1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 *

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

     5 * modify it under the terms of the GNU Lesser General Public

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

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

     8 *

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

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

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

    12 * Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public

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

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

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    22  

    23 /* GStreamer

    24  * Copyright (C) 2005 Jan Schmidt <thaytan@mad.scientist.com>

    25  *

    26  * gstsegment.c: Unit test for segments

    27  *

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

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

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

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

    32  *

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

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

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

    36  * Library General Public License for more details.

    37  *

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

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

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

    41  * Boston, MA 02111-1307, USA.

    42  */

    43 

    44 

    45 #include <gst/gst_global.h>

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

    47 

    48 #define LOG_FILE "c:\\logs\\gstsegment_logs.txt" 

    49 #include "std_log_result.h" 

    50 #define LOG_FILENAME_LINE __FILE__, __LINE__

    51 

    52 

    53 #if EMULATOR

    54 static GET_GLOBAL_VAR_FROM_TLS(raised_critical,gstcheck,gboolean)

    55 #define _gst_check_raised_critical (*GET_GSTREAMER_WSD_VAR_NAME(raised_critical,gstcheck,g)())

    56 #else 

    57 extern gboolean _gst_check_raised_critical;

    58 #endif

    59 

    60 //gboolean _gst_check_expecting_log = FALSE;

    61 #if EMULATOR

    62 static GET_GLOBAL_VAR_FROM_TLS(expecting_log,gstcheck,gboolean)

    63 #define _gst_check_expecting_log (*GET_GSTREAMER_WSD_VAR_NAME(expecting_log,gstcheck,g)())

    64 #else 

    65 extern gboolean _gst_check_expecting_log;

    66 #endif

    67 

    68 

    69 //char* xmlfile = "gstsegment";

    70 

    71 void create_xml(int result)

    72 {

    73     if(result)

    74         assert_failed = 1;

    75     

    76     testResultXml(xmlfile);

    77     close_log_file();

    78 }

    79 

    80 void segment_seek_nosize()

    81 {

    82   GstSegment segment;

    83   gboolean res;

    84   gint64 cstart, cstop;

    85   gboolean update;

    86   

    87     xmlfile = "segment_seek_nosize";

    88   std_log(LOG_FILENAME_LINE, "Test Started segment_seek_nosize");

    89 

    90   gst_segment_init (&segment, GST_FORMAT_BYTES);

    91 

    92   /* configure segment to start 100 */

    93   gst_segment_set_seek (&segment, 1.0,

    94       GST_FORMAT_BYTES,

    95       GST_SEEK_FLAG_NONE,

    96       GST_SEEK_TYPE_SET, 100, GST_SEEK_TYPE_NONE, -1, &update);

    97   fail_unless (segment.start == 100);

    98   fail_unless (segment.stop == -1);

    99   fail_unless (update == TRUE);

   100 

   101   /* configure segment to stop relative, should not do anything since 

   102    * size is unknown. */

   103   gst_segment_set_seek (&segment, 1.0,

   104       GST_FORMAT_BYTES,

   105       GST_SEEK_FLAG_NONE,

   106       GST_SEEK_TYPE_NONE, 200, GST_SEEK_TYPE_CUR, -100, &update);

   107   fail_unless (segment.start == 100);

   108   fail_unless (segment.stop == -1);

   109   fail_unless (update == FALSE);

   110 

   111   /* do some clipping on the open range */

   112   /* completely outside */

   113   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);

   114   fail_unless (res == FALSE);

   115 

   116   /* touching lower bound, still outside of the segment */

   117   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);

   118   fail_unless (res == FALSE);

   119 

   120   /* partially inside */

   121   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);

   122   fail_unless (res == TRUE);

   123   fail_unless (cstart == 100);

   124   fail_unless (cstop == 150);

   125 

   126   /* inside, touching lower bound */

   127   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   128       100, 150, &cstart, &cstop);

   129   fail_unless (res == TRUE);

   130   fail_unless (cstart == 100);

   131   fail_unless (cstop == 150);

   132 

   133   /* special case, 0 duration */

   134   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   135       100, 100, &cstart, &cstop);

   136   fail_unless (res == TRUE);

   137   fail_unless (cstart == 100);

   138   fail_unless (cstop == 100);

   139 

   140   /* completely inside */

   141   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   142       150, 200, &cstart, &cstop);

   143   fail_unless (res == TRUE);

   144   fail_unless (cstart == 150);

   145   fail_unless (cstop == 200);

   146 

   147   /* invalid start */

   148   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);

   149   fail_unless (res == FALSE);

   150 

   151   /* start outside, we don't know the stop */

   152   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);

   153   fail_unless (res == TRUE);

   154   fail_unless (cstart == 100);

   155   fail_unless (cstop == -1);

   156 

   157   /* start on lower bound */

   158   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);

   159   fail_unless (res == TRUE);

   160   fail_unless (cstart == 100);

   161   fail_unless (cstop == -1);

   162 

   163   /* start inside */

   164   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);

   165   fail_unless (res == TRUE);

   166   fail_unless (cstart == 150);

   167   fail_unless (cstop == -1);

   168 

   169   /* add 100 to start, set stop to 300 */

   170   gst_segment_set_seek (&segment, 1.0,

   171       GST_FORMAT_BYTES,

   172       GST_SEEK_FLAG_NONE,

   173       GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 300, &update);

   174   fail_unless (segment.start == 200);

   175   fail_unless (segment.stop == 300);

   176   fail_unless (update == TRUE);

   177 

   178   update = FALSE;

   179   /* add 100 to start (to 300), set stop to 200, this is not allowed. 

   180    * nothing should be updated in the segment. A g_warning is

   181    * emited. */

   182   ASSERT_CRITICAL(gst_segment_set_seek (&segment, 1.0,

   183           GST_FORMAT_BYTES,

   184           GST_SEEK_FLAG_NONE,

   185           GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 200, &update));

   186           

   187   fail_unless (segment.start == 200);

   188   fail_unless (segment.stop == 300);

   189   /* update didn't change */

   190   fail_unless (update == FALSE);

   191 

   192   update = TRUE;

   193   /* seek relative to end, should not do anything since size is

   194    * unknown. */

   195   gst_segment_set_seek (&segment, 1.0,

   196       GST_FORMAT_BYTES,

   197       GST_SEEK_FLAG_NONE,

   198       GST_SEEK_TYPE_END, -300, GST_SEEK_TYPE_END, -100, &update);

   199   fail_unless (segment.start == 200);

   200   fail_unless (segment.stop == 300);

   201   fail_unless (update == FALSE);

   202 

   203   /* completely outside */

   204   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);

   205   fail_unless (res == FALSE);

   206 

   207   /* touching lower bound */

   208   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 200, &cstart, &cstop);

   209   fail_unless (res == FALSE);

   210 

   211   /* partially inside */

   212   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 250, &cstart, &cstop);

   213   fail_unless (res == TRUE);

   214   fail_unless (cstart == 200);

   215   fail_unless (cstop == 250);

   216 

   217   /* inside, touching lower bound */

   218   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   219       200, 250, &cstart, &cstop);

   220   fail_unless (res == TRUE);

   221   fail_unless (cstart == 200);

   222   fail_unless (cstop == 250);

   223 

   224   /* completely inside */

   225   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   226       250, 290, &cstart, &cstop);

   227   fail_unless (res == TRUE);

   228   fail_unless (cstart == 250);

   229   fail_unless (cstop == 290);

   230 

   231   /* partially inside */

   232   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   233       250, 350, &cstart, &cstop);

   234   fail_unless (res == TRUE);

   235   fail_unless (cstart == 250);

   236   fail_unless (cstop == 300);

   237 

   238   /* invalid start */

   239   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);

   240   fail_unless (res == FALSE);

   241 

   242   /* start outside */

   243   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);

   244   fail_unless (res == TRUE);

   245   fail_unless (cstart == 200);

   246   fail_unless (cstop == 300);

   247 

   248   /* start on lower bound */

   249   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 200, -1, &cstart, &cstop);

   250   fail_unless (res == TRUE);

   251   fail_unless (cstart == 200);

   252   fail_unless (cstop == 300);

   253 

   254   /* start inside */

   255   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 250, -1, &cstart, &cstop);

   256   fail_unless (res == TRUE);

   257   fail_unless (cstart == 250);

   258   fail_unless (cstop == 300);

   259 

   260   /* start outside on boundary */

   261   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 300, -1, &cstart, &cstop);

   262   fail_unless (res == FALSE);

   263 

   264   /* start completely outside */

   265   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 350, -1, &cstart, &cstop);

   266   fail_unless (res == FALSE);

   267   

   268     std_log(LOG_FILENAME_LINE, "Test Successful");

   269   create_xml(0);

   270 }

   271 

   272 

   273 /* mess with the segment structure in the bytes format */

   274 void segment_seek_size()

   275 {

   276   GstSegment segment;

   277   gboolean res;

   278   gint64 cstart, cstop;

   279   gboolean update;

   280   

   281       xmlfile = "segment_seek_size";

   282   std_log(LOG_FILENAME_LINE, "Test Started segment_seek_size");

   283 

   284   gst_segment_init (&segment, GST_FORMAT_BYTES);

   285   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   286 

   287   /* configure segment to start 100 */

   288   gst_segment_set_seek (&segment, 1.0,

   289       GST_FORMAT_BYTES,

   290       GST_SEEK_FLAG_NONE,

   291       GST_SEEK_TYPE_SET, 100, GST_SEEK_TYPE_NONE, -1, &update);

   292   fail_unless (segment.start == 100);

   293   fail_unless (segment.stop == -1);

   294   fail_unless (update == TRUE);

   295 

   296   /* configure segment to stop relative, does not update stop

   297    * since we did not set it before. */

   298   gst_segment_set_seek (&segment, 1.0,

   299       GST_FORMAT_BYTES,

   300       GST_SEEK_FLAG_NONE,

   301       GST_SEEK_TYPE_NONE, 200, GST_SEEK_TYPE_CUR, -100, &update);

   302   fail_unless (segment.start == 100);

   303   fail_unless (segment.stop == -1);

   304   fail_unless (update == FALSE);

   305 

   306   /* do some clipping on the open range */

   307   /* completely outside */

   308   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);

   309   fail_unless (res == FALSE);

   310 

   311   /* touching lower bound */

   312   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);

   313   fail_unless (res == FALSE);

   314 

   315   /* partially inside */

   316   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);

   317   fail_unless (res == TRUE);

   318   fail_unless (cstart == 100);

   319   fail_unless (cstop == 150);

   320 

   321   /* inside, touching lower bound */

   322   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   323       100, 150, &cstart, &cstop);

   324   fail_unless (res == TRUE);

   325   fail_unless (cstart == 100);

   326   fail_unless (cstop == 150);

   327 

   328   /* completely inside */

   329   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   330       150, 200, &cstart, &cstop);

   331   fail_unless (res == TRUE);

   332   fail_unless (cstart == 150);

   333   fail_unless (cstop == 200);

   334 

   335   /* partially inside, clip to size */

   336   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   337       150, 300, &cstart, &cstop);

   338   fail_unless (res == TRUE);

   339   fail_unless (cstart == 150);

   340   fail_unless (cstop == 200);

   341 

   342   /* invalid start */

   343   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);

   344   fail_unless (res == FALSE);

   345 

   346   /* start outside */

   347   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);

   348   fail_unless (res == TRUE);

   349   fail_unless (cstart == 100);

   350   fail_unless (cstop == -1);

   351 

   352   /* start on lower bound */

   353   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);

   354   fail_unless (res == TRUE);

   355   fail_unless (cstart == 100);

   356   fail_unless (cstop == -1);

   357 

   358   /* start inside */

   359   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);

   360   fail_unless (res == TRUE);

   361   fail_unless (cstart == 150);

   362   fail_unless (cstop == -1);

   363 

   364   /* add 100 to start, set stop to 300, stop clips to 200 */

   365   gst_segment_set_seek (&segment, 1.0,

   366       GST_FORMAT_BYTES,

   367       GST_SEEK_FLAG_NONE,

   368       GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 300, &update);

   369   fail_unless (segment.start == 200);

   370   fail_unless (segment.stop == 200);

   371 

   372   /* add 100 to start (to 300), set stop to 200, this clips start

   373    * to duration */

   374   gst_segment_set_seek (&segment, 1.0,

   375       GST_FORMAT_BYTES,

   376       GST_SEEK_FLAG_NONE,

   377       GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 200, &update);

   378   fail_unless (segment.start == 200);

   379   fail_unless (segment.stop == 200);

   380   fail_unless (update == FALSE);

   381 

   382   /* seek relative to end */

   383   gst_segment_set_seek (&segment, 1.0,

   384       GST_FORMAT_BYTES,

   385       GST_SEEK_FLAG_NONE,

   386       GST_SEEK_TYPE_END, -100, GST_SEEK_TYPE_END, -20, &update);

   387   fail_unless (segment.start == 100);

   388   fail_unless (segment.stop == 180);

   389   fail_unless (update == TRUE);

   390 

   391   /* completely outside */

   392   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);

   393   fail_unless (res == FALSE);

   394 

   395   /* touching lower bound */

   396   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);

   397   fail_unless (res == FALSE);

   398 

   399   /* partially inside */

   400   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);

   401   fail_unless (res == TRUE);

   402   fail_unless (cstart == 100);

   403   fail_unless (cstop == 150);

   404 

   405   /* inside, touching lower bound */

   406   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   407       100, 150, &cstart, &cstop);

   408   fail_unless (res == TRUE);

   409   fail_unless (cstart == 100);

   410   fail_unless (cstop == 150);

   411 

   412   /* completely inside */

   413   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   414       150, 170, &cstart, &cstop);

   415   fail_unless (res == TRUE);

   416   fail_unless (cstart == 150);

   417   fail_unless (cstop == 170);

   418 

   419   /* partially inside */

   420   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   421       150, 250, &cstart, &cstop);

   422   fail_unless (res == TRUE);

   423   fail_unless (cstart == 150);

   424   fail_unless (cstop == 180);

   425 

   426   /* invalid start */

   427   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);

   428   fail_unless (res == FALSE);

   429 

   430   /* start outside */

   431   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);

   432   fail_unless (res == TRUE);

   433   fail_unless (cstart == 100);

   434   fail_unless (cstop == 180);

   435 

   436   /* start on lower bound */

   437   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);

   438   fail_unless (res == TRUE);

   439   fail_unless (cstart == 100);

   440   fail_unless (cstop == 180);

   441 

   442   /* start inside */

   443   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);

   444   fail_unless (res == TRUE);

   445   fail_unless (cstart == 150);

   446   fail_unless (cstop == 180);

   447 

   448   /* start outside on boundary */

   449   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 180, -1, &cstart, &cstop);

   450   fail_unless (res == FALSE);

   451 

   452   /* start completely outside */

   453   res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 250, -1, &cstart, &cstop);

   454   fail_unless (res == FALSE);

   455   

   456     std_log(LOG_FILENAME_LINE, "Test Successful");

   457   create_xml(0);

   458 }

   459 

   460 

   461 void segment_seek_reverse()

   462 {

   463   GstSegment segment;

   464   gboolean update;

   465 

   466   xmlfile = "segment_seek_reverse";

   467   std_log(LOG_FILENAME_LINE, "Test Started segment_seek_reverse");

   468 

   469   gst_segment_init (&segment, GST_FORMAT_BYTES);

   470   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   471 

   472   /* configure segment to stop 100 */

   473   gst_segment_set_seek (&segment, -1.0,

   474       GST_FORMAT_BYTES,

   475       GST_SEEK_FLAG_NONE,

   476       GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_SET, 100, &update);

   477   fail_unless (segment.start == 0);

   478   

   479   fail_unless (segment.stop == 100);

   480   

   481   fail_unless (segment.time == 0);

   482   

   483   fail_unless (segment.last_stop == 100);

   484   

   485   fail_unless (update == TRUE);

   486   

   487 

   488   /* update */

   489   gst_segment_set_seek (&segment, -1.0,

   490       GST_FORMAT_BYTES,

   491       GST_SEEK_FLAG_NONE,

   492       GST_SEEK_TYPE_SET, 10, GST_SEEK_TYPE_CUR, -20, &update);

   493   fail_unless (segment.start == 10);

   494   

   495   fail_unless (segment.stop == 80);

   496   

   497   fail_unless (segment.time == 10);

   498   

   499   fail_unless (segment.last_stop == 80);

   500   

   501   fail_unless (update == TRUE);

   502   

   503 

   504   gst_segment_set_seek (&segment, -1.0,

   505       GST_FORMAT_BYTES,

   506       GST_SEEK_FLAG_NONE,

   507       GST_SEEK_TYPE_SET, 20, GST_SEEK_TYPE_NONE, 0, &update);

   508   fail_unless (segment.start == 20);

   509   

   510   fail_unless (segment.stop == 80);

   511   

   512   fail_unless (segment.time == 20);

   513   

   514   fail_unless (segment.last_stop == 80);

   515   

   516   fail_unless (update == FALSE);

   517   

   518   

   519   std_log(LOG_FILENAME_LINE, "Test Successful");

   520   create_xml(0);

   521 }

   522 

   523 

   524 /* mess with the segment structure in the bytes format */

   525 void segment_seek_rate()

   526 {

   527   GstSegment segment;

   528   gboolean update;

   529 

   530   xmlfile = "segment_seek_rate";

   531   std_log(LOG_FILENAME_LINE, "Test Started segment_seek_rate");

   532   

   533   gst_segment_init (&segment, GST_FORMAT_BYTES);

   534 

   535   /* configure segment to rate 2.0, format does not matter when we don't specify

   536    * a start or stop position. */

   537   gst_segment_set_seek (&segment, 2.0,

   538       GST_FORMAT_UNDEFINED,

   539       GST_SEEK_FLAG_NONE,

   540       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_NONE, -1, &update);

   541   fail_unless (segment.format == GST_FORMAT_BYTES);

   542   

   543   fail_unless (segment.start == 0);

   544   

   545   fail_unless (segment.stop == -1);

   546   

   547   fail_unless (segment.rate == 2.0);

   548   

   549   fail_unless (update == FALSE);

   550   

   551 

   552   /* 0 is the same in all formats and should not fail */

   553   gst_segment_set_seek (&segment, 2.0,

   554       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   555       GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1, &update);

   556   fail_unless (segment.format == GST_FORMAT_BYTES);

   557   

   558 

   559   /* set to -1 means start from 0 */

   560   gst_segment_set_seek (&segment, 2.0,

   561       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   562       GST_SEEK_TYPE_SET, -1, GST_SEEK_TYPE_NONE, -1, &update);

   563   fail_unless (segment.format == GST_FORMAT_BYTES);

   564   

   565   fail_unless (segment.start == 0);

   566   

   567 

   568   gst_segment_set_seek (&segment, 2.0,

   569       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   570       GST_SEEK_TYPE_CUR, 0, GST_SEEK_TYPE_NONE, -1, &update);

   571 

   572   gst_segment_set_seek (&segment, 2.0,

   573       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   574       GST_SEEK_TYPE_END, 0, GST_SEEK_TYPE_NONE, -1, &update);

   575 

   576   /* -1 for end is fine too in all formats */

   577   gst_segment_set_seek (&segment, 2.0,

   578       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   579       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, -1, &update);

   580 

   581   /* 0 as relative end is fine too */

   582   gst_segment_set_seek (&segment, 2.0,

   583       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   584       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_CUR, 0, &update);

   585 

   586   gst_segment_set_seek (&segment, 2.0,

   587       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   588       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);

   589 

   590   /* set a real stop position, this must happen in bytes */

   591   gst_segment_set_seek (&segment, 3.0,

   592       GST_FORMAT_BYTES,

   593       GST_SEEK_FLAG_NONE,

   594       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, 100, &update);

   595   fail_unless (segment.format == GST_FORMAT_BYTES);

   596   

   597   fail_unless (segment.start == 0);

   598   

   599   fail_unless (segment.stop == 100);

   600   

   601   fail_unless (segment.rate == 3.0);

   602   

   603   /* no seek should happen, we just updated the stop position in forward

   604    * playback mode.*/

   605   fail_unless (update == FALSE);

   606   

   607 

   608   /* 0 as relative end is fine too */

   609   gst_segment_set_seek (&segment, 2.0,

   610       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   611       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_CUR, 0, &update);

   612   fail_unless (segment.stop == 100);

   613   

   614 

   615   gst_segment_set_seek (&segment, 2.0,

   616       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   617       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);

   618   fail_unless (segment.stop == 100);

   619   

   620 

   621   /* -1 for end is fine too in all formats */

   622   gst_segment_set_seek (&segment, 2.0,

   623       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   624       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, -1, &update);

   625   fail_unless (segment.stop == -1);

   626   

   627 

   628   /* set some duration, stop -1 END seeks will now work with the

   629    * duration, if the formats match */

   630   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   631   fail_unless (segment.duration == 200);

   632   

   633 

   634   /* seek to end in any format with 0 should set the stop to the

   635    * duration */

   636   gst_segment_set_seek (&segment, 2.0,

   637       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

   638       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);

   639   fail_unless (segment.stop == 200);

   640   

   641   fail_unless (segment.duration == 200);

   642   

   643 

   644   /* subtract 100 from the end */

   645   gst_segment_set_seek (&segment, 2.0,

   646       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

   647       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, -100, &update);

   648   fail_unless (segment.stop == 100);

   649   

   650   fail_unless (segment.duration == 200);

   651   

   652 

   653   /* add 100 to the duration, this should be clamped to the duration */

   654   gst_segment_set_seek (&segment, 2.0,

   655       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

   656       GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 100, &update);

   657   fail_unless (segment.stop == 200);

   658   

   659   fail_unless (segment.duration == 200);

   660   

   661 

   662   /* add 300 to the start, this should be clamped to the duration */

   663   gst_segment_set_seek (&segment, 2.0,

   664       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

   665       GST_SEEK_TYPE_CUR, 300, GST_SEEK_TYPE_END, 0, &update);

   666   fail_unless (segment.start == 200);

   667   

   668   fail_unless (segment.stop == 200);

   669   

   670   fail_unless (segment.duration == 200);

   671   

   672 

   673   /* subtract 300 from the start, this should be clamped to 0 */

   674   gst_segment_set_seek (&segment, 2.0,

   675       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

   676       GST_SEEK_TYPE_CUR, -300, GST_SEEK_TYPE_END, 0, &update);

   677   fail_unless (segment.start == 0);

   678   

   679   fail_unless (segment.stop == 200);

   680   

   681   fail_unless (segment.duration == 200);

   682   

   683   

   684   std_log(LOG_FILENAME_LINE, "Test Successful");

   685   create_xml(0);

   686 }

   687 

   688 

   689 /* mess with the segment structure in the bytes format */

   690 void segment_newsegment_open()

   691 {

   692   GstSegment segment;

   693 

   694   xmlfile = "segment_newsegment_open";

   695   std_log(LOG_FILENAME_LINE, "Test Started segment_newsegment_open");

   696 

   697   gst_segment_init (&segment, GST_FORMAT_BYTES);

   698 

   699   /* time should also work for starting from 0 */

   700   gst_segment_set_newsegment (&segment, FALSE, 1.0, GST_FORMAT_TIME, 0, -1, 0);

   701 

   702   fail_unless (segment.rate == 1.0);

   703   

   704   fail_unless (segment.format == GST_FORMAT_BYTES);

   705   

   706   fail_unless (segment.flags == 0);

   707   

   708   fail_unless (segment.start == 0);

   709   

   710   fail_unless (segment.stop == -1);

   711   

   712   fail_unless (segment.time == 0);

   713   

   714   fail_unless (segment.accum == 0);

   715   

   716   fail_unless (segment.last_stop == 0);

   717   

   718   fail_unless (segment.duration == -1);

   719   

   720 

   721   /* we set stop but in the wrong format, stop stays open. */

   722   gst_segment_set_newsegment (&segment, FALSE, 1.0, GST_FORMAT_TIME, 0, 200, 0);

   723 

   724   fail_unless (segment.start == 0);

   725   

   726   fail_unless (segment.stop == -1);

   727   

   728   fail_unless (segment.time == 0);

   729   

   730   fail_unless (segment.accum == 0);

   731   

   732 

   733   /* update, nothing changes */

   734   gst_segment_set_newsegment (&segment, TRUE, 1.0, GST_FORMAT_BYTES, 0, -1, 0);

   735 

   736   fail_unless (segment.start == 0);

   737   

   738   fail_unless (segment.stop == -1);

   739   

   740   fail_unless (segment.time == 0);

   741   

   742   fail_unless (segment.accum == 0);

   743   

   744 

   745   /* update */

   746   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   747       GST_FORMAT_BYTES, 100, -1, 100);

   748 

   749   fail_unless (segment.start == 100);

   750   

   751   fail_unless (segment.stop == -1);

   752   

   753   fail_unless (segment.time == 100);

   754   

   755   fail_unless (segment.accum == 100);

   756   

   757 

   758   /* last_stop 0, accum does not change */

   759   gst_segment_set_newsegment (&segment, FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0);

   760 

   761   fail_unless (segment.start == 0);

   762   

   763   fail_unless (segment.stop == -1);

   764   

   765   fail_unless (segment.time == 0);

   766   

   767   fail_unless (segment.accum == 100);

   768   

   769 

   770   gst_segment_set_last_stop (&segment, GST_FORMAT_BYTES, 200);

   771 

   772   /* last_stop 200, accum changes */

   773   gst_segment_set_newsegment (&segment, FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0);

   774 

   775   fail_unless (segment.start == 0);

   776   

   777   fail_unless (segment.stop == -1);

   778   

   779   fail_unless (segment.time == 0);

   780   

   781   fail_unless (segment.accum == 300);

   782   

   783   

   784   std_log(LOG_FILENAME_LINE, "Test Successful");

   785   create_xml(0);

   786 

   787 }

   788 

   789 

   790 /* mess with the segment structure in the bytes format */

   791 void segment_newsegment_closed()

   792 {

   793   GstSegment segment;

   794 

   795   xmlfile = "segment_newsegment_closed";

   796   std_log(LOG_FILENAME_LINE, "Test Started segment_newsegment_closed");

   797 

   798   gst_segment_init (&segment, GST_FORMAT_BYTES);

   799 

   800   gst_segment_set_newsegment (&segment, FALSE, 1.0,

   801       GST_FORMAT_BYTES, 0, 200, 0);

   802 

   803   fail_unless (segment.rate == 1.0);

   804   

   805   fail_unless (segment.format == GST_FORMAT_BYTES);

   806   

   807   fail_unless (segment.flags == 0);

   808   

   809   fail_unless (segment.start == 0);

   810   

   811   fail_unless (segment.stop == 200);

   812   

   813   fail_unless (segment.time == 0);

   814   

   815   fail_unless (segment.accum == 0);

   816   

   817   fail_unless (segment.last_stop == 0);

   818   

   819   fail_unless (segment.duration == -1);

   820   

   821 

   822   /* do an update */

   823   gst_segment_set_newsegment (&segment, TRUE, 1.0, GST_FORMAT_BYTES, 0, 300, 0);

   824 

   825   fail_unless (segment.start == 0);

   826   

   827   fail_unless (segment.stop == 300);

   828   

   829   fail_unless (segment.time == 0);

   830   

   831   fail_unless (segment.accum == 0);

   832   

   833 

   834   /* and a new accumulated one */

   835   gst_segment_set_newsegment (&segment, FALSE, 1.0,

   836       GST_FORMAT_BYTES, 100, 400, 300);

   837 

   838   fail_unless (segment.start == 100);

   839   

   840   fail_unless (segment.stop == 400);

   841   

   842   fail_unless (segment.time == 300);

   843   

   844   fail_unless (segment.accum == 300);

   845   

   846 

   847   /* and a new updated one */

   848   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   849       GST_FORMAT_BYTES, 100, 500, 300);

   850 

   851   fail_unless (segment.start == 100);

   852   

   853   fail_unless (segment.stop == 500);

   854   

   855   fail_unless (segment.time == 300);

   856   

   857   fail_unless (segment.accum == 300);

   858   

   859 

   860   /* and a new partially updated one */

   861   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   862       GST_FORMAT_BYTES, 200, 500, 400);

   863 

   864   fail_unless (segment.start == 200);

   865   

   866   fail_unless (segment.stop == 500);

   867   

   868   fail_unless (segment.time == 400);

   869   

   870   fail_unless (segment.accum == 400);

   871   

   872   

   873   std_log(LOG_FILENAME_LINE, "Test Successful");

   874   create_xml(0);

   875 }

   876 

   877 

   878 

   879 /* mess with the segment structure in the time format */

   880 void segment_newsegment_streamtime()

   881 {

   882   GstSegment segment;

   883   gint64 result;

   884 

   885   xmlfile = "segment_newsegment_streamtime";

   886   std_log(LOG_FILENAME_LINE, "Test Started segment_newsegment_streamtime");

   887 

   888   gst_segment_init (&segment, GST_FORMAT_TIME);

   889 

   890   /***************************

   891    * Normal segment

   892    ***************************/

   893   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   894       GST_FORMAT_TIME, 0, 200, 0);

   895 

   896   fail_unless (segment.rate == 1.0);

   897   

   898   fail_unless (segment.applied_rate == 1.0);

   899   

   900   fail_unless (segment.format == GST_FORMAT_TIME);

   901   

   902   fail_unless (segment.flags == 0);

   903   

   904   fail_unless (segment.start == 0);

   905   

   906   fail_unless (segment.stop == 200);

   907   

   908   fail_unless (segment.time == 0);

   909   

   910   fail_unless (segment.accum == 0);

   911   

   912   fail_unless (segment.last_stop == 0);

   913   

   914   fail_unless (segment.duration == -1);

   915   

   916 

   917   /* invalid time gives invalid result */

   918   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

   919   fail_unless (result == -1);

   920   

   921 

   922   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);

   923   fail_unless (result == 0);

   924   

   925 

   926   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);

   927   fail_unless (result == 100);

   928   

   929 

   930   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);

   931   fail_unless (result == 200);

   932   

   933 

   934   /* outside of the segment */

   935   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);

   936   fail_unless (result == -1);

   937   

   938 

   939   /*********************

   940    * time shifted by 500

   941    *********************/

   942   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   943       GST_FORMAT_TIME, 0, 200, 500);

   944 

   945   fail_unless (segment.accum == 200);

   946   

   947 

   948   /* invalid time gives invalid result */

   949   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

   950   fail_unless (result == -1);

   951   

   952 

   953   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);

   954   fail_unless (result == 500);

   955   

   956 

   957   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);

   958   fail_unless (result == 600);

   959   

   960 

   961   /* outside of the segment */

   962   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);

   963   fail_unless (result == -1);

   964   

   965 

   966   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);

   967   fail_unless (result == -1);

   968   

   969 

   970   /*********************

   971    * time offset by 500

   972    *********************/

   973   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   974       GST_FORMAT_TIME, 500, 700, 0);

   975 

   976   fail_unless (segment.accum == 400);

   977   

   978 

   979   /* invalid time gives invalid result */

   980   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

   981   fail_unless (result == -1);

   982   

   983 

   984   /* before segment is invalid */

   985   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);

   986   fail_unless (result == -1);

   987   

   988 

   989   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);

   990   fail_unless (result == 0);

   991   

   992 

   993   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 600);

   994   fail_unless (result == 100);

   995   

   996 

   997   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 700);

   998   fail_unless (result == 200);

   999   

  1000 

  1001   /* outside of the segment */

  1002   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 800);

  1003   fail_unless (result == -1);

  1004   

  1005 

  1006   /*************************************

  1007    * time offset by 500, shifted by 200

  1008    *************************************/

  1009   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

  1010       GST_FORMAT_TIME, 500, 700, 200);

  1011 

  1012   fail_unless (segment.accum == 600);

  1013   

  1014 

  1015   /* invalid time gives invalid result */

  1016   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

  1017   fail_unless (result == -1);

  1018   

  1019 

  1020   /* before segment is invalid */

  1021   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);

  1022   fail_unless (result == -1);

  1023   

  1024 

  1025   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);

  1026   fail_unless (result == 200);

  1027   

  1028 

  1029   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 600);

  1030   fail_unless (result == 300);

  1031   

  1032 

  1033   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 700);

  1034   fail_unless (result == 400);

  1035   

  1036 

  1037   /* outside of the segment */

  1038   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 800);

  1039   fail_unless (result == -1);

  1040   

  1041   

  1042   std_log(LOG_FILENAME_LINE, "Test Successful");

  1043   create_xml(0);

  1044 }

  1045 

  1046 

  1047 /* mess with the segment structure in the time format */

  1048 void segment_newsegment_streamtime_rate()

  1049 {

  1050   GstSegment segment;

  1051   gint64 result;

  1052 

  1053   xmlfile = "segment_newsegment_streamtime_rate";

  1054   std_log(LOG_FILENAME_LINE, "Test Started segment_newsegment_streamtime_rate");

  1055 

  1056   gst_segment_init (&segment, GST_FORMAT_TIME);

  1057 

  1058   /***************************

  1059    * Normal segment rate 2.0

  1060    ***************************/

  1061   gst_segment_set_newsegment_full (&segment, FALSE, 2.0, 1.0,

  1062       GST_FORMAT_TIME, 0, 200, 0);

  1063 

  1064   fail_unless (segment.rate == 2.0);

  1065   

  1066   fail_unless (segment.applied_rate == 1.0);

  1067   

  1068   fail_unless (segment.format == GST_FORMAT_TIME);

  1069   

  1070   fail_unless (segment.flags == 0);

  1071   

  1072   fail_unless (segment.start == 0);

  1073   

  1074   fail_unless (segment.stop == 200);

  1075   

  1076   fail_unless (segment.time == 0);

  1077   

  1078   fail_unless (segment.accum == 0);

  1079   

  1080   fail_unless (segment.last_stop == 0);

  1081   

  1082   fail_unless (segment.duration == -1);

  1083   

  1084 

  1085   /* invalid time gives invalid result */

  1086   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

  1087   fail_unless (result == -1);

  1088   

  1089 

  1090   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);

  1091   fail_unless (result == 0);

  1092   

  1093 

  1094   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);

  1095   fail_unless (result == 100);

  1096   

  1097 

  1098   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);

  1099   fail_unless (result == 150);

  1100   

  1101 

  1102   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);

  1103   fail_unless (result == 200);

  1104   

  1105 

  1106   /* outside of the segment */

  1107   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);

  1108   fail_unless (result == -1);

  1109   

  1110 

  1111   /***************************************

  1112    * Normal segment rate 2.0, offset

  1113    ***************************************/

  1114   gst_segment_set_newsegment_full (&segment, FALSE, 2.0, 1.0,

  1115       GST_FORMAT_TIME, 100, 300, 0);

  1116 

  1117   fail_unless (segment.accum == 100);

  1118   

  1119 

  1120   /* invalid time gives invalid result */

  1121   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);

  1122   fail_unless (result == -1);

  1123   

  1124 

  1125   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);

  1126   fail_unless (result == 0);

  1127   

  1128 

  1129   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);

  1130   fail_unless (result == 100);

  1131   

  1132 

  1133   result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 250);

  1134   fail_unless (result == 150);