1  /*

     2  *  Copyright © 2008 Nokia Corporation.

     3  *  This material, including documentation and any related 

     4  *  computer programs, is protected by copyright controlled by 

     5  *  Nokia Corporation. All rights are reserved. Copying, 

     6  *  including reproducing, storing, adapting or translating, any 

     7  *  or all of this material requires the prior written consent of 

     8  *  Nokia Corporation. This material also contains confidential 

     9  *  information which may not be disclosed to others without the 

    10  *  prior written consent of Nokia Corporation.

    11  * ============================================================================

    12  */

    13 

    14 /* GStreamer

    15  * Copyright (C) 2005 Wim Taymans <wim@fluendo.com>

    16  *

    17  * gstsystemclock.c: Unit test for GstSystemClock

    18  *

    19  * This library is free software; you can redistribute it and/or

    20  * modify it under the terms of the GNU Library General Public

    21  * License as published by the Free Software Foundation; either

    22  * version 2 of the License, or (at your option) any later version.

    23  *

    24  * This library is distributed in the hope that it will be useful,

    25  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    27  * Library General Public License for more details.

    28  *

    29  * You should have received a copy of the GNU Library General Public

    30  * License along with this library; if not, write to the

    31  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    32  * Boston, MA 02111-1307, USA.

    33  */

    34 

    35 

    36 #include <gst/gst_global.h>

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

    38 

    39 #define LOG_FILE "c:\\logs\\gstsystemclock_logs.txt" 

    40 #include "std_log_result.h" 

    41 #define LOG_FILENAME_LINE __FILE__, __LINE__

    42 

    43 //char* xmlfile = "gstsystemclock";

    44 

    45 void create_xml(int result)

    46 {

    47     if(result)

    48         assert_failed = 1;

    49     

    50     testResultXml(xmlfile);

    51     close_log_file();

    52 }

    53 

    54 

    55 /* see if the defines make sense */

    56 void test_range()

    57 {

    58   GstClockTime time, time2;

    59   

    60   xmlfile = "test_range";

    61   std_log(LOG_FILENAME_LINE, "Test Started test_range");

    62 

    63   time = GST_SECOND;

    64   fail_unless (time == G_GUINT64_CONSTANT (1000000000));

    65   

    66 

    67   time2 = time / 1000;

    68   fail_unless (time2 == 1000000);

    69   

    70   fail_unless (time2 == GST_MSECOND);

    71   

    72   fail_unless (time2 == GST_TIME_AS_USECONDS (time));

    73   

    74 

    75   time2 = time / 1000000;

    76   fail_unless (time2 == 1000);

    77   

    78   fail_unless (time2 == GST_USECOND);

    79   

    80   fail_unless (time2 == GST_TIME_AS_MSECONDS (time));

    81   

    82   

    83   std_log(LOG_FILENAME_LINE, "Test Successful");

    84   create_xml(0);

    85 }

    86 

    87 

    88 #define TIME_UNIT (GST_SECOND / 5)

    89 static void

    90 gst_clock_debug (GstClock * clock)

    91 {

    92   GstClockTime time;

    93 

    94   time = gst_clock_get_time (clock);

    95   GST_DEBUG ("Clock info: time %" GST_TIME_FORMAT, GST_TIME_ARGS (time));

    96 }

    97 

    98 static gboolean

    99 ok_callback (GstClock * clock, GstClockTime time,

   100     GstClockID id, gpointer user_data)

   101 {

   102   GST_LOG ("unlocked async id %p", id);

   103   return FALSE;

   104 }

   105 

   106 static gboolean

   107 error_callback (GstClock * clock, GstClockTime time,

   108     GstClockID id, gpointer user_data)

   109 {

   110   GST_WARNING ("unlocked unscheduled async id %p, this is wrong", id);

   111   fail_if (TRUE);

   112 

   113   return FALSE;

   114 }

   115 

   116 static gboolean

   117 store_callback (GstClock * clock, GstClockTime time,

   118     GstClockID id, gpointer user_data)

   119 {

   120   GList **list = user_data;

   121 

   122   GST_DEBUG ("unlocked async id %p", id);

   123   *list = g_list_append (*list, id);

   124   return FALSE;

   125 }

   126 

   127 static gboolean

   128 notify_callback (GstClock * clock, GstClockTime time,

   129     GstClockID id, gpointer user_data)

   130 {

   131   gboolean *ret = (gboolean *) user_data;

   132 

   133   if (ret != NULL)

   134     *ret = TRUE;

   135 

   136   return FALSE;

   137 }

   138 

   139 void test_single_shot()

   140 {

   141   GstClock *clock;

   142   GstClockID id, id2;

   143   GstClockTime base;

   144   GstClockReturn result;

   145   

   146 	xmlfile = "test_single_shot";

   147   std_log(LOG_FILENAME_LINE, "Test Started test_single_shot");

   148 

   149   clock = gst_system_clock_obtain ();

   150   fail_unless (clock != NULL, "Could not create instance of GstSystemClock");

   151   

   152 

   153   gst_clock_debug (clock);

   154   base = gst_clock_get_time (clock);

   155 

   156   id = gst_clock_new_single_shot_id (clock, base + TIME_UNIT);

   157   fail_unless (id != NULL, "Could not create single shot id");

   158   

   159 

   160   GST_DEBUG ("waiting one time unit");

   161   result = gst_clock_id_wait (id, NULL);

   162   gst_clock_debug (clock);

   163   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK (result=%d)",

   164       result);

   165   

   166   fail_unless (gst_clock_get_time (clock) > (base + TIME_UNIT),

   167       "target time has not been reached");

   168       

   169 

   170   GST_DEBUG ("waiting in the past");

   171   result = gst_clock_id_wait (id, NULL);

   172   gst_clock_debug (clock);

   173   fail_unless (result == GST_CLOCK_EARLY,

   174       "Waiting did not return EARLY(result=%d)", result);

   175       

   176   gst_clock_id_unref (id);

   177 

   178   id = gst_clock_new_single_shot_id (clock, base + 2 * TIME_UNIT);

   179   GST_DEBUG ("waiting one second async id %p", id);

   180   result = gst_clock_id_wait_async (id, ok_callback, NULL);

   181   gst_clock_id_unref (id);

   182   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   183   

   184   g_usleep (TIME_UNIT / (2 * 1000));

   185 

   186   id = gst_clock_new_single_shot_id (clock, base + 5 * TIME_UNIT);

   187   GST_DEBUG ("waiting one second async, with cancel on id %p", id);

   188   result = gst_clock_id_wait_async (id, error_callback, NULL);

   189   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   190   

   191   g_usleep (TIME_UNIT / (2 * 1000));

   192   GST_DEBUG ("cancel id %p after half a time unit", id);

   193   gst_clock_id_unschedule (id);

   194   gst_clock_id_unref (id);

   195   GST_DEBUG ("canceled id %p", id);

   196 

   197   GST_DEBUG ("waiting multiple one second async, with cancel");

   198   id = gst_clock_new_single_shot_id (clock, base + 5 * TIME_UNIT);

   199   id2 = gst_clock_new_single_shot_id (clock, base + 6 * TIME_UNIT);

   200   GST_DEBUG ("waiting id %p", id);

   201   result = gst_clock_id_wait_async (id, ok_callback, NULL);

   202   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   203   

   204   gst_clock_id_unref (id);

   205   GST_DEBUG ("waiting id %p", id2);

   206   result = gst_clock_id_wait_async (id2, error_callback, NULL);

   207   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   208   

   209   g_usleep (TIME_UNIT / (2 * 1000));

   210   GST_DEBUG ("cancel id %p after half a time unit", id2);

   211   gst_clock_id_unschedule (id2);

   212   GST_DEBUG ("canceled id %p", id2);

   213   gst_clock_id_unref (id2);

   214   g_usleep (TIME_UNIT / (2 * 1000));

   215   

   216   std_log(LOG_FILENAME_LINE, "Test Successful");

   217   create_xml(0);

   218 }

   219 

   220 

   221 void test_periodic_shot()

   222 {

   223   GstClock *clock;

   224   GstClockID id, id2;

   225   GstClockTime base;

   226   GstClockReturn result;

   227 

   228 	xmlfile = "test_periodic_shot";

   229   std_log(LOG_FILENAME_LINE, "Test Started test_periodic_shot");

   230   

   231   clock = gst_system_clock_obtain ();

   232   fail_unless (clock != NULL, "Could not create instance of GstSystemClock");

   233   

   234 

   235   gst_clock_debug (clock);

   236   base = gst_clock_get_time (clock);

   237 

   238   // signal every half a time unit 

   239   id = gst_clock_new_periodic_id (clock, base + TIME_UNIT, TIME_UNIT / 2);

   240   fail_unless (id != NULL, "Could not create periodic id");

   241   

   242 

   243   GST_DEBUG ("waiting one time unit");

   244   result = gst_clock_id_wait (id, NULL);

   245   gst_clock_debug (clock);

   246   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   247   

   248 

   249   GST_DEBUG ("waiting for the next");

   250   result = gst_clock_id_wait (id, NULL);

   251   gst_clock_debug (clock);

   252   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   253   

   254 

   255   GST_DEBUG ("waiting for the next async %p", id);

   256   result = gst_clock_id_wait_async (id, ok_callback, NULL);

   257   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   258   

   259   g_usleep (TIME_UNIT / (2 * 1000));

   260 

   261   GST_DEBUG ("waiting some more for the next async %p", id);

   262   result = gst_clock_id_wait_async (id, ok_callback, NULL);

   263   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   264   

   265   g_usleep (TIME_UNIT / (2 * 1000));

   266 

   267   id2 = gst_clock_new_periodic_id (clock, base + TIME_UNIT, TIME_UNIT / 2);

   268   fail_unless (id2 != NULL, "Could not create second periodic id");

   269   

   270 

   271   GST_DEBUG ("waiting some more for another async %p", id2);

   272   result = gst_clock_id_wait_async (id2, ok_callback, NULL);

   273   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   274   

   275   g_usleep (TIME_UNIT / (2 * 1000));

   276 

   277   GST_DEBUG ("unschedule %p", id);

   278   gst_clock_id_unschedule (id);

   279 

   280   // entry cannot be used again 

   281   result = gst_clock_id_wait_async (id, error_callback, NULL);

   282   fail_unless (result == GST_CLOCK_UNSCHEDULED,

   283       "Waiting did not return UNSCHEDULED");

   284       

   285   result = gst_clock_id_wait (id, NULL);

   286   fail_unless (result == GST_CLOCK_UNSCHEDULED,

   287       "Waiting did not return UNSCHEDULED");

   288       

   289   g_usleep (TIME_UNIT / (2 * 1000));

   290 

   291   // clean up 

   292   gst_clock_id_unref (id);

   293   

   294   std_log(LOG_FILENAME_LINE, "Test Successful");

   295   create_xml(0);

   296 }

   297 

   298 

   299 void test_async_order()

   300 {

   301   GstClock *clock;

   302   GstClockID id1, id2;

   303   GList *cb_list = NULL, *next;

   304   GstClockTime base;

   305   GstClockReturn result;

   306 

   307 	xmlfile = "test_async_order";

   308   std_log(LOG_FILENAME_LINE, "Test Started test_async_order");

   309   

   310   

   311   clock = gst_system_clock_obtain ();

   312   fail_unless (clock != NULL, "Could not create instance of GstSystemClock");

   313   

   314 

   315   gst_clock_debug (clock);

   316   base = gst_clock_get_time (clock);

   317 

   318   id1 = gst_clock_new_single_shot_id (clock, base + 2 * TIME_UNIT);

   319   id2 = gst_clock_new_single_shot_id (clock, base + 1 * TIME_UNIT);

   320   result = gst_clock_id_wait_async (id1, store_callback, &cb_list);

   321   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   322   

   323   g_usleep (TIME_UNIT / (2 * 1000));

   324   result = gst_clock_id_wait_async (id2, store_callback, &cb_list);

   325   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   326   

   327   g_usleep (TIME_UNIT / 1000);

   328   // at this point at least one of the timers should have timed out 

   329   fail_unless (cb_list != NULL, "expected notification");

   330   

   331   fail_unless (cb_list->data == id2,

   332       "Expected notification for id2 to come first");

   333       

   334   g_usleep (TIME_UNIT / 1000);

   335   // now both should have timed out 

   336   next = g_list_next (cb_list);

   337   fail_unless (next != NULL, "expected second notification");

   338   

   339   fail_unless (next->data == id1, "Missing notification for id1");

   340   

   341   gst_clock_id_unref (id1);

   342   gst_clock_id_unref (id2);

   343   g_list_free (cb_list);

   344   

   345   std_log(LOG_FILENAME_LINE, "Test Successful");

   346   create_xml(0);

   347 }

   348 

   349 

   350 void test_periodic_multi()

   351 {

   352   GstClock *clock;

   353   GstClockID clock_id;

   354   GstClockTime base;

   355   GstClockReturn result;

   356   gboolean got_callback = FALSE;

   357   

   358   xmlfile = "test_periodic_multi";

   359   std_log(LOG_FILENAME_LINE, "Test Started test_periodic_multi");

   360 

   361 

   362   clock = gst_system_clock_obtain ();

   363   fail_unless (clock != NULL, "Could not create instance of GstSystemClock");

   364   

   365 

   366   gst_clock_debug (clock);

   367   base = gst_clock_get_time (clock);

   368 

   369   clock_id = gst_clock_new_periodic_id (clock, base + TIME_UNIT, TIME_UNIT);

   370   gst_clock_id_wait (clock_id, NULL);

   371   fail_unless (gst_clock_get_time (clock) >= base + TIME_UNIT);

   372   

   373   fail_unless (gst_clock_get_time (clock) < base + 2 * TIME_UNIT);

   374   

   375 

   376   // now perform a concurrent wait and wait_async 

   377 

   378   result = gst_clock_id_wait_async (clock_id, notify_callback, &got_callback);

   379   fail_unless (result == GST_CLOCK_OK, "Async waiting did not return OK");

   380   

   381   fail_unless (got_callback == FALSE);

   382   

   383   result = gst_clock_id_wait (clock_id, NULL);

   384   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   385   

   386   fail_unless (gst_clock_get_time (clock) >= base + 2 * TIME_UNIT);

   387   

   388   // give the async thread some time to call our callback: 

   389   g_usleep (TIME_UNIT / (10 * 1000));

   390   fail_unless (got_callback == TRUE, "got no async callback (1)");

   391   

   392   fail_unless (gst_clock_get_time (clock) < base + 3 * TIME_UNIT);

   393   

   394   got_callback = FALSE;

   395 

   396   result = gst_clock_id_wait (clock_id, NULL);

   397   fail_unless (result == GST_CLOCK_OK, "Waiting did not return OK");

   398   

   399   fail_unless (gst_clock_get_time (clock) >= base + 3 * TIME_UNIT);

   400   

   401   // give the async thread some time to call our callback: 

   402   g_usleep (TIME_UNIT / (10 * 1000));

   403   fail_unless (got_callback == TRUE, "got no async callback (2)");

   404   

   405   fail_unless (gst_clock_get_time (clock) < base + 4 * TIME_UNIT);

   406   

   407   

   408   std_log(LOG_FILENAME_LINE, "Test Successful");

   409   create_xml(0);

   410 }

   411 

   412 

   413 

   414 /* test if a blocking wait, unblocked by an async entry continues to be

   415  * scheduled */

   416 typedef struct

   417 {

   418   GstClock *clock;

   419   GstClockID id;

   420   GstClockTimeDiff jitter;

   421   GstClockReturn ret;

   422 } MixedInfo;

   423 

   424 static gpointer

   425 mixed_thread (MixedInfo * info)

   426 {

   427   info->ret = gst_clock_id_wait (info->id, &info->jitter);

   428   return NULL;

   429 }

   430 

   431 static gboolean

   432 mixed_async_cb (GstClock * clock, GstClockTime time,

   433     GstClockID id, gpointer user_data)

   434 {

   435   return TRUE;

   436 }

   437 

   438 void test_mixed()

   439 {

   440   GThread *thread;

   441   GError *error = NULL;

   442   MixedInfo info;

   443   GstClockTime base;

   444   GstClockID id;

   445   

   446   xmlfile = "test_mixed";

   447   std_log(LOG_FILENAME_LINE, "Test Started test_mixed");

   448 

   449 

   450   info.clock = gst_system_clock_obtain ();

   451   fail_unless (info.clock != NULL,

   452       "Could not create instance of GstSystemClock");

   453       

   454 

   455   /* get current time of the clock as base time */

   456   base = gst_clock_get_time (info.clock);

   457 

   458   /* create entry to wait for 1 second */

   459   info.id = gst_clock_new_single_shot_id (info.clock, base + GST_SECOND);

   460 

   461   /* make and start an entry that is scheduled every 10ms */

   462   id = gst_clock_new_periodic_id (info.clock, base, 10 * GST_MSECOND);

   463 

   464   /* start waiting for the entry */

   465   thread = g_thread_create ((GThreadFunc) mixed_thread, &info, TRUE, &error);

   466   fail_unless (error == NULL, "error creating thread");

   467   

   468   fail_unless (thread != NULL, "Could not create thread");

   469   

   470 

   471   /* wait half a second so we are sure to be in the thread */

   472   g_usleep (G_USEC_PER_SEC / 2);

   473 

   474   /* start scheduling the entry */

   475   gst_clock_id_wait_async (id, mixed_async_cb, NULL);

   476 

   477   /* wait for thread to finish */

   478   g_thread_join (thread);

   479   /* entry must have timed out correctly */

   480   fail_unless (info.ret == GST_CLOCK_OK, "clock return was %d", info.ret);

   481   

   482 

   483   gst_clock_id_unschedule (id);

   484   gst_clock_id_unref (id);

   485   gst_clock_id_unref (info.id);

   486   gst_object_unref (info.clock);

   487   

   488   std_log(LOG_FILENAME_LINE, "Test Successful");

   489   create_xml(0);

   490   

   491 }

   492 

   493 void test_diff()

   494 {

   495 

   496 

   497   GstClockTime time1[] = { 0, (GstClockTime) - 1, 0, 1, 2 * GST_SECOND,(GstClockTime) - GST_SECOND, (GstClockTime) - GST_SECOND};

   498   GstClockTime time2[] = { 0, 1, 1, 0, 1 * GST_SECOND, (GstClockTime) - GST_SECOND, GST_SECOND };

   499   GstClockTimeDiff d[] = { 0, 2, 1, -1, -GST_SECOND, 0, 2 * GST_SECOND };

   500   guint i;

   501   

   502     xmlfile = "test_diff";

   503   std_log(LOG_FILENAME_LINE, "Test Started test_diff");

   504 

   505   for (i = 0; i < G_N_ELEMENTS (d); i++) {

   506     fail_if (d[i] != GST_CLOCK_DIFF (time1[i], time2[i]));

   507   }

   508   

   509   std_log(LOG_FILENAME_LINE, "Test Successful");

   510   create_xml(0);

   511 }

   512 

   513 void test_signedness()

   514 {

   515 

   516   

   517   GstClockTime time[] = { 0, 1, G_MAXUINT64 / GST_SECOND };

   518   GstClockTimeDiff diff[] = { 0, 1, -1, G_MAXINT64 / GST_SECOND, G_MININT64 / GST_SECOND };

   519   guint i;

   520   

   521   	xmlfile = "test_signedness";

   522   std_log(LOG_FILENAME_LINE, "Test Started test_signedness");

   523 

   524   for (i = 0; i < G_N_ELEMENTS (time); i++) {

   525     fail_if (time[i] != (time[i] * GST_SECOND / GST_SECOND));

   526   }

   527   for (i = 0; i < G_N_ELEMENTS (diff); i++) {

   528     fail_if (diff[i] != (diff[i] * GST_SECOND / GST_SECOND));

   529   }

   530   

   531   std_log(LOG_FILENAME_LINE, "Test Successful");

   532   create_xml(0);

   533   

   534 } 

   535 

   536 

   537 

   538 /*void main(int argc,char** argv)

   539 {

   540         gst_init(&argc,&argv);

   541         test_range();

   542         test_mixed();

   543         test_diff();

   544         test_signedness();

   545         

   546 //        test_single_shot();

   547 //        test_periodic_shot();

   548 //        test_periodic_multi();

   549 //        test_async_order();

   550         

   551 }*/

   552 

   553 

   554 void (*fn[8]) (void) = {

   555         test_range,

   556         test_diff,

   557         test_signedness,

   558         test_single_shot,

   559         test_periodic_shot,

   560         test_periodic_multi,

   561         test_async_order,

   562         test_mixed

   563 };

   564 

   565 char *args[] = {

   566         "test_range",

   567         "test_diff",

   568         "test_signedness",

   569         "test_single_shot",

   570         "test_periodic_shot",

   571         "test_periodic_multi",

   572         "test_async_order",

   573         "test_mixed",

   574 };

   575 

   576 GST_CHECK_MAIN (gst_systemclock);

   577 

   578 

   579 

   580 

   581