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 #include <gst/gst_global.h>

    24 #include <unistd.h>

    25 

    26 #include <gst/check/gstcheck.h>

    27 

    28 #define LOG_FILE "c:\\logs\\fakesink_log1.txt"

    29 #include "std_log_result.h"

    30 #define LOG_FILENAME_LINE __FILE__, __LINE__

    31 //char* xmlfile = "fakesink";

    32 

    33 void create_xml(int result)

    34 {

    35     if(result)

    36         assert_failed = 1;

    37     

    38     testResultXml(xmlfile);

    39     close_log_file();

    40 }

    41 

    42 typedef struct

    43 {

    44   GstPad *pad;

    45   GstBuffer *buffer;

    46   GThread *thread;

    47   GstFlowReturn ret;

    48 } ChainData;

    49 

    50 static gpointer

    51 chain_async_buffer (gpointer data)

    52 {

    53   ChainData *chain_data = (ChainData *) data;

    54 

    55   chain_data->ret = gst_pad_chain (chain_data->pad, chain_data->buffer);

    56 

    57   return chain_data;

    58 }

    59 

    60 static ChainData *

    61 chain_async (GstPad * pad, GstBuffer * buffer)

    62 {

    63   GThread *thread;

    64   ChainData *chain_data;

    65   GError *error = NULL;

    66 

    67   chain_data = g_new (ChainData, 1);

    68   chain_data->pad = pad;

    69   chain_data->buffer = buffer;

    70   chain_data->ret = GST_FLOW_ERROR;

    71 

    72   thread = g_thread_create (chain_async_buffer, chain_data, TRUE, &error);

    73   if (error != NULL) {

    74     g_warning ("could not create thread reason: %s", error->message);

    75     g_free (chain_data);

    76     return NULL;

    77   }

    78   chain_data->thread = thread;

    79 

    80   return chain_data;

    81 }

    82 

    83 static GstFlowReturn

    84 chain_async_return (ChainData * data)

    85 {

    86   GstFlowReturn ret;

    87 

    88   g_thread_join (data->thread);

    89   ret = data->ret;

    90   g_free (data);

    91 

    92   return ret;

    93 }

    94 

    95 void test_clipping()

    96 {

    97   GstElement *sink;

    98   GstPad *sinkpad;

    99   GstStateChangeReturn ret;

   100 

   101   //xmlfile = "test_clipping";

   102   std_log(LOG_FILENAME_LINE, "Test Started test_clipping");

   103   /* create sink */

   104   sink = gst_element_factory_make ("fakesink", "sink");

   105   fail_if (sink == NULL);

   106   TEST_ASSERT_FAIL

   107 

   108   sinkpad = gst_element_get_pad (sink, "sink");

   109   fail_if (sinkpad == NULL);

   110   TEST_ASSERT_FAIL

   111 

   112   /* make element ready to accept data */

   113   ret = gst_element_set_state (sink, GST_STATE_PAUSED);

   114   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   115   TEST_ASSERT_FAIL

   116 

   117   /* send segment */

   118   {

   119     GstEvent *segment;

   120     gboolean eret;

   121 

   122     GST_DEBUG ("sending segment");

   123     segment = gst_event_new_new_segment (FALSE,

   124         1.0, GST_FORMAT_TIME, 1 * GST_SECOND, 5 * GST_SECOND, 1 * GST_SECOND);

   125 

   126     eret = gst_pad_send_event (sinkpad, segment);

   127     fail_if (eret == FALSE);

   128     TEST_ASSERT_FAIL

   129   }

   130 

   131   /* new segment should not have finished preroll */

   132   ret = gst_element_get_state (sink, NULL, NULL, 0);

   133   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   134   TEST_ASSERT_FAIL

   135 

   136   /* send buffer that should be dropped */

   137   {

   138     GstBuffer *buffer;

   139     GstFlowReturn fret;

   140 

   141     buffer = gst_buffer_new ();

   142     GST_BUFFER_TIMESTAMP (buffer) = 0;

   143     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;

   144 

   145     GST_DEBUG ("sending buffer to be dropped");

   146     fret = gst_pad_chain (sinkpad, buffer);

   147     fail_if (fret != GST_FLOW_OK);

   148     TEST_ASSERT_FAIL

   149   }

   150   /* dropped buffer should not have finished preroll */

   151   ret = gst_element_get_state (sink, NULL, NULL, 0);

   152   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   153   TEST_ASSERT_FAIL

   154 

   155   /* send buffer that should be dropped */

   156   {

   157     GstBuffer *buffer;

   158     GstFlowReturn fret;

   159 

   160     buffer = gst_buffer_new ();

   161     GST_BUFFER_TIMESTAMP (buffer) = 5 * GST_SECOND;

   162     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;

   163 

   164     GST_DEBUG ("sending buffer to be dropped");

   165     fret = gst_pad_chain (sinkpad, buffer);

   166     fail_if (fret != GST_FLOW_OK);

   167     TEST_ASSERT_FAIL

   168   }

   169   /* dropped buffer should not have finished preroll */

   170   ret = gst_element_get_state (sink, NULL, NULL, 0);

   171   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   172   TEST_ASSERT_FAIL

   173 

   174   /* send buffer that should block and finish preroll */

   175   {

   176     GstBuffer *buffer;

   177     GstFlowReturn fret;

   178     ChainData *data;

   179     GstState current, pending;

   180 

   181     buffer = gst_buffer_new ();

   182     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;

   183     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;

   184 

   185     GST_DEBUG ("sending buffer to finish preroll");

   186     data = chain_async (sinkpad, buffer);

   187     fail_if (data == NULL);

   188     TEST_ASSERT_FAIL

   189 

   190     /* state should now eventually change to PAUSED */

   191     ret = gst_element_get_state (sink, &current, &pending, GST_CLOCK_TIME_NONE);

   192     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);

   193     fail_unless (current == GST_STATE_PAUSED);

   194     fail_unless (pending == GST_STATE_VOID_PENDING);

   195     TEST_ASSERT_FAIL

   196 

   197     /* playing should render the buffer */

   198     ret = gst_element_set_state (sink, GST_STATE_PLAYING);

   199     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);

   200     TEST_ASSERT_FAIL

   201 

   202     /* and we should get a success return value */

   203     fret = chain_async_return (data);

   204     fail_if (fret != GST_FLOW_OK);

   205     TEST_ASSERT_FAIL

   206   }

   207 

   208   /* send some buffer that will be dropped or clipped, this can 

   209    * only be observed in the debug log. */

   210   {

   211     GstBuffer *buffer;

   212     GstFlowReturn fret;

   213 

   214     buffer = gst_buffer_new ();

   215     GST_BUFFER_TIMESTAMP (buffer) = 6 * GST_SECOND;

   216     GST_BUFFER_DURATION (buffer) = 1 * GST_MSECOND;

   217 

   218     /* should be dropped */

   219     GST_DEBUG ("sending buffer to drop");

   220     fret = gst_pad_chain (sinkpad, buffer);

   221     fail_if (fret != GST_FLOW_OK);

   222     TEST_ASSERT_FAIL

   223 

   224     buffer = gst_buffer_new ();

   225     GST_BUFFER_TIMESTAMP (buffer) = 0 * GST_SECOND;

   226     GST_BUFFER_DURATION (buffer) = 2 * GST_SECOND;

   227 

   228     /* should be clipped */

   229     GST_DEBUG ("sending buffer to clip");

   230     fret = gst_pad_chain (sinkpad, buffer);

   231     fail_if (fret != GST_FLOW_OK);

   232     TEST_ASSERT_FAIL

   233 

   234     buffer = gst_buffer_new ();

   235     GST_BUFFER_TIMESTAMP (buffer) = 4 * GST_SECOND;

   236     GST_BUFFER_DURATION (buffer) = 2 * GST_SECOND;

   237 

   238     /* should be clipped */

   239     GST_DEBUG ("sending buffer to clip");

   240     fret = gst_pad_chain (sinkpad, buffer);

   241     fail_if (fret != GST_FLOW_OK);

   242     TEST_ASSERT_FAIL

   243   }

   244 

   245   gst_element_set_state (sink, GST_STATE_NULL);

   246   gst_element_get_state (sink, NULL, NULL, GST_CLOCK_TIME_NONE);

   247   gst_object_unref (sinkpad);

   248   gst_object_unref (sink);

   249   std_log(LOG_FILENAME_LINE, "Test Successful");

   250     create_xml(0);

   251 }

   252 

   253 

   254 

   255 void test_preroll_sync()

   256 {

   257   GstElement *pipeline, *sink;

   258   GstPad *sinkpad;

   259   GstStateChangeReturn ret;

   260 

   261   //xmlfile = "test_preroll_sync";

   262   std_log(LOG_FILENAME_LINE, "Test Started test_preroll_sync");

   263   /* create sink */

   264   pipeline = gst_pipeline_new ("pipeline");

   265   fail_if (pipeline == NULL);

   266   TEST_ASSERT_FAIL

   267 

   268   sink = gst_element_factory_make ("fakesink", "sink");

   269   fail_if (sink == NULL);

   270   TEST_ASSERT_FAIL

   271   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);

   272 

   273   gst_bin_add (GST_BIN (pipeline), sink);

   274 

   275   sinkpad = gst_element_get_pad (sink, "sink");

   276   fail_if (sinkpad == NULL);

   277   TEST_ASSERT_FAIL

   278 

   279   /* make pipeline and element ready to accept data */

   280   ret = gst_element_set_state (pipeline, GST_STATE_PAUSED);

   281   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   282   TEST_ASSERT_FAIL

   283 

   284   /* send segment */

   285   {

   286     GstEvent *segment;

   287     gboolean eret;

   288 

   289     GST_DEBUG ("sending segment");

   290     segment = gst_event_new_new_segment (FALSE,

   291         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);

   292 

   293     eret = gst_pad_send_event (sinkpad, segment);

   294     fail_if (eret == FALSE);

   295     TEST_ASSERT_FAIL

   296   }

   297 

   298   /* send buffer that should block and finish preroll */

   299   {

   300     GstBuffer *buffer;

   301     GstFlowReturn fret;

   302     ChainData *data;

   303     GstState current, pending;

   304 

   305     buffer = gst_buffer_new ();

   306     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;

   307     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;

   308 

   309     GST_DEBUG ("sending buffer to finish preroll");

   310     data = chain_async (sinkpad, buffer);

   311     fail_if (data == NULL);

   312     TEST_ASSERT_FAIL

   313 

   314     /* state should now eventually change to PAUSED */

   315     ret =

   316         gst_element_get_state (pipeline, &current, &pending,

   317         GST_CLOCK_TIME_NONE);

   318     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);

   319     fail_unless (current == GST_STATE_PAUSED);

   320     fail_unless (pending == GST_STATE_VOID_PENDING);

   321     TEST_ASSERT_FAIL

   322 

   323     /* playing should render the buffer */

   324     ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);

   325     fail_unless (ret == GST_STATE_CHANGE_SUCCESS);

   326     TEST_ASSERT_FAIL

   327 

   328     /* and we should get a success return value */

   329     fret = chain_async_return (data);

   330     fail_if (fret != GST_FLOW_OK);

   331     TEST_ASSERT_FAIL

   332   }

   333   gst_element_set_state (pipeline, GST_STATE_NULL);

   334   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);

   335   gst_object_unref (sinkpad);

   336   gst_object_unref (pipeline);

   337   std_log(LOG_FILENAME_LINE, "Test Successful");

   338     create_xml(0);

   339 }

   340 

   341 

   342 

   343 /* after EOS, we refuse everything */

   344 void test_eos()

   345 {

   346   GstElement *pipeline, *sink;

   347   GstPad *sinkpad;

   348   GstStateChangeReturn ret;

   349   GstMessage *message;

   350   GstBus *bus;

   351 

   352   //xmlfile = "test_eos";

   353   std_log(LOG_FILENAME_LINE, "Test Started test_eos");

   354   /* create sink */

   355   pipeline = gst_pipeline_new ("pipeline");

   356   fail_if (pipeline == NULL);

   357   TEST_ASSERT_FAIL

   358 

   359   bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (pipeline));

   360   fail_if (bus == NULL);

   361   TEST_ASSERT_FAIL

   362 

   363   sink = gst_element_factory_make ("fakesink", "sink");

   364   fail_if (sink == NULL);

   365   TEST_ASSERT_FAIL

   366   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);

   367 

   368   gst_bin_add (GST_BIN (pipeline), sink);

   369 

   370   sinkpad = gst_element_get_pad (sink, "sink");

   371   fail_if (sinkpad == NULL);

   372   TEST_ASSERT_FAIL

   373 

   374   /* make pipeline and element ready to accept data */

   375   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);

   376   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   377   TEST_ASSERT_FAIL

   378 

   379   /* send EOS, this should work fine */

   380   {

   381     GstEvent *eos;

   382     gboolean eret;

   383 

   384     GST_DEBUG ("sending EOS");

   385     eos = gst_event_new_eos ();

   386 

   387     eret = gst_pad_send_event (sinkpad, eos);

   388     fail_if (eret == FALSE);

   389     TEST_ASSERT_FAIL

   390   }

   391 

   392   /* wait for preroll */

   393   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);

   394 

   395   /* EOS should be on the bus at some point */

   396   while (TRUE) {

   397     GstMessageType type;

   398 

   399     /* blocking wait for messages */

   400     message = gst_bus_timed_pop (bus, GST_CLOCK_TIME_NONE);

   401     type = GST_MESSAGE_TYPE (message);

   402     gst_message_unref (message);

   403 

   404     GST_DEBUG ("got message %s", gst_message_type_get_name (type));

   405 

   406     if (type == GST_MESSAGE_EOS)

   407       break;

   408   }

   409   gst_object_unref (bus);

   410 

   411   /* send another EOS, this should fail */

   412   {

   413     GstEvent *eos;

   414     gboolean eret;

   415 

   416     GST_DEBUG ("sending second EOS");

   417     eos = gst_event_new_eos ();

   418 

   419     eret = gst_pad_send_event (sinkpad, eos);

   420     fail_if (eret == TRUE);

   421     TEST_ASSERT_FAIL

   422   }

   423 

   424   /* send segment, this should fail */

   425   {

   426     GstEvent *segment;

   427     gboolean eret;

   428 

   429     GST_DEBUG ("sending segment");

   430     segment = gst_event_new_new_segment (FALSE,

   431         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);

   432 

   433     eret = gst_pad_send_event (sinkpad, segment);

   434     fail_if (eret == TRUE);

   435     TEST_ASSERT_FAIL

   436   }

   437 

   438   /* send buffer that should fail after EOS */

   439   {

   440     GstBuffer *buffer;

   441     GstFlowReturn fret;

   442 

   443     buffer = gst_buffer_new ();

   444     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;

   445     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;

   446 

   447     GST_DEBUG ("sending buffer");

   448 

   449     /* buffer after EOS is not UNEXPECTED */

   450     fret = gst_pad_chain (sinkpad, buffer);

   451     fail_unless (fret == GST_FLOW_UNEXPECTED);

   452     TEST_ASSERT_FAIL

   453   }

   454 

   455   /* flush, EOS state is flushed again. */

   456   {

   457     GstEvent *event;

   458     gboolean eret;

   459 

   460     GST_DEBUG ("sending FLUSH_START");

   461     event = gst_event_new_flush_start ();

   462     eret = gst_pad_send_event (sinkpad, event);

   463     fail_unless (eret == TRUE);

   464     TEST_ASSERT_FAIL

   465 

   466     GST_DEBUG ("sending FLUSH_STOP");

   467     event = gst_event_new_flush_stop ();

   468     eret = gst_pad_send_event (sinkpad, event);

   469     fail_unless (eret == TRUE);

   470     TEST_ASSERT_FAIL

   471   }

   472 

   473   /* send segment, this should now work again */

   474   {

   475     GstEvent *segment;

   476     gboolean eret;

   477 

   478     GST_DEBUG ("sending segment");

   479     segment = gst_event_new_new_segment (FALSE,

   480         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);

   481 

   482     eret = gst_pad_send_event (sinkpad, segment);

   483     fail_unless (eret == TRUE);

   484     TEST_ASSERT_FAIL

   485   }

   486 

   487   /* send buffer that should work and block */

   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     fret = gst_pad_chain (sinkpad, buffer);

   499     fail_unless (fret == GST_FLOW_OK);

   500     TEST_ASSERT_FAIL

   501   }

   502 

   503   gst_element_set_state (pipeline, GST_STATE_NULL);

   504   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);

   505   gst_object_unref (sinkpad);

   506   gst_object_unref (pipeline);

   507   std_log(LOG_FILENAME_LINE, "Test Successful");

   508     create_xml(0);

   509 }

   510 

   511 

   512 

   513 /* test EOS triggered by the element */

   514 void test_eos2()

   515 {

   516   GstElement *pipeline, *sink;

   517   GstPad *sinkpad;

   518   GstStateChangeReturn ret;

   519 

   520   //xmlfile = "test_eos2";

   521   std_log(LOG_FILENAME_LINE, "Test Started test_eos2");

   522   /* create sink */

   523   pipeline = gst_pipeline_new ("pipeline");

   524   fail_if (pipeline == NULL);

   525   TEST_ASSERT_FAIL

   526 

   527   sink = gst_element_factory_make ("fakesink", "sink");

   528   fail_if (sink == NULL);

   529   TEST_ASSERT_FAIL

   530   g_object_set (G_OBJECT (sink), "sync", TRUE, NULL);

   531   g_object_set (G_OBJECT (sink), "num-buffers", 1, NULL);

   532 

   533   gst_bin_add (GST_BIN (pipeline), sink);

   534 

   535   sinkpad = gst_element_get_pad (sink, "sink");

   536   fail_if (sinkpad == NULL);

   537   TEST_ASSERT_FAIL

   538 

   539   /* make pipeline and element ready to accept data */

   540   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);

   541   fail_unless (ret == GST_STATE_CHANGE_ASYNC);

   542   TEST_ASSERT_FAIL

   543 

   544   /* send segment, this should work */

   545   {

   546     GstEvent *segment;

   547     gboolean eret;

   548 

   549     GST_DEBUG ("sending segment");

   550     segment = gst_event_new_new_segment (FALSE,

   551         1.0, GST_FORMAT_TIME, 0 * GST_SECOND, 2 * GST_SECOND, 0 * GST_SECOND);

   552 

   553     eret = gst_pad_send_event (sinkpad, segment);

   554     fail_if (eret == FALSE);

   555     TEST_ASSERT_FAIL

   556   }

   557 

   558   /* send buffer that should return UNEXPECTED */

   559   {

   560     GstBuffer *buffer;

   561     GstFlowReturn fret;

   562 

   563     buffer = gst_buffer_new ();

   564     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;

   565     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;

   566 

   567     GST_DEBUG ("sending buffer");

   568 

   569     /* this buffer will generate UNEXPECTED */

   570     fret = gst_pad_chain (sinkpad, buffer);

   571     fail_unless (fret == GST_FLOW_UNEXPECTED);

   572     TEST_ASSERT_FAIL

   573   }

   574 

   575   /* send buffer that should return UNEXPECTED */

   576   {

   577     GstBuffer *buffer;

   578     GstFlowReturn fret;

   579 

   580     buffer = gst_buffer_new ();

   581     GST_BUFFER_TIMESTAMP (buffer) = 1 * GST_SECOND;

   582     GST_BUFFER_DURATION (buffer) = 1 * GST_SECOND;

   583 

   584     GST_DEBUG ("sending buffer");

   585 

   586     fret = gst_pad_chain (sinkpad, buffer);

   587     fail_unless (fret == GST_FLOW_UNEXPECTED);

   588     TEST_ASSERT_FAIL

   589   }

   590 

   591   gst_element_set_state (pipeline, GST_STATE_NULL);

   592   gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);

   593   gst_object_unref (sinkpad);

   594   gst_object_unref (pipeline);

   595   std_log(LOG_FILENAME_LINE, "Test Successful");

   596     create_xml(0);

   597 }

   598 

   599 

   600 // static Suite *

   601 // fakesink_suite (void)

   602 // {

   603 //   Suite *s = suite_create ("fakesink");

   604 //   TCase *tc_chain = tcase_create ("general");

   605 //

   606 //   suite_add_tcase (s, tc_chain);

   607 //   tcase_add_test (tc_chain, test_clipping);

   608 //   tcase_add_test (tc_chain, test_preroll_sync);

   609 //   tcase_add_test (tc_chain, test_eos);

   610 //   tcase_add_test (tc_chain, test_eos2);

   611 //

   612 //   return s;

   613 // }

   614 

   615 void (*fn[5]) (void) = {

   616         test_clipping,

   617         test_preroll_sync,

   618         test_eos,

   619         test_eos2

   620 };

   621 

   622 char *args[] = {

   623         "test_clipping",

   624         "test_preroll_sync",

   625         "test_eos",

   626         "test_eos2",

   627 };

   628 

   629 GST_CHECK_MAIN (fakesink);