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 Jan Schmidt <thaytan@mad.scientist.com>

    16  *

    17  * gstsegment.c: Unit test for segments

    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\\gstsegment_logs.txt" 

    40 #include "std_log_result.h" 

    41 #define LOG_FILENAME_LINE __FILE__, __LINE__

    42 

    43 

    44 #if EMULATOR

    45 static GET_GLOBAL_VAR_FROM_TLS(raised_critical,gstcheck,gboolean)

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

    47 #else 

    48 extern gboolean _gst_check_raised_critical;

    49 #endif

    50 

    51 //gboolean _gst_check_expecting_log = FALSE;

    52 #if EMULATOR

    53 static GET_GLOBAL_VAR_FROM_TLS(expecting_log,gstcheck,gboolean)

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

    55 #else 

    56 extern gboolean _gst_check_expecting_log;

    57 #endif

    58 

    59 

    60 //char* xmlfile = "gstsegment";

    61 

    62 void create_xml(int result)

    63 {

    64     if(result)

    65         assert_failed = 1;

    66     

    67     testResultXml(xmlfile);

    68     close_log_file();

    69 }

    70 

    71 void segment_seek_nosize()

    72 {

    73   GstSegment segment;

    74   gboolean res;

    75   gint64 cstart, cstop;

    76   gboolean update;

    77   

    78     xmlfile = "segment_seek_nosize";

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

    80 

    81   gst_segment_init (&segment, GST_FORMAT_BYTES);

    82 

    83   /* configure segment to start 100 */

    84   gst_segment_set_seek (&segment, 1.0,

    85       GST_FORMAT_BYTES,

    86       GST_SEEK_FLAG_NONE,

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

    88   fail_unless (segment.start == 100);

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

    90   fail_unless (update == TRUE);

    91 

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

    93    * size is unknown. */

    94   gst_segment_set_seek (&segment, 1.0,

    95       GST_FORMAT_BYTES,

    96       GST_SEEK_FLAG_NONE,

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

    98   fail_unless (segment.start == 100);

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

   100   fail_unless (update == FALSE);

   101 

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

   103   /* completely outside */

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

   105   fail_unless (res == FALSE);

   106 

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

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

   109   fail_unless (res == FALSE);

   110 

   111   /* partially inside */

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

   113   fail_unless (res == TRUE);

   114   fail_unless (cstart == 100);

   115   fail_unless (cstop == 150);

   116 

   117   /* inside, touching lower bound */

   118   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   120   fail_unless (res == TRUE);

   121   fail_unless (cstart == 100);

   122   fail_unless (cstop == 150);

   123 

   124   /* special case, 0 duration */

   125   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

   126       100, 100, &cstart, &cstop);

   127   fail_unless (res == TRUE);

   128   fail_unless (cstart == 100);

   129   fail_unless (cstop == 100);

   130 

   131   /* completely inside */

   132   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   134   fail_unless (res == TRUE);

   135   fail_unless (cstart == 150);

   136   fail_unless (cstop == 200);

   137 

   138   /* invalid start */

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

   140   fail_unless (res == FALSE);

   141 

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

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

   144   fail_unless (res == TRUE);

   145   fail_unless (cstart == 100);

   146   fail_unless (cstop == -1);

   147 

   148   /* start on lower bound */

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

   150   fail_unless (res == TRUE);

   151   fail_unless (cstart == 100);

   152   fail_unless (cstop == -1);

   153 

   154   /* start inside */

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

   156   fail_unless (res == TRUE);

   157   fail_unless (cstart == 150);

   158   fail_unless (cstop == -1);

   159 

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

   161   gst_segment_set_seek (&segment, 1.0,

   162       GST_FORMAT_BYTES,

   163       GST_SEEK_FLAG_NONE,

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

   165   fail_unless (segment.start == 200);

   166   fail_unless (segment.stop == 300);

   167   fail_unless (update == TRUE);

   168 

   169   update = FALSE;

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

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

   172    * emited. */

   173   ASSERT_CRITICAL(gst_segment_set_seek (&segment, 1.0,

   174           GST_FORMAT_BYTES,

   175           GST_SEEK_FLAG_NONE,

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

   177           

   178   fail_unless (segment.start == 200);

   179   fail_unless (segment.stop == 300);

   180   /* update didn't change */

   181   fail_unless (update == FALSE);

   182 

   183   update = TRUE;

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

   185    * unknown. */

   186   gst_segment_set_seek (&segment, 1.0,

   187       GST_FORMAT_BYTES,

   188       GST_SEEK_FLAG_NONE,

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

   190   fail_unless (segment.start == 200);

   191   fail_unless (segment.stop == 300);

   192   fail_unless (update == FALSE);

   193 

   194   /* completely outside */

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

   196   fail_unless (res == FALSE);

   197 

   198   /* touching lower bound */

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

   200   fail_unless (res == FALSE);

   201 

   202   /* partially inside */

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

   204   fail_unless (res == TRUE);

   205   fail_unless (cstart == 200);

   206   fail_unless (cstop == 250);

   207 

   208   /* inside, touching lower bound */

   209   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   211   fail_unless (res == TRUE);

   212   fail_unless (cstart == 200);

   213   fail_unless (cstop == 250);

   214 

   215   /* completely inside */

   216   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   218   fail_unless (res == TRUE);

   219   fail_unless (cstart == 250);

   220   fail_unless (cstop == 290);

   221 

   222   /* partially inside */

   223   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   225   fail_unless (res == TRUE);

   226   fail_unless (cstart == 250);

   227   fail_unless (cstop == 300);

   228 

   229   /* invalid start */

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

   231   fail_unless (res == FALSE);

   232 

   233   /* start outside */

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

   235   fail_unless (res == TRUE);

   236   fail_unless (cstart == 200);

   237   fail_unless (cstop == 300);

   238 

   239   /* start on lower bound */

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

   241   fail_unless (res == TRUE);

   242   fail_unless (cstart == 200);

   243   fail_unless (cstop == 300);

   244 

   245   /* start inside */

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

   247   fail_unless (res == TRUE);

   248   fail_unless (cstart == 250);

   249   fail_unless (cstop == 300);

   250 

   251   /* start outside on boundary */

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

   253   fail_unless (res == FALSE);

   254 

   255   /* start completely outside */

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

   257   fail_unless (res == FALSE);

   258   

   259     std_log(LOG_FILENAME_LINE, "Test Successful");

   260   create_xml(0);

   261 }

   262 

   263 

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

   265 void segment_seek_size()

   266 {

   267   GstSegment segment;

   268   gboolean res;

   269   gint64 cstart, cstop;

   270   gboolean update;

   271   

   272       xmlfile = "segment_seek_size";

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

   274 

   275   gst_segment_init (&segment, GST_FORMAT_BYTES);

   276   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   277 

   278   /* configure segment to start 100 */

   279   gst_segment_set_seek (&segment, 1.0,

   280       GST_FORMAT_BYTES,

   281       GST_SEEK_FLAG_NONE,

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

   283   fail_unless (segment.start == 100);

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

   285   fail_unless (update == TRUE);

   286 

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

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

   289   gst_segment_set_seek (&segment, 1.0,

   290       GST_FORMAT_BYTES,

   291       GST_SEEK_FLAG_NONE,

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

   293   fail_unless (segment.start == 100);

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

   295   fail_unless (update == FALSE);

   296 

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

   298   /* completely outside */

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

   300   fail_unless (res == FALSE);

   301 

   302   /* touching lower bound */

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

   304   fail_unless (res == FALSE);

   305 

   306   /* partially inside */

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

   308   fail_unless (res == TRUE);

   309   fail_unless (cstart == 100);

   310   fail_unless (cstop == 150);

   311 

   312   /* inside, touching lower bound */

   313   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   315   fail_unless (res == TRUE);

   316   fail_unless (cstart == 100);

   317   fail_unless (cstop == 150);

   318 

   319   /* completely inside */

   320   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   322   fail_unless (res == TRUE);

   323   fail_unless (cstart == 150);

   324   fail_unless (cstop == 200);

   325 

   326   /* partially inside, clip to size */

   327   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   329   fail_unless (res == TRUE);

   330   fail_unless (cstart == 150);

   331   fail_unless (cstop == 200);

   332 

   333   /* invalid start */

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

   335   fail_unless (res == FALSE);

   336 

   337   /* start outside */

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

   339   fail_unless (res == TRUE);

   340   fail_unless (cstart == 100);

   341   fail_unless (cstop == -1);

   342 

   343   /* start on lower bound */

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

   345   fail_unless (res == TRUE);

   346   fail_unless (cstart == 100);

   347   fail_unless (cstop == -1);

   348 

   349   /* start inside */

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

   351   fail_unless (res == TRUE);

   352   fail_unless (cstart == 150);

   353   fail_unless (cstop == -1);

   354 

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

   356   gst_segment_set_seek (&segment, 1.0,

   357       GST_FORMAT_BYTES,

   358       GST_SEEK_FLAG_NONE,

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

   360   fail_unless (segment.start == 200);

   361   fail_unless (segment.stop == 200);

   362 

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

   364    * to duration */

   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, 200, &update);

   369   fail_unless (segment.start == 200);

   370   fail_unless (segment.stop == 200);

   371   fail_unless (update == FALSE);

   372 

   373   /* seek relative to end */

   374   gst_segment_set_seek (&segment, 1.0,

   375       GST_FORMAT_BYTES,

   376       GST_SEEK_FLAG_NONE,

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

   378   fail_unless (segment.start == 100);

   379   fail_unless (segment.stop == 180);

   380   fail_unless (update == TRUE);

   381 

   382   /* completely outside */

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

   384   fail_unless (res == FALSE);

   385 

   386   /* touching lower bound */

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

   388   fail_unless (res == FALSE);

   389 

   390   /* partially inside */

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

   392   fail_unless (res == TRUE);

   393   fail_unless (cstart == 100);

   394   fail_unless (cstop == 150);

   395 

   396   /* inside, touching lower bound */

   397   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   399   fail_unless (res == TRUE);

   400   fail_unless (cstart == 100);

   401   fail_unless (cstop == 150);

   402 

   403   /* completely inside */

   404   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   406   fail_unless (res == TRUE);

   407   fail_unless (cstart == 150);

   408   fail_unless (cstop == 170);

   409 

   410   /* partially inside */

   411   res = gst_segment_clip (&segment, GST_FORMAT_BYTES,

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

   413   fail_unless (res == TRUE);

   414   fail_unless (cstart == 150);

   415   fail_unless (cstop == 180);

   416 

   417   /* invalid start */

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

   419   fail_unless (res == FALSE);

   420 

   421   /* start outside */

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

   423   fail_unless (res == TRUE);

   424   fail_unless (cstart == 100);

   425   fail_unless (cstop == 180);

   426 

   427   /* start on lower bound */

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

   429   fail_unless (res == TRUE);

   430   fail_unless (cstart == 100);

   431   fail_unless (cstop == 180);

   432 

   433   /* start inside */

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

   435   fail_unless (res == TRUE);

   436   fail_unless (cstart == 150);

   437   fail_unless (cstop == 180);

   438 

   439   /* start outside on boundary */

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

   441   fail_unless (res == FALSE);

   442 

   443   /* start completely outside */

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

   445   fail_unless (res == FALSE);

   446   

   447     std_log(LOG_FILENAME_LINE, "Test Successful");

   448   create_xml(0);

   449 }

   450 

   451 

   452 void segment_seek_reverse()

   453 {

   454   GstSegment segment;

   455   gboolean update;

   456 

   457   xmlfile = "segment_seek_reverse";

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

   459 

   460   gst_segment_init (&segment, GST_FORMAT_BYTES);

   461   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   462 

   463   /* configure segment to stop 100 */

   464   gst_segment_set_seek (&segment, -1.0,

   465       GST_FORMAT_BYTES,

   466       GST_SEEK_FLAG_NONE,

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

   468   fail_unless (segment.start == 0);

   469   

   470   fail_unless (segment.stop == 100);

   471   

   472   fail_unless (segment.time == 0);

   473   

   474   fail_unless (segment.last_stop == 100);

   475   

   476   fail_unless (update == TRUE);

   477   

   478 

   479   /* update */

   480   gst_segment_set_seek (&segment, -1.0,

   481       GST_FORMAT_BYTES,

   482       GST_SEEK_FLAG_NONE,

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

   484   fail_unless (segment.start == 10);

   485   

   486   fail_unless (segment.stop == 80);

   487   

   488   fail_unless (segment.time == 10);

   489   

   490   fail_unless (segment.last_stop == 80);

   491   

   492   fail_unless (update == TRUE);

   493   

   494 

   495   gst_segment_set_seek (&segment, -1.0,

   496       GST_FORMAT_BYTES,

   497       GST_SEEK_FLAG_NONE,

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

   499   fail_unless (segment.start == 20);

   500   

   501   fail_unless (segment.stop == 80);

   502   

   503   fail_unless (segment.time == 20);

   504   

   505   fail_unless (segment.last_stop == 80);

   506   

   507   fail_unless (update == FALSE);

   508   

   509   

   510   std_log(LOG_FILENAME_LINE, "Test Successful");

   511   create_xml(0);

   512 }

   513 

   514 

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

   516 void segment_seek_rate()

   517 {

   518   GstSegment segment;

   519   gboolean update;

   520 

   521   xmlfile = "segment_seek_rate";

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

   523   

   524   gst_segment_init (&segment, GST_FORMAT_BYTES);

   525 

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

   527    * a start or stop position. */

   528   gst_segment_set_seek (&segment, 2.0,

   529       GST_FORMAT_UNDEFINED,

   530       GST_SEEK_FLAG_NONE,

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

   532   fail_unless (segment.format == GST_FORMAT_BYTES);

   533   

   534   fail_unless (segment.start == 0);

   535   

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

   537   

   538   fail_unless (segment.rate == 2.0);

   539   

   540   fail_unless (update == FALSE);

   541   

   542 

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

   544   gst_segment_set_seek (&segment, 2.0,

   545       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   547   fail_unless (segment.format == GST_FORMAT_BYTES);

   548   

   549 

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

   551   gst_segment_set_seek (&segment, 2.0,

   552       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   554   fail_unless (segment.format == GST_FORMAT_BYTES);

   555   

   556   fail_unless (segment.start == 0);

   557   

   558 

   559   gst_segment_set_seek (&segment, 2.0,

   560       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   562 

   563   gst_segment_set_seek (&segment, 2.0,

   564       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   566 

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

   568   gst_segment_set_seek (&segment, 2.0,

   569       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   571 

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

   573   gst_segment_set_seek (&segment, 2.0,

   574       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   576 

   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_END, 0, &update);

   580 

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

   582   gst_segment_set_seek (&segment, 3.0,

   583       GST_FORMAT_BYTES,

   584       GST_SEEK_FLAG_NONE,

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

   586   fail_unless (segment.format == GST_FORMAT_BYTES);

   587   

   588   fail_unless (segment.start == 0);

   589   

   590   fail_unless (segment.stop == 100);

   591   

   592   fail_unless (segment.rate == 3.0);

   593   

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

   595    * playback mode.*/

   596   fail_unless (update == FALSE);

   597   

   598 

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

   600   gst_segment_set_seek (&segment, 2.0,

   601       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   603   fail_unless (segment.stop == 100);

   604   

   605 

   606   gst_segment_set_seek (&segment, 2.0,

   607       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   609   fail_unless (segment.stop == 100);

   610   

   611 

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

   613   gst_segment_set_seek (&segment, 2.0,

   614       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

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

   617   

   618 

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

   620    * duration, if the formats match */

   621   gst_segment_set_duration (&segment, GST_FORMAT_BYTES, 200);

   622   fail_unless (segment.duration == 200);

   623   

   624 

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

   626    * duration */

   627   gst_segment_set_seek (&segment, 2.0,

   628       GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,

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

   630   fail_unless (segment.stop == 200);

   631   

   632   fail_unless (segment.duration == 200);

   633   

   634 

   635   /* subtract 100 from the end */

   636   gst_segment_set_seek (&segment, 2.0,

   637       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

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

   639   fail_unless (segment.stop == 100);

   640   

   641   fail_unless (segment.duration == 200);

   642   

   643 

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

   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 == 200);

   649   

   650   fail_unless (segment.duration == 200);

   651   

   652 

   653   /* add 300 to the start, 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_CUR, 300, GST_SEEK_TYPE_END, 0, &update);

   657   fail_unless (segment.start == 200);

   658   

   659   fail_unless (segment.stop == 200);

   660   

   661   fail_unless (segment.duration == 200);

   662   

   663 

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

   665   gst_segment_set_seek (&segment, 2.0,

   666       GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,

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

   668   fail_unless (segment.start == 0);

   669   

   670   fail_unless (segment.stop == 200);

   671   

   672   fail_unless (segment.duration == 200);

   673   

   674   

   675   std_log(LOG_FILENAME_LINE, "Test Successful");

   676   create_xml(0);

   677 }

   678 

   679 

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

   681 void segment_newsegment_open()

   682 {

   683   GstSegment segment;

   684 

   685   xmlfile = "segment_newsegment_open";

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

   687 

   688   gst_segment_init (&segment, GST_FORMAT_BYTES);

   689 

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

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

   692 

   693   fail_unless (segment.rate == 1.0);

   694   

   695   fail_unless (segment.format == GST_FORMAT_BYTES);

   696   

   697   fail_unless (segment.flags == 0);

   698   

   699   fail_unless (segment.start == 0);

   700   

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

   702   

   703   fail_unless (segment.time == 0);

   704   

   705   fail_unless (segment.accum == 0);

   706   

   707   fail_unless (segment.last_stop == 0);

   708   

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

   710   

   711 

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

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

   714 

   715   fail_unless (segment.start == 0);

   716   

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

   718   

   719   fail_unless (segment.time == 0);

   720   

   721   fail_unless (segment.accum == 0);

   722   

   723 

   724   /* update, nothing changes */

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

   726 

   727   fail_unless (segment.start == 0);

   728   

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

   730   

   731   fail_unless (segment.time == 0);

   732   

   733   fail_unless (segment.accum == 0);

   734   

   735 

   736   /* update */

   737   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   738       GST_FORMAT_BYTES, 100, -1, 100);

   739 

   740   fail_unless (segment.start == 100);

   741   

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

   743   

   744   fail_unless (segment.time == 100);

   745   

   746   fail_unless (segment.accum == 100);

   747   

   748 

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

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

   751 

   752   fail_unless (segment.start == 0);

   753   

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

   755   

   756   fail_unless (segment.time == 0);

   757   

   758   fail_unless (segment.accum == 100);

   759   

   760 

   761   gst_segment_set_last_stop (&segment, GST_FORMAT_BYTES, 200);

   762 

   763   /* last_stop 200, accum changes */

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

   765 

   766   fail_unless (segment.start == 0);

   767   

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

   769   

   770   fail_unless (segment.time == 0);

   771   

   772   fail_unless (segment.accum == 300);

   773   

   774   

   775   std_log(LOG_FILENAME_LINE, "Test Successful");

   776   create_xml(0);

   777 

   778 }

   779 

   780 

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

   782 void segment_newsegment_closed()

   783 {

   784   GstSegment segment;

   785 

   786   xmlfile = "segment_newsegment_closed";

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

   788 

   789   gst_segment_init (&segment, GST_FORMAT_BYTES);

   790 

   791   gst_segment_set_newsegment (&segment, FALSE, 1.0,

   792       GST_FORMAT_BYTES, 0, 200, 0);

   793 

   794   fail_unless (segment.rate == 1.0);

   795   

   796   fail_unless (segment.format == GST_FORMAT_BYTES);

   797   

   798   fail_unless (segment.flags == 0);

   799   

   800   fail_unless (segment.start == 0);

   801   

   802   fail_unless (segment.stop == 200);

   803   

   804   fail_unless (segment.time == 0);

   805   

   806   fail_unless (segment.accum == 0);

   807   

   808   fail_unless (segment.last_stop == 0);

   809   

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

   811   

   812 

   813   /* do an update */

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

   815 

   816   fail_unless (segment.start == 0);

   817   

   818   fail_unless (segment.stop == 300);

   819   

   820   fail_unless (segment.time == 0);

   821   

   822   fail_unless (segment.accum == 0);

   823   

   824 

   825   /* and a new accumulated one */

   826   gst_segment_set_newsegment (&segment, FALSE, 1.0,

   827       GST_FORMAT_BYTES, 100, 400, 300);

   828 

   829   fail_unless (segment.start == 100);

   830   

   831   fail_unless (segment.stop == 400);

   832   

   833   fail_unless (segment.time == 300);

   834   

   835   fail_unless (segment.accum == 300);

   836   

   837 

   838   /* and a new updated one */

   839   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   840       GST_FORMAT_BYTES, 100, 500, 300);

   841 

   842   fail_unless (segment.start == 100);

   843   

   844   fail_unless (segment.stop == 500);

   845   

   846   fail_unless (segment.time == 300);

   847   

   848   fail_unless (segment.accum == 300);

   849   

   850 

   851   /* and a new partially updated one */

   852   gst_segment_set_newsegment (&segment, TRUE, 1.0,

   853       GST_FORMAT_BYTES, 200, 500, 400);

   854 

   855   fail_unless (segment.start == 200);

   856   

   857   fail_unless (segment.stop == 500);

   858   

   859   fail_unless (segment.time == 400);

   860   

   861   fail_unless (segment.accum == 400);

   862   

   863   

   864   std_log(LOG_FILENAME_LINE, "Test Successful");

   865   create_xml(0);

   866 }

   867 

   868 

   869 

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

   871 void segment_newsegment_streamtime()

   872 {

   873   GstSegment segment;

   874   gint64 result;

   875 

   876   xmlfile = "segment_newsegment_streamtime";

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

   878 

   879   gst_segment_init (&segment, GST_FORMAT_TIME);

   880 

   881   /***************************

   882    * Normal segment

   883    ***************************/

   884   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   885       GST_FORMAT_TIME, 0, 200, 0);

   886 

   887   fail_unless (segment.rate == 1.0);

   888   

   889   fail_unless (segment.applied_rate == 1.0);

   890   

   891   fail_unless (segment.format == GST_FORMAT_TIME);

   892   

   893   fail_unless (segment.flags == 0);

   894   

   895   fail_unless (segment.start == 0);

   896   

   897   fail_unless (segment.stop == 200);

   898   

   899   fail_unless (segment.time == 0);

   900   

   901   fail_unless (segment.accum == 0);

   902   

   903   fail_unless (segment.last_stop == 0);

   904   

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

   906   

   907 

   908   /* invalid time gives invalid result */

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

   910   fail_unless (result == -1);

   911   

   912 

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

   914   fail_unless (result == 0);

   915   

   916 

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

   918   fail_unless (result == 100);

   919   

   920 

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

   922   fail_unless (result == 200);

   923   

   924 

   925   /* outside of the segment */

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

   927   fail_unless (result == -1);

   928   

   929 

   930   /*********************

   931    * time shifted by 500

   932    *********************/

   933   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   934       GST_FORMAT_TIME, 0, 200, 500);

   935 

   936   fail_unless (segment.accum == 200);

   937   

   938 

   939   /* invalid time gives invalid result */

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

   941   fail_unless (result == -1);

   942   

   943 

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

   945   fail_unless (result == 500);

   946   

   947 

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

   949   fail_unless (result == 600);

   950   

   951 

   952   /* outside of the segment */

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

   954   fail_unless (result == -1);

   955   

   956 

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

   958   fail_unless (result == -1);

   959   

   960 

   961   /*********************

   962    * time offset by 500

   963    *********************/

   964   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

   965       GST_FORMAT_TIME, 500, 700, 0);

   966 

   967   fail_unless (segment.accum == 400);

   968   

   969 

   970   /* invalid time gives invalid result */

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

   972   fail_unless (result == -1);

   973   

   974 

   975   /* before segment is invalid */

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

   977   fail_unless (result == -1);

   978   

   979 

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

   981   fail_unless (result == 0);

   982   

   983 

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

   985   fail_unless (result == 100);

   986   

   987 

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

   989   fail_unless (result == 200);

   990   

   991 

   992   /* outside of the segment */

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

   994   fail_unless (result == -1);

   995   

   996 

   997   /*************************************

   998    * time offset by 500, shifted by 200

   999    *************************************/

  1000   gst_segment_set_newsegment_full (&segment, FALSE, 1.0, 1.0,

  1001       GST_FORMAT_TIME, 500, 700, 200);

  1002 

  1003   fail_unless (segment.accum == 600);

  1004   

  1005 

  1006   /* invalid time gives invalid result */

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

  1008   fail_unless (result == -1);

  1009   

  1010 

  1011   /* before segment is invalid */

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

  1013   fail_unless (result == -1);

  1014   

  1015 

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

  1017   fail_unless (result == 200);

  1018   

  1019 

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

  1021   fail_unless (result == 300);

  1022   

  1023 

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

  1025   fail_unless (result == 400);

  1026   

  1027 

  1028   /* outside of the segment */

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

  1030   fail_unless (result == -1);

  1031   

  1032   

  1033   std_log(LOG_FILENAME_LINE, "Test Successful");

  1034   create_xml(0);

  1035 }

  1036 

  1037 

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

  1039 void segment_newsegment_streamtime_rate()

  1040 {

  1041   GstSegment segment;

  1042   gint64 result;

  1043 

  1044   xmlfile = "segment_newsegment_streamtime_rate";

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

  1046 

  1047   gst_segment_init (&segment, GST_FORMAT_TIME);

  1048 

  1049   /***************************

  1050    * Normal segment rate 2.0

  1051    ***************************/

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

  1053       GST_FORMAT_TIME, 0, 200, 0);

  1054 

  1055   fail_unless (segment.rate == 2.0);

  1056   

  1057   fail_unless (segment.applied_rate == 1.0);

  1058   

  1059   fail_unless (segment.format == GST_FORMAT_TIME);

  1060   

  1061   fail_unless (segment.flags == 0);

  1062   

  1063   fail_unless (segment.start == 0);

  1064   

  1065   fail_unless (segment.stop == 200);

  1066   

  1067   fail_unless (segment.time == 0);

  1068   

  1069   fail_unless (segment.accum == 0);

  1070   

  1071   fail_unless (segment.last_stop == 0);

  1072   

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

  1074   

  1075 

  1076   /* invalid time gives invalid result */

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

  1078   fail_unless (result == -1);

  1079   

  1080 

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

  1082   fail_unless (result == 0);

  1083   

  1084 

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

  1086   fail_unless (result == 100);

  1087   

  1088 

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

  1090   fail_unless (result == 150);

  1091   

  1092 

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

  1094   fail_unless (result == 200);

  1095   

  1096 

  1097   /* outside of the segment */

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

  1099   fail_unless (result == -1);

  1100   

  1101 

  1102   /***************************************

  1103    * Normal segment rate 2.0, offset

  1104    ***************************************/

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

  1106       GST_FORMAT_TIME, 100, 300, 0);

  1107 

  1108   fail_unless (segment.accum == 100);

  1109   

  1110 

  1111   /* invalid time gives invalid result */

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

  1113   fail_unless (result == -1);

  1114   

  1115 

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

  1117   fail_unless (result == 0);

  1118   

  1119 

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

  1121   fail_unless (result == 100);

  1122   

  1123 

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

  1125   fail_unless (result == 150);

  1126   

  1127 

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

  1129   fail_unless (result == 200);

  1130   

  1131 

  1132   /* outside of the segment */

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

  1134   fail_unless (result == -1);

  1135