2 * Copyright (C) 2005 Jan Schmidt <thaytan@mad.scientist.com>
3 * 2009 Wim Taymans <wim.taymans@gmail.com>
5 * gstsegment.c: Unit test for segments
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
23 #include <gst/check/gstcheck.h>
25 /* mess with the segment structure in the bytes format */
26 GST_START_TEST (segment_seek_nosize)
30 guint64 cstart, cstop;
33 gst_segment_init (&segment, GST_FORMAT_BYTES);
35 /* configure segment to start 100 */
36 gst_segment_do_seek (&segment, 1.0,
39 GST_SEEK_TYPE_SET, 100, GST_SEEK_TYPE_NONE, -1, &update);
40 fail_unless (segment.start == 100);
41 fail_unless (segment.stop == -1);
42 fail_unless (update == TRUE);
44 /* configure segment to stop relative, should not do anything since
46 gst_segment_do_seek (&segment, 1.0,
49 GST_SEEK_TYPE_NONE, 200, GST_SEEK_TYPE_CUR, -100, &update);
50 fail_unless (segment.start == 100);
51 fail_unless (segment.stop == -1);
52 fail_unless (update == FALSE);
54 /* do some clipping on the open range */
55 /* completely outside */
56 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);
57 fail_unless (res == FALSE);
59 /* touching lower bound, still outside of the segment */
60 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);
61 fail_unless (res == FALSE);
63 /* partially inside */
64 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);
65 fail_unless (res == TRUE);
66 fail_unless (cstart == 100);
67 fail_unless (cstop == 150);
69 /* inside, touching lower bound */
70 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
71 100, 150, &cstart, &cstop);
72 fail_unless (res == TRUE);
73 fail_unless (cstart == 100);
74 fail_unless (cstop == 150);
76 /* special case, 0 duration and outside segment */
77 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 90, 90, &cstart, &cstop);
78 fail_unless (res == FALSE);
80 /* special case, 0 duration and touching lower bound, i.e. inside segment */
81 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
82 100, 100, &cstart, &cstop);
83 fail_unless (res == TRUE);
84 fail_unless (cstart == 100);
85 fail_unless (cstop == 100);
87 /* special case, 0 duration and inside the segment */
88 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
89 120, 120, &cstart, &cstop);
90 fail_unless (res == TRUE);
91 fail_unless (cstart == 120);
92 fail_unless (cstop == 120);
94 /* completely inside */
95 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
96 150, 200, &cstart, &cstop);
97 fail_unless (res == TRUE);
98 fail_unless (cstart == 150);
99 fail_unless (cstop == 200);
102 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);
103 fail_unless (res == FALSE);
105 /* start outside, we don't know the stop */
106 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);
107 fail_unless (res == TRUE);
108 fail_unless (cstart == 100);
109 fail_unless (cstop == -1);
111 /* start on lower bound */
112 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);
113 fail_unless (res == TRUE);
114 fail_unless (cstart == 100);
115 fail_unless (cstop == -1);
118 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);
119 fail_unless (res == TRUE);
120 fail_unless (cstart == 150);
121 fail_unless (cstop == -1);
123 /* add 100 to start, set stop to 300 */
124 gst_segment_do_seek (&segment, 1.0,
127 GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 300, &update);
128 fail_unless (segment.start == 200);
129 fail_unless (segment.stop == 300);
130 fail_unless (update == TRUE);
133 /* add 100 to start (to 300), set stop to 200, this is not allowed.
134 * nothing should be updated in the segment. A g_warning is
136 ASSERT_CRITICAL (gst_segment_do_seek (&segment, 1.0,
139 GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 200, &update));
140 fail_unless (segment.start == 200);
141 fail_unless (segment.stop == 300);
142 /* update didn't change */
143 fail_unless (update == FALSE);
146 /* seek relative to end, should not do anything since size is
148 gst_segment_do_seek (&segment, 1.0,
151 GST_SEEK_TYPE_END, -300, GST_SEEK_TYPE_END, -100, &update);
152 fail_unless (segment.start == 200);
153 fail_unless (segment.stop == 300);
154 fail_unless (update == FALSE);
156 /* completely outside */
157 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);
158 fail_unless (res == FALSE);
160 /* touching lower bound */
161 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 200, &cstart, &cstop);
162 fail_unless (res == FALSE);
164 /* partially inside */
165 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 250, &cstart, &cstop);
166 fail_unless (res == TRUE);
167 fail_unless (cstart == 200);
168 fail_unless (cstop == 250);
170 /* inside, touching lower bound */
171 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
172 200, 250, &cstart, &cstop);
173 fail_unless (res == TRUE);
174 fail_unless (cstart == 200);
175 fail_unless (cstop == 250);
177 /* completely inside */
178 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
179 250, 290, &cstart, &cstop);
180 fail_unless (res == TRUE);
181 fail_unless (cstart == 250);
182 fail_unless (cstop == 290);
184 /* partially inside */
185 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
186 250, 350, &cstart, &cstop);
187 fail_unless (res == TRUE);
188 fail_unless (cstart == 250);
189 fail_unless (cstop == 300);
192 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);
193 fail_unless (res == FALSE);
196 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);
197 fail_unless (res == TRUE);
198 fail_unless (cstart == 200);
199 fail_unless (cstop == 300);
201 /* start on lower bound */
202 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 200, -1, &cstart, &cstop);
203 fail_unless (res == TRUE);
204 fail_unless (cstart == 200);
205 fail_unless (cstop == 300);
208 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 250, -1, &cstart, &cstop);
209 fail_unless (res == TRUE);
210 fail_unless (cstart == 250);
211 fail_unless (cstop == 300);
213 /* start outside on boundary */
214 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 300, -1, &cstart, &cstop);
215 fail_unless (res == FALSE);
217 /* start completely outside */
218 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 350, -1, &cstart, &cstop);
219 fail_unless (res == FALSE);
224 /* mess with the segment structure in the bytes format */
225 GST_START_TEST (segment_seek_size)
229 guint64 cstart, cstop;
232 gst_segment_init (&segment, GST_FORMAT_BYTES);
233 segment.duration = 200;
235 /* configure segment to start 100 */
236 gst_segment_do_seek (&segment, 1.0,
239 GST_SEEK_TYPE_SET, 100, GST_SEEK_TYPE_NONE, -1, &update);
240 fail_unless (segment.start == 100);
241 fail_unless (segment.stop == -1);
242 fail_unless (update == TRUE);
244 /* configure segment to stop relative, does not update stop
245 * since we did not set it before. */
246 gst_segment_do_seek (&segment, 1.0,
249 GST_SEEK_TYPE_NONE, 200, GST_SEEK_TYPE_CUR, -100, &update);
250 fail_unless (segment.start == 100);
251 fail_unless (segment.stop == -1);
252 fail_unless (update == FALSE);
254 /* do some clipping on the open range */
255 /* completely outside */
256 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);
257 fail_unless (res == FALSE);
259 /* touching lower bound */
260 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);
261 fail_unless (res == FALSE);
263 /* partially inside */
264 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);
265 fail_unless (res == TRUE);
266 fail_unless (cstart == 100);
267 fail_unless (cstop == 150);
269 /* inside, touching lower bound */
270 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
271 100, 150, &cstart, &cstop);
272 fail_unless (res == TRUE);
273 fail_unless (cstart == 100);
274 fail_unless (cstop == 150);
276 /* completely inside */
277 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
278 150, 200, &cstart, &cstop);
279 fail_unless (res == TRUE);
280 fail_unless (cstart == 150);
281 fail_unless (cstop == 200);
283 /* partially inside, clip to size */
284 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
285 150, 300, &cstart, &cstop);
286 fail_unless (res == TRUE);
287 fail_unless (cstart == 150);
288 fail_unless (cstop == 200);
291 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);
292 fail_unless (res == FALSE);
295 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);
296 fail_unless (res == TRUE);
297 fail_unless (cstart == 100);
298 fail_unless (cstop == -1);
300 /* start on lower bound */
301 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);
302 fail_unless (res == TRUE);
303 fail_unless (cstart == 100);
304 fail_unless (cstop == -1);
307 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);
308 fail_unless (res == TRUE);
309 fail_unless (cstart == 150);
310 fail_unless (cstop == -1);
312 /* add 100 to start, set stop to 300, stop clips to 200 */
313 gst_segment_do_seek (&segment, 1.0,
316 GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 300, &update);
317 fail_unless (segment.start == 200);
318 fail_unless (segment.stop == 200);
320 /* add 100 to start (to 300), set stop to 200, this clips start
322 gst_segment_do_seek (&segment, 1.0,
325 GST_SEEK_TYPE_CUR, 100, GST_SEEK_TYPE_SET, 200, &update);
326 fail_unless (segment.start == 200);
327 fail_unless (segment.stop == 200);
328 fail_unless (update == FALSE);
330 /* seek relative to end */
331 gst_segment_do_seek (&segment, 1.0,
334 GST_SEEK_TYPE_END, -100, GST_SEEK_TYPE_END, -20, &update);
335 fail_unless (segment.start == 100);
336 fail_unless (segment.stop == 180);
337 fail_unless (update == TRUE);
339 /* completely outside */
340 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 0, 50, &cstart, &cstop);
341 fail_unless (res == FALSE);
343 /* touching lower bound */
344 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 100, &cstart, &cstop);
345 fail_unless (res == FALSE);
347 /* partially inside */
348 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, 150, &cstart, &cstop);
349 fail_unless (res == TRUE);
350 fail_unless (cstart == 100);
351 fail_unless (cstop == 150);
353 /* inside, touching lower bound */
354 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
355 100, 150, &cstart, &cstop);
356 fail_unless (res == TRUE);
357 fail_unless (cstart == 100);
358 fail_unless (cstop == 150);
360 /* completely inside */
361 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
362 150, 170, &cstart, &cstop);
363 fail_unless (res == TRUE);
364 fail_unless (cstart == 150);
365 fail_unless (cstop == 170);
367 /* partially inside */
368 res = gst_segment_clip (&segment, GST_FORMAT_BYTES,
369 150, 250, &cstart, &cstop);
370 fail_unless (res == TRUE);
371 fail_unless (cstart == 150);
372 fail_unless (cstop == 180);
375 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, -1, 100, &cstart, &cstop);
376 fail_unless (res == FALSE);
379 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 50, -1, &cstart, &cstop);
380 fail_unless (res == TRUE);
381 fail_unless (cstart == 100);
382 fail_unless (cstop == 180);
384 /* start on lower bound */
385 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 100, -1, &cstart, &cstop);
386 fail_unless (res == TRUE);
387 fail_unless (cstart == 100);
388 fail_unless (cstop == 180);
391 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 150, -1, &cstart, &cstop);
392 fail_unless (res == TRUE);
393 fail_unless (cstart == 150);
394 fail_unless (cstop == 180);
396 /* start outside on boundary */
397 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 180, -1, &cstart, &cstop);
398 fail_unless (res == FALSE);
400 /* start completely outside */
401 res = gst_segment_clip (&segment, GST_FORMAT_BYTES, 250, -1, &cstart, &cstop);
402 fail_unless (res == FALSE);
407 GST_START_TEST (segment_seek_reverse)
412 gst_segment_init (&segment, GST_FORMAT_BYTES);
413 segment.duration = 200;
415 /* configure segment to stop 100 */
416 gst_segment_do_seek (&segment, -1.0,
419 GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_SET, 100, &update);
420 fail_unless (segment.start == 0);
421 fail_unless (segment.stop == 100);
422 fail_unless (segment.time == 0);
423 fail_unless (segment.position == 100);
424 fail_unless (update == TRUE);
427 gst_segment_do_seek (&segment, -1.0,
430 GST_SEEK_TYPE_SET, 10, GST_SEEK_TYPE_CUR, -20, &update);
431 fail_unless (segment.start == 10);
432 fail_unless (segment.stop == 80);
433 fail_unless (segment.time == 10);
434 fail_unless (segment.position == 80);
435 fail_unless (update == TRUE);
437 gst_segment_do_seek (&segment, -1.0,
440 GST_SEEK_TYPE_SET, 20, GST_SEEK_TYPE_NONE, 0, &update);
441 fail_unless (segment.start == 20);
442 fail_unless (segment.stop == 80);
443 fail_unless (segment.time == 20);
444 fail_unless (segment.position == 80);
445 fail_unless (update == FALSE);
450 /* mess with the segment structure in the bytes format */
451 GST_START_TEST (segment_seek_rate)
456 gst_segment_init (&segment, GST_FORMAT_BYTES);
458 /* configure segment to rate 2.0 */
459 gst_segment_do_seek (&segment, 2.0,
462 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_NONE, -1, &update);
463 fail_unless (segment.format == GST_FORMAT_BYTES);
464 fail_unless (segment.start == 0);
465 fail_unless (segment.stop == -1);
466 fail_unless (segment.rate == 2.0);
467 fail_unless (update == FALSE);
470 /* 0 is the same in all formats and should not fail */
471 gst_segment_do_seek (&segment, 2.0,
472 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
473 GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1, &update);
474 fail_unless (segment.format == GST_FORMAT_BYTES);
476 /* set to -1 means start from 0 */
477 gst_segment_do_seek (&segment, 2.0,
478 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
479 GST_SEEK_TYPE_SET, -1, GST_SEEK_TYPE_NONE, -1, &update);
480 fail_unless (segment.format == GST_FORMAT_BYTES);
481 fail_unless (segment.start == 0);
483 gst_segment_do_seek (&segment, 2.0,
484 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
485 GST_SEEK_TYPE_CUR, 0, GST_SEEK_TYPE_NONE, -1, &update);
487 gst_segment_do_seek (&segment, 2.0,
488 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
489 GST_SEEK_TYPE_END, 0, GST_SEEK_TYPE_NONE, -1, &update);
491 /* -1 for end is fine too in all formats */
492 gst_segment_do_seek (&segment, 2.0,
493 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
494 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, -1, &update);
496 /* 0 as relative end is fine too */
497 gst_segment_do_seek (&segment, 2.0,
498 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
499 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_CUR, 0, &update);
501 gst_segment_do_seek (&segment, 2.0,
502 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
503 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);
506 /* set a real stop position, this must happen in bytes */
507 gst_segment_do_seek (&segment, 3.0,
510 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, 100, &update);
511 fail_unless (segment.format == GST_FORMAT_BYTES);
512 fail_unless (segment.start == 0);
513 fail_unless (segment.stop == 100);
514 fail_unless (segment.rate == 3.0);
515 /* no seek should happen, we just updated the stop position in forward
517 fail_unless (update == FALSE);
520 /* 0 as relative end is fine too */
521 gst_segment_do_seek (&segment, 2.0,
522 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
523 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_CUR, 0, &update);
524 fail_unless (segment.stop == 100);
526 gst_segment_do_seek (&segment, 2.0,
527 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
528 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);
529 fail_unless (segment.stop == 100);
531 /* -1 for end is fine too in all formats */
532 gst_segment_do_seek (&segment, 2.0,
533 GST_FORMAT_TIME, GST_SEEK_FLAG_NONE,
534 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_SET, -1, &update);
535 fail_unless (segment.stop == -1);
538 /* set some duration, stop -1 END seeks will now work with the
539 * duration, if the formats match */
540 segment.duration = 200;
541 fail_unless (segment.duration == 200);
543 /* seek to end with 0 should set the stop to the duration */
544 gst_segment_do_seek (&segment, 2.0,
545 GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,
546 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 0, &update);
547 fail_unless (segment.stop == 200);
548 fail_unless (segment.duration == 200);
550 /* subtract 100 from the end */
551 gst_segment_do_seek (&segment, 2.0,
552 GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,
553 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, -100, &update);
554 fail_unless (segment.stop == 100);
555 fail_unless (segment.duration == 200);
557 /* add 100 to the duration, this should be clamped to the duration */
558 gst_segment_do_seek (&segment, 2.0,
559 GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,
560 GST_SEEK_TYPE_NONE, -1, GST_SEEK_TYPE_END, 100, &update);
561 fail_unless (segment.stop == 200);
562 fail_unless (segment.duration == 200);
564 /* add 300 to the start, this should be clamped to the duration */
565 gst_segment_do_seek (&segment, 2.0,
566 GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,
567 GST_SEEK_TYPE_CUR, 300, GST_SEEK_TYPE_END, 0, &update);
568 fail_unless (segment.start == 200);
569 fail_unless (segment.stop == 200);
570 fail_unless (segment.duration == 200);
572 /* subtract 300 from the start, this should be clamped to 0 */
573 gst_segment_do_seek (&segment, 2.0,
574 GST_FORMAT_BYTES, GST_SEEK_FLAG_NONE,
575 GST_SEEK_TYPE_CUR, -300, GST_SEEK_TYPE_END, 0, &update);
576 GST_DEBUG ("%" G_GINT64_FORMAT, segment.start);
577 fail_unless (segment.start == 0);
578 fail_unless (segment.stop == 200);
579 fail_unless (segment.duration == 200);
585 /* mess with the segment structure in the bytes format */
586 GST_START_TEST (segment_newsegment_open)
590 gst_segment_init (&segment, GST_FORMAT_BYTES);
592 /* time should also work for starting from 0 */
593 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0, GST_FORMAT_TIME, 0, -1,
596 fail_unless (segment.rate == 1.0);
597 fail_unless (segment.format == GST_FORMAT_BYTES);
598 fail_unless (segment.flags == 0);
599 fail_unless (segment.start == 0);
600 fail_unless (segment.stop == -1);
601 fail_unless (segment.time == 0);
602 fail_unless (segment.base == 0);
603 fail_unless (segment.position == 0);
604 fail_unless (segment.duration == -1);
606 /* we set stop but in the wrong format, stop stays open. */
607 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0, GST_FORMAT_TIME, 0,
610 fail_unless (segment.start == 0);
611 fail_unless (segment.stop == -1);
612 fail_unless (segment.time == 0);
613 fail_unless (segment.base == 0);
614 fail_unless (segment.position == 0);
616 /* update, nothing changes */
617 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0, GST_FORMAT_BYTES, 0, -1,
620 fail_unless (segment.start == 0);
621 fail_unless (segment.stop == -1);
622 fail_unless (segment.time == 0);
623 fail_unless (segment.base == 0);
624 fail_unless (segment.position == 0);
627 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0,
628 GST_FORMAT_BYTES, 100, -1, 100);
630 fail_unless (segment.start == 100);
631 fail_unless (segment.stop == -1);
632 fail_unless (segment.time == 100);
633 fail_unless (segment.base == 100);
634 fail_unless (segment.position == 100);
636 /* last_stop 0, base does not change */
637 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0, GST_FORMAT_BYTES, 0,
640 fail_unless (segment.start == 0);
641 fail_unless (segment.stop == -1);
642 fail_unless (segment.time == 0);
643 fail_unless (segment.base == 100);
645 gst_segment_set_last_stop (&segment, GST_FORMAT_BYTES, 200);
647 fail_unless (segment.position == 200);
649 /* last_stop 200, base changes */
650 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0, GST_FORMAT_BYTES, 0,
653 fail_unless (segment.start == 0);
654 fail_unless (segment.stop == -1);
655 fail_unless (segment.time == 0);
656 fail_unless (segment.base == 300);
657 fail_unless (segment.position == 0);
663 /* mess with the segment structure in the bytes format */
664 GST_START_TEST (segment_newsegment_closed)
668 gst_segment_init (&segment, GST_FORMAT_BYTES);
670 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
671 GST_FORMAT_BYTES, 0, 200, 0);
673 fail_unless (segment.rate == 1.0);
674 fail_unless (segment.format == GST_FORMAT_BYTES);
675 fail_unless (segment.flags == 0);
676 fail_unless (segment.start == 0);
677 fail_unless (segment.stop == 200);
678 fail_unless (segment.time == 0);
679 fail_unless (segment.base == 0);
680 fail_unless (segment.position == 0);
681 fail_unless (segment.duration == -1);
683 /* assume we advanced to position 40 */
684 gst_segment_set_last_stop (&segment, GST_FORMAT_BYTES, 40);
685 fail_unless (segment.position == 40);
687 /* do an update to the start, last_stop is unchanged because it's bigger */
688 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0, GST_FORMAT_BYTES, 20,
691 fail_unless (segment.start == 20);
692 fail_unless (segment.stop == 200);
693 fail_unless (segment.time == 20);
694 fail_unless (segment.base == 20);
695 fail_unless (segment.position == 40);
697 /* do an update past our last_stop, it should be updated now */
698 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0, GST_FORMAT_BYTES, 50,
701 fail_unless (segment.start == 50);
702 fail_unless (segment.stop == 300);
703 fail_unless (segment.time == 50);
704 fail_unless (segment.base == 50);
705 fail_unless (segment.position == 50);
707 /* and a new accumulated one */
708 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
709 GST_FORMAT_BYTES, 100, 400, 300);
711 fail_unless (segment.start == 100);
712 fail_unless (segment.stop == 400);
713 fail_unless (segment.time == 300);
714 fail_unless (segment.base == 300);
716 /* and a new updated one */
717 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0,
718 GST_FORMAT_BYTES, 100, 500, 300);
720 fail_unless (segment.start == 100);
721 fail_unless (segment.stop == 500);
722 fail_unless (segment.time == 300);
723 fail_unless (segment.base == 300);
725 /* and a new partially updated one */
726 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0,
727 GST_FORMAT_BYTES, 200, 500, 400);
729 fail_unless (segment.start == 200);
730 fail_unless (segment.stop == 500);
731 fail_unless (segment.time == 400);
732 fail_unless (segment.base == 400);
737 /* mess with the segment structure in the time format */
738 GST_START_TEST (segment_newsegment_streamtime)
743 gst_segment_init (&segment, GST_FORMAT_TIME);
745 /***************************
747 ***************************/
748 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
749 GST_FORMAT_TIME, 0, 200, 0);
751 fail_unless (segment.rate == 1.0);
752 fail_unless (segment.applied_rate == 1.0);
753 fail_unless (segment.format == GST_FORMAT_TIME);
754 fail_unless (segment.flags == 0);
755 fail_unless (segment.start == 0);
756 fail_unless (segment.stop == 200);
757 fail_unless (segment.time == 0);
758 fail_unless (segment.base == 0);
759 fail_unless (segment.position == 0);
760 fail_unless (segment.duration == -1);
762 /* invalid time gives invalid result */
763 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
764 fail_unless (result == -1);
766 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
767 fail_unless (result == 0);
769 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
770 fail_unless (result == 100);
772 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
773 fail_unless (result == 200);
775 /* outside of the segment */
776 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
777 fail_unless (result == -1);
779 /*********************
780 * time shifted by 500
781 *********************/
782 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
783 GST_FORMAT_TIME, 0, 200, 500);
785 fail_unless (segment.base == 200);
787 /* invalid time gives invalid result */
788 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
789 fail_unless (result == -1);
791 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
792 fail_unless (result == 500);
794 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
795 fail_unless (result == 600);
797 /* outside of the segment */
798 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);
799 fail_unless (result == -1);
801 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
802 fail_unless (result == -1);
804 /*********************
806 *********************/
807 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
808 GST_FORMAT_TIME, 500, 700, 0);
810 fail_unless (segment.base == 400);
812 /* invalid time gives invalid result */
813 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
814 fail_unless (result == -1);
816 /* before segment is invalid */
817 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);
818 fail_unless (result == -1);
820 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);
821 fail_unless (result == 0);
823 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 600);
824 fail_unless (result == 100);
826 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 700);
827 fail_unless (result == 200);
829 /* outside of the segment */
830 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 800);
831 fail_unless (result == -1);
833 /*************************************
834 * time offset by 500, shifted by 200
835 *************************************/
836 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
837 GST_FORMAT_TIME, 500, 700, 200);
839 fail_unless (segment.base == 600);
841 /* invalid time gives invalid result */
842 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
843 fail_unless (result == -1);
845 /* before segment is invalid */
846 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);
847 fail_unless (result == -1);
849 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 500);
850 fail_unless (result == 200);
852 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 600);
853 fail_unless (result == 300);
855 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 700);
856 fail_unless (result == 400);
858 /* outside of the segment */
859 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 800);
860 fail_unless (result == -1);
865 /* mess with the segment structure in the time format */
866 GST_START_TEST (segment_newsegment_streamtime_rate)
871 gst_segment_init (&segment, GST_FORMAT_TIME);
873 /***************************
874 * Normal segment rate 2.0
875 ***************************/
876 gst_segment_set_newsegment (&segment, FALSE, 2.0, 1.0,
877 GST_FORMAT_TIME, 0, 200, 0);
879 fail_unless (segment.rate == 2.0);
880 fail_unless (segment.applied_rate == 1.0);
881 fail_unless (segment.format == GST_FORMAT_TIME);
882 fail_unless (segment.flags == 0);
883 fail_unless (segment.start == 0);
884 fail_unless (segment.stop == 200);
885 fail_unless (segment.time == 0);
886 fail_unless (segment.base == 0);
887 fail_unless (segment.position == 0);
888 fail_unless (segment.duration == -1);
890 /* invalid time gives invalid result */
891 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
892 fail_unless (result == -1);
894 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
895 fail_unless (result == 0);
897 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
898 fail_unless (result == 100);
900 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
901 fail_unless (result == 150);
903 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
904 fail_unless (result == 200);
906 /* outside of the segment */
907 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
908 fail_unless (result == -1);
910 /***************************************
911 * Normal segment rate 2.0, offset
912 ***************************************/
913 gst_segment_set_newsegment (&segment, FALSE, 2.0, 1.0,
914 GST_FORMAT_TIME, 100, 300, 0);
916 fail_unless (segment.base == 100);
918 /* invalid time gives invalid result */
919 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
920 fail_unless (result == -1);
922 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
923 fail_unless (result == 0);
925 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
926 fail_unless (result == 100);
928 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 250);
929 fail_unless (result == 150);
931 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
932 fail_unless (result == 200);
934 /* outside of the segment */
935 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);
936 fail_unless (result == -1);
938 /***************************************
939 * Normal segment rate -1.0, offset
940 ***************************************/
942 /* buffers will arrive from 300 to 100 in a sink, stream time
943 * calculation is unaffected by the rate */
944 gst_segment_set_newsegment (&segment, FALSE, -1.0, 1.0,
945 GST_FORMAT_TIME, 100, 300, 0);
947 fail_unless (segment.base == 200);
949 /* invalid time gives invalid result */
950 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
951 fail_unless (result == -1);
953 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
954 fail_unless (result == 0);
956 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
957 fail_unless (result == 100);
959 /***********************************************
960 * Normal segment rate -1.0, offset, time = 200
961 ***********************************************/
962 gst_segment_set_newsegment (&segment, FALSE, -1.0, 1.0,
963 GST_FORMAT_TIME, 100, 300, 200);
965 /* invalid time gives invalid result */
966 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
967 fail_unless (result == -1);
969 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
970 fail_unless (result == 200);
972 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
973 fail_unless (result == 300);
975 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
976 fail_unless (result == 400);
978 /* outside of the segment */
979 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 400);
980 fail_unless (result == -1);
985 /* mess with the segment structure in the time format */
986 GST_START_TEST (segment_newsegment_streamtime_applied_rate)
991 gst_segment_init (&segment, GST_FORMAT_TIME);
993 /***********************************************************
994 * Normal segment rate 1.0, applied rate -1.0
995 * This means the timestamps represents a stream going backwards
996 * starting from @time to 0.
997 ************************************************************/
998 gst_segment_set_newsegment (&segment, FALSE, 1.0, -1.0,
999 GST_FORMAT_TIME, 0, 200, 200);
1001 fail_unless (segment.rate == 1.0);
1002 fail_unless (segment.applied_rate == -1.0);
1003 fail_unless (segment.format == GST_FORMAT_TIME);
1004 fail_unless (segment.flags == 0);
1005 fail_unless (segment.start == 0);
1006 fail_unless (segment.stop == 200);
1007 fail_unless (segment.time == 200);
1008 fail_unless (segment.base == 0);
1009 fail_unless (segment.position == 0);
1010 fail_unless (segment.duration == -1);
1012 /* invalid time gives invalid result */
1013 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1014 fail_unless (result == -1);
1016 /* we count backwards from 200 */
1017 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1018 fail_unless (result == 200);
1020 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1021 fail_unless (result == 100);
1023 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1024 fail_unless (result == 50);
1026 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1027 fail_unless (result == 0);
1029 /* outside of the segment */
1030 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1031 fail_unless (result == -1);
1033 /***********************************************************
1034 * Normal segment rate 1.0, applied rate 2.0
1035 * This means the timestamps represents a stream at twice the
1037 ************************************************************/
1038 gst_segment_set_newsegment (&segment, FALSE, 1.0, 2.0,
1039 GST_FORMAT_TIME, 0, 200, 0);
1041 fail_unless (segment.rate == 1.0);
1042 fail_unless (segment.applied_rate == 2.0);
1043 fail_unless (segment.format == GST_FORMAT_TIME);
1044 fail_unless (segment.flags == 0);
1045 fail_unless (segment.start == 0);
1046 fail_unless (segment.stop == 200);
1047 fail_unless (segment.time == 0);
1048 fail_unless (segment.base == 200);
1049 fail_unless (segment.position == 0);
1050 fail_unless (segment.duration == -1);
1052 /* invalid time gives invalid result */
1053 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1054 fail_unless (result == -1);
1056 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1057 fail_unless (result == 0);
1059 /* the stream prepresents a stream going twice as fast, the position
1060 * in the segment is therefore scaled by the applied rate */
1061 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1062 fail_unless (result == 200);
1064 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1065 fail_unless (result == 300);
1067 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1068 fail_unless (result == 400);
1070 /* outside of the segment */
1071 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1072 fail_unless (result == -1);
1074 /***********************************************************
1075 * Normal segment rate 1.0, applied rate -2.0
1076 * This means the timestamps represents a stream at twice the
1078 ************************************************************/
1079 gst_segment_set_newsegment (&segment, FALSE, 1.0, -2.0,
1080 GST_FORMAT_TIME, 0, 200, 400);
1082 fail_unless (segment.rate == 1.0);
1083 fail_unless (segment.applied_rate == -2.0);
1084 fail_unless (segment.format == GST_FORMAT_TIME);
1085 fail_unless (segment.flags == 0);
1086 fail_unless (segment.start == 0);
1087 fail_unless (segment.stop == 200);
1088 fail_unless (segment.time == 400);
1089 /* previous segment lasted 200, rate of 2.0 was already applied */
1090 fail_unless (segment.base == 400);
1091 fail_unless (segment.position == 0);
1092 fail_unless (segment.duration == -1);
1094 /* invalid time gives invalid result */
1095 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1096 fail_unless (result == -1);
1098 /* we count backwards from 400 */
1099 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1100 fail_unless (result == 400);
1102 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1103 fail_unless (result == 200);
1105 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1106 fail_unless (result == 100);
1108 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1109 fail_unless (result == 0);
1111 /* outside of the segment */
1112 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1113 fail_unless (result == -1);
1115 /***********************************************************
1116 * Normal segment rate 1.0, applied rate -2.0
1117 * This means the timestamps represents a stream at twice the
1118 * reverse rate, start time cannot compensate the complete
1119 * duration of the segment so we stop at 0
1120 ************************************************************/
1121 gst_segment_set_newsegment (&segment, FALSE, 1.0, -2.0,
1122 GST_FORMAT_TIME, 0, 200, 200);
1124 fail_unless (segment.rate == 1.0);
1125 fail_unless (segment.applied_rate == -2.0);
1126 fail_unless (segment.format == GST_FORMAT_TIME);
1127 fail_unless (segment.flags == 0);
1128 fail_unless (segment.start == 0);
1129 fail_unless (segment.stop == 200);
1130 fail_unless (segment.time == 200);
1131 fail_unless (segment.base == 600);
1132 fail_unless (segment.position == 0);
1133 fail_unless (segment.duration == -1);
1135 /* invalid time gives invalid result */
1136 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1137 fail_unless (result == -1);
1139 /* we count backwards from 200 */
1140 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1141 fail_unless (result == 200);
1143 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1144 fail_unless (result == 0);
1147 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1148 fail_unless (result == 0);
1150 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1151 fail_unless (result == 0);
1153 /* outside of the segment */
1154 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1155 fail_unless (result == -1);
1160 /* mess with the segment structure in the time format */
1161 GST_START_TEST (segment_newsegment_streamtime_applied_rate_rate)
1166 gst_segment_init (&segment, GST_FORMAT_TIME);
1168 /***********************************************************
1169 * Segment rate 2.0, applied rate 2.0
1170 * this means we have a double speed stream that we should
1171 * speed up by a factor of 2.0 some more. the resulting
1172 * stream will be played at four times the speed.
1173 ************************************************************/
1174 gst_segment_set_newsegment (&segment, FALSE, 2.0, 2.0,
1175 GST_FORMAT_TIME, 0, 200, 0);
1177 fail_unless (segment.rate == 2.0);
1178 fail_unless (segment.applied_rate == 2.0);
1179 fail_unless (segment.format == GST_FORMAT_TIME);
1180 fail_unless (segment.flags == 0);
1181 fail_unless (segment.start == 0);
1182 fail_unless (segment.stop == 200);
1183 fail_unless (segment.time == 0);
1184 fail_unless (segment.base == 0);
1185 fail_unless (segment.position == 0);
1186 fail_unless (segment.duration == -1);
1188 /* invalid time gives invalid result */
1189 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1190 fail_unless (result == -1);
1192 /* only applied rate affects our calculation of the stream time */
1193 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1194 fail_unless (result == 0);
1196 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1197 fail_unless (result == 200);
1199 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1200 fail_unless (result == 300);
1202 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1203 fail_unless (result == 400);
1205 /* outside of the segment */
1206 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1207 fail_unless (result == -1);
1209 /***********************************************************
1210 * Segment rate 2.0, applied rate -1.0
1211 * this means we have a reverse stream that we should
1212 * speed up by a factor of 2.0
1213 ************************************************************/
1214 gst_segment_set_newsegment (&segment, FALSE, 2.0, -1.0,
1215 GST_FORMAT_TIME, 0, 200, 200);
1217 fail_unless (segment.rate == 2.0);
1218 fail_unless (segment.applied_rate == -1.0);
1219 fail_unless (segment.format == GST_FORMAT_TIME);
1220 fail_unless (segment.flags == 0);
1221 fail_unless (segment.start == 0);
1222 fail_unless (segment.stop == 200);
1223 fail_unless (segment.time == 200);
1224 /* previous segment lasted 100 */
1225 fail_unless (segment.base == 100);
1226 fail_unless (segment.position == 0);
1227 fail_unless (segment.duration == -1);
1229 /* invalid time gives invalid result */
1230 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1231 fail_unless (result == -1);
1233 /* only applied rate affects our calculation of the stream time */
1234 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1235 fail_unless (result == 200);
1237 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1238 fail_unless (result == 100);
1240 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1241 fail_unless (result == 50);
1243 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1244 fail_unless (result == 0);
1246 /* outside of the segment */
1247 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1248 fail_unless (result == -1);
1250 /***********************************************************
1251 * Segment rate -1.0, applied rate -1.0
1252 * this means we have a reverse stream that we should
1253 * reverse to get the normal stream again.
1254 ************************************************************/
1255 gst_segment_set_newsegment (&segment, FALSE, -1.0, -1.0,
1256 GST_FORMAT_TIME, 0, 200, 200);
1258 fail_unless (segment.rate == -1.0);
1259 fail_unless (segment.applied_rate == -1.0);
1260 fail_unless (segment.format == GST_FORMAT_TIME);
1261 fail_unless (segment.flags == 0);
1262 fail_unless (segment.start == 0);
1263 fail_unless (segment.stop == 200);
1264 fail_unless (segment.time == 200);
1265 /* accumulated 100 of previous segment to make 200 */
1266 fail_unless (segment.base == 200);
1267 fail_unless (segment.position == 200);
1268 fail_unless (segment.duration == -1);
1270 /* invalid time gives invalid result */
1271 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1272 fail_unless (result == -1);
1274 /* only applied rate affects our calculation of the stream time */
1275 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1276 fail_unless (result == 200);
1278 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1279 fail_unless (result == 100);
1281 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1282 fail_unless (result == 50);
1284 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1285 fail_unless (result == 0);
1287 /* outside of the segment */
1288 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1289 fail_unless (result == -1);
1291 /***********************************************************
1292 * Segment rate -1.0, applied rate -1.0
1293 * this means we have a reverse stream that we should
1294 * reverse to get the normal stream again.
1295 ************************************************************/
1296 gst_segment_set_newsegment (&segment, FALSE, -1.0, 2.0,
1297 GST_FORMAT_TIME, 0, 200, 0);
1299 fail_unless (segment.rate == -1.0);
1300 fail_unless (segment.applied_rate == 2.0);
1301 fail_unless (segment.format == GST_FORMAT_TIME);
1302 fail_unless (segment.flags == 0);
1303 fail_unless (segment.start == 0);
1304 fail_unless (segment.stop == 200);
1305 fail_unless (segment.time == 0);
1306 fail_unless (segment.base == 400);
1307 fail_unless (segment.position == 200);
1308 fail_unless (segment.duration == -1);
1310 /* invalid time gives invalid result */
1311 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, -1);
1312 fail_unless (result == -1);
1314 /* only applied rate affects our calculation of the stream time */
1315 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 0);
1316 fail_unless (result == 0);
1318 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 100);
1319 fail_unless (result == 200);
1321 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 150);
1322 fail_unless (result == 300);
1324 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 200);
1325 fail_unless (result == 400);
1327 /* outside of the segment */
1328 result = gst_segment_to_stream_time (&segment, GST_FORMAT_TIME, 300);
1329 fail_unless (result == -1);
1334 /* mess with the segment structure in the time format */
1335 GST_START_TEST (segment_newsegment_runningtime)
1340 gst_segment_init (&segment, GST_FORMAT_TIME);
1342 /***************************
1344 ***************************/
1345 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
1346 GST_FORMAT_TIME, 0, 200, 0);
1348 fail_unless (segment.rate == 1.0);
1349 fail_unless (segment.applied_rate == 1.0);
1350 fail_unless (segment.format == GST_FORMAT_TIME);
1351 fail_unless (segment.flags == 0);
1352 fail_unless (segment.start == 0);
1353 fail_unless (segment.stop == 200);
1354 fail_unless (segment.time == 0);
1355 fail_unless (segment.base == 0);
1356 fail_unless (segment.position == 0);
1357 fail_unless (segment.duration == -1);
1359 /* invalid time gives invalid result */
1360 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1361 fail_unless (result == -1);
1363 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 0);
1364 fail_unless (result == 0);
1365 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1366 fail_unless (result == 0);
1368 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 100);
1369 fail_unless (result == 100);
1370 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1371 fail_unless (result == 100);
1373 /* at edge is exactly the segment duration */
1374 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 200);
1375 fail_unless (result == 200);
1376 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1377 fail_unless (result == 200);
1379 /* outside of the segment */
1380 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 300);
1381 fail_unless (result == -1);
1382 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 300);
1383 fail_unless (result == -1);
1385 /***********************************************************
1386 * time shifted by 500, check if accumulation worked.
1387 * Rate convert to twice the speed which means scaling down
1388 * all positions by 2.0 in this segment.
1389 * Then time argument is not used at all here.
1390 ***********************************************************/
1391 gst_segment_set_newsegment (&segment, FALSE, 2.0, 1.0,
1392 GST_FORMAT_TIME, 0, 200, 500);
1394 /* normal speed gives elapsed of 200 */
1395 fail_unless (segment.base == 200);
1397 /* invalid time gives invalid result */
1398 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1399 fail_unless (result == -1);
1401 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 0);
1402 fail_unless (result == 200);
1403 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1404 fail_unless (result == 0);
1406 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 100);
1407 fail_unless (result == 250);
1408 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1409 fail_unless (result == 100);
1411 /* outside of the segment */
1412 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 500);
1413 fail_unless (result == -1);
1414 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 310);
1415 fail_unless (result == -1);
1417 /********************************************
1418 * time offset by 500
1419 * applied rate is not used for running time
1420 ********************************************/
1421 gst_segment_set_newsegment (&segment, FALSE, 1.0, 2.0,
1422 GST_FORMAT_TIME, 500, 700, 0);
1424 /* previous segment played at double speed gives elapsed time of
1425 * 100 added to previous accum of 200 gives 300. */
1426 fail_unless (segment.base == 300);
1428 /* invalid time gives invalid result */
1429 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1430 fail_unless (result == -1);
1432 /* before segment is invalid */
1433 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 400);
1434 fail_unless (result == -1);
1435 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 200);
1436 fail_unless (result == -1);
1438 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 500);
1439 fail_unless (result == 300);
1440 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1441 fail_unless (result == 500);
1443 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 600);
1444 fail_unless (result == 400);
1445 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1446 fail_unless (result == 600);
1448 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 700);
1449 fail_unless (result == 500);
1450 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1451 fail_unless (result == 700);
1453 /* outside of the segment */
1454 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 800);
1455 fail_unless (result == -1);
1456 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 600);
1457 fail_unless (result == -1);
1459 /**********************************************************
1460 * time offset by 500, shifted by 200
1461 * Negative rate makes the running time go backwards
1462 * relative to the segment stop position. again time
1464 **********************************************************/
1465 gst_segment_set_newsegment (&segment, FALSE, -1.0, 1.0,
1466 GST_FORMAT_TIME, 500, 700, 200);
1468 fail_unless (segment.base == 500);
1470 /* invalid time gives invalid result */
1471 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1472 fail_unless (result == -1);
1474 /* before segment is invalid */
1475 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 400);
1476 fail_unless (result == -1);
1477 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 400);
1478 fail_unless (result == -1);
1480 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 500);
1481 fail_unless (result == 700);
1482 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1483 fail_unless (result == 500);
1485 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 600);
1486 fail_unless (result == 600);
1487 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1488 fail_unless (result == 600);
1490 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 700);
1491 fail_unless (result == 500);
1492 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1493 fail_unless (result == 700);
1495 /* outside of the segment */
1496 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 800);
1497 fail_unless (result == -1);
1498 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 800);
1499 fail_unless (result == -1);
1501 /**********************************************************
1502 * time offset by 500, shifted by 200
1503 * Negative rate makes the running time go backwards at
1504 * twice speed relative to the segment stop position. again
1506 **********************************************************/
1507 gst_segment_set_newsegment (&segment, FALSE, -2.0, -2.0,
1508 GST_FORMAT_TIME, 500, 700, 200);
1510 fail_unless (segment.base == 700);
1512 /* invalid time gives invalid result */
1513 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1514 fail_unless (result == -1);
1516 /* before segment is invalid */
1517 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 400);
1518 fail_unless (result == -1);
1519 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 600);
1520 fail_unless (result == -1);
1522 /* total scaled segment time is 100, accum is 700, so we get 800 */
1523 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 500);
1524 fail_unless (result == 800);
1525 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1526 fail_unless (result == 500);
1528 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 600);
1529 fail_unless (result == 750);
1530 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1531 fail_unless (result == 600);
1533 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 700);
1534 fail_unless (result == 700);
1535 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1536 fail_unless (result == 700);
1538 /* outside of the segment */
1539 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 800);
1540 fail_unless (result == -1);
1541 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 900);
1542 fail_unless (result == -1);
1544 /* see if negative rate closed segment correctly */
1545 gst_segment_set_newsegment (&segment, FALSE, -2.0, -1.0,
1546 GST_FORMAT_TIME, 500, 700, 200);
1548 /* previous segment lasted 100, and was at 700 so we should get 800 */
1549 fail_unless (segment.base == 800);
1550 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, 800);
1551 fail_unless (result == 700);
1556 /* mess with the segment structure in the time format */
1557 GST_START_TEST (segment_newsegment_accum)
1562 gst_segment_init (&segment, GST_FORMAT_TIME);
1564 /***************************
1565 * Normal reverse segment
1566 ***************************/
1567 gst_segment_set_newsegment (&segment, FALSE, -1.0, 1.0,
1568 GST_FORMAT_TIME, 0, 200, 0);
1570 fail_unless (segment.rate == -1.0);
1571 fail_unless (segment.applied_rate == 1.0);
1572 fail_unless (segment.format == GST_FORMAT_TIME);
1573 fail_unless (segment.flags == 0);
1574 fail_unless (segment.start == 0);
1575 fail_unless (segment.stop == 200);
1576 fail_unless (segment.time == 0);
1577 fail_unless (segment.base == 0);
1578 fail_unless (segment.position == 200);
1579 fail_unless (segment.duration == -1);
1581 /* invalid time gives invalid result */
1582 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1583 fail_unless (result == -1);
1585 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 200);
1586 fail_unless (result == 0);
1587 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1588 fail_unless (result == 200);
1590 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 150);
1591 fail_unless (result == 50);
1592 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1593 fail_unless (result == 150);
1595 /* update segment, this accumulates 50 from the previous segment. */
1596 gst_segment_set_newsegment (&segment, TRUE, -2.0, 1.0,
1597 GST_FORMAT_TIME, 0, 150, 0);
1599 fail_unless (segment.rate == -2.0);
1600 fail_unless (segment.applied_rate == 1.0);
1601 fail_unless (segment.format == GST_FORMAT_TIME);
1602 fail_unless (segment.flags == 0);
1603 fail_unless (segment.start == 0);
1604 fail_unless (segment.stop == 150);
1605 fail_unless (segment.time == 0);
1606 fail_unless (segment.base == 50);
1607 fail_unless (segment.position == 150);
1608 fail_unless (segment.duration == -1);
1610 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 150);
1611 fail_unless (result == 50);
1612 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1613 fail_unless (result == 150);
1615 /* 50 accumulated + 50 / 2 */
1616 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 100);
1617 fail_unless (result == 75);
1618 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1619 fail_unless (result == 100);
1621 /* update segment, this does not accumulate anything. */
1622 gst_segment_set_newsegment (&segment, TRUE, 1.0, 1.0,
1623 GST_FORMAT_TIME, 100, 200, 100);
1625 fail_unless (segment.rate == 1.0);
1626 fail_unless (segment.applied_rate == 1.0);
1627 fail_unless (segment.format == GST_FORMAT_TIME);
1628 fail_unless (segment.flags == 0);
1629 fail_unless (segment.start == 100);
1630 fail_unless (segment.stop == 200);
1631 fail_unless (segment.time == 100);
1632 fail_unless (segment.base == 50);
1633 fail_unless (segment.position == 150);
1634 fail_unless (segment.duration == -1);
1636 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 100);
1637 fail_unless (result == 50);
1638 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1639 fail_unless (result == 100);
1641 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 150);
1642 fail_unless (result == 100);
1643 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1644 fail_unless (result == 150);
1649 /* mess with the segment structure in the time format */
1650 GST_START_TEST (segment_newsegment_accum2)
1655 gst_segment_init (&segment, GST_FORMAT_TIME);
1657 /***************************
1658 * Normal reverse segment
1659 ***************************/
1660 gst_segment_set_newsegment (&segment, FALSE, -1.0, 1.0,
1661 GST_FORMAT_TIME, 0, 200, 0);
1663 fail_unless (segment.rate == -1.0);
1664 fail_unless (segment.applied_rate == 1.0);
1665 fail_unless (segment.format == GST_FORMAT_TIME);
1666 fail_unless (segment.flags == 0);
1667 fail_unless (segment.start == 0);
1668 fail_unless (segment.stop == 200);
1669 fail_unless (segment.time == 0);
1670 fail_unless (segment.base == 0);
1671 fail_unless (segment.position == 200);
1672 fail_unless (segment.duration == -1);
1674 /* invalid time gives invalid result */
1675 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1676 fail_unless (result == -1);
1677 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1678 fail_unless (result == -1);
1680 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 200);
1681 fail_unless (result == 0);
1682 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1683 fail_unless (result == 200);
1685 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 150);
1686 fail_unless (result == 50);
1687 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1688 fail_unless (result == 150);
1690 /* close segment, this accumulates nothing. */
1691 gst_segment_set_newsegment (&segment, TRUE, -1.0, 1.0,
1692 GST_FORMAT_TIME, 150, 200, 0);
1694 fail_unless (segment.rate == -1.0);
1695 fail_unless (segment.applied_rate == 1.0);
1696 fail_unless (segment.format == GST_FORMAT_TIME);
1697 fail_unless (segment.flags == 0);
1698 fail_unless (segment.start == 150);
1699 fail_unless (segment.stop == 200);
1700 fail_unless (segment.time == 0);
1701 fail_unless (segment.base == 0);
1702 fail_unless (segment.position == 200);
1703 fail_unless (segment.duration == -1);
1705 /* new segment, this accumulates 50. */
1706 gst_segment_set_newsegment (&segment, FALSE, 1.0, 1.0,
1707 GST_FORMAT_TIME, 150, 300, 150);
1709 fail_unless (segment.rate == 1.0);
1710 fail_unless (segment.applied_rate == 1.0);
1711 fail_unless (segment.format == GST_FORMAT_TIME);
1712 fail_unless (segment.flags == 0);
1713 fail_unless (segment.start == 150);
1714 fail_unless (segment.stop == 300);
1715 fail_unless (segment.time == 150);
1716 fail_unless (segment.base == 50);
1717 fail_unless (segment.position == 150);
1718 fail_unless (segment.duration == -1);
1720 /* invalid time gives invalid result */
1721 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, -1);
1722 fail_unless (result == -1);
1724 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 150);
1725 fail_unless (result == 50);
1726 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1727 fail_unless (result == 150);
1729 result = gst_segment_to_running_time (&segment, GST_FORMAT_TIME, 200);
1730 fail_unless (result == 100);
1731 result = gst_segment_to_position (&segment, GST_FORMAT_TIME, result);
1732 fail_unless (result == 200);
1738 GST_START_TEST (segment_copy)
1741 GstSegment segment = { 0.0, };
1743 /* this is a boxed type copy function, we support copying NULL */
1744 fail_unless (gst_segment_copy (NULL) == NULL);
1746 gst_segment_init (&segment, GST_FORMAT_TIME);
1748 segment.rate = -1.0;
1749 segment.applied_rate = 1.0;
1754 copy = gst_segment_copy (&segment);
1755 fail_unless (copy != NULL);
1756 /* we inited the struct on the stack to zeroes, so direct comparison should
1757 * be ok here despite the padding field and regardless of implementation */
1758 fail_unless (memcmp (copy, &segment, sizeof (GstSegment)) == 0);
1759 gst_segment_free (copy);
1765 gst_segment_suite (void)
1767 Suite *s = suite_create ("GstSegment");
1768 TCase *tc_chain = tcase_create ("segments");
1770 tcase_set_timeout (tc_chain, 20);
1772 suite_add_tcase (s, tc_chain);
1773 tcase_add_test (tc_chain, segment_seek_nosize);
1774 tcase_add_test (tc_chain, segment_seek_size);
1775 tcase_add_test (tc_chain, segment_seek_reverse);
1776 tcase_add_test (tc_chain, segment_seek_rate);
1778 tcase_add_test (tc_chain, segment_newsegment_open);
1779 tcase_add_test (tc_chain, segment_newsegment_closed);
1780 tcase_add_test (tc_chain, segment_newsegment_streamtime);
1781 tcase_add_test (tc_chain, segment_newsegment_streamtime_rate);
1782 tcase_add_test (tc_chain, segment_newsegment_streamtime_applied_rate);
1783 tcase_add_test (tc_chain, segment_newsegment_streamtime_applied_rate_rate);
1784 tcase_add_test (tc_chain, segment_newsegment_runningtime);
1785 tcase_add_test (tc_chain, segment_newsegment_accum);
1786 tcase_add_test (tc_chain, segment_newsegment_accum2);
1788 tcase_add_test (tc_chain, segment_copy);
1793 GST_CHECK_MAIN (gst_segment);