1 /* GStreamer
2 *
3 * unit tests for audio support library
4 *
5 * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
6 * Copyright (C) 2011 Sebastian Dröge <sebastian.droege@collabora.co.uk>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include <gst/check/gstcheck.h>
29
30 #include <gst/audio/audio.h>
31 #include <string.h>
32
33 static GstBuffer *
make_buffer(guint8 ** _data)34 make_buffer (guint8 ** _data)
35 {
36 GstBuffer *buf = gst_buffer_new ();
37 guint8 *data = (guint8 *) g_malloc (1000);
38
39 gst_buffer_append_memory (buf,
40 gst_memory_new_wrapped (0, data, 1000, 0, 1000, data, g_free));
41 if (_data)
42 *_data = data;
43 return buf;
44 }
45
46 static void
setup_segment(GstSegment * s,GstFormat fmt,guint64 start,guint64 stop,guint64 stream_time)47 setup_segment (GstSegment * s, GstFormat fmt, guint64 start, guint64 stop,
48 guint64 stream_time)
49 {
50 gst_segment_init (s, fmt);
51 s->start = start;
52 s->stop = stop;
53 s->time = stream_time;
54 }
55
GST_START_TEST(test_buffer_clip_unsupported_format)56 GST_START_TEST (test_buffer_clip_unsupported_format)
57 {
58 GstSegment s;
59 GstBuffer *buf;
60 guint8 *data;
61
62 /* If the format is not TIME or DEFAULT it should assert()
63 * FIXME: check if return value is the same as the input buffer.
64 * probably can't be done because the assert() does a SIGABRT.
65 */
66 buf = make_buffer (&data);
67 setup_segment (&s, GST_FORMAT_PERCENT, 0, 10, 0);
68
69 GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;
70 GST_BUFFER_DURATION (buf) = 0;
71 GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
72 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
73
74 ASSERT_CRITICAL (gst_audio_buffer_clip (buf, &s, 100, 1));
75
76 gst_buffer_unref (buf);
77 }
78
79 GST_END_TEST;
80
GST_START_TEST(test_buffer_clip_time_start_and_stop)81 GST_START_TEST (test_buffer_clip_time_start_and_stop)
82 {
83 GstSegment s;
84 GstBuffer *buf;
85 GstBuffer *ret;
86 GstMapInfo map;
87 guint8 *data;
88
89 /* Clip start and end */
90 buf = make_buffer (&data);
91 setup_segment (&s, GST_FORMAT_TIME, 4 * GST_SECOND, 8 * GST_SECOND,
92 4 * GST_SECOND);
93
94 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
95 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
96 GST_BUFFER_OFFSET (buf) = 200;
97 GST_BUFFER_OFFSET_END (buf) = 1200;
98
99 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
100 fail_unless (ret != NULL);
101
102 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
103 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 4 * GST_SECOND);
104 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
105 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 800);
106 gst_buffer_map (ret, &map, GST_MAP_READ);
107 fail_unless (map.data == data + 200);
108 fail_unless (map.size == 400);
109 gst_buffer_unmap (ret, &map);
110
111 gst_buffer_unref (ret);
112 }
113
114 GST_END_TEST;
115
GST_START_TEST(test_buffer_clip_time_start_and_stop_planar)116 GST_START_TEST (test_buffer_clip_time_start_and_stop_planar)
117 {
118 GstSegment s;
119 GstBuffer *buf;
120 GstBuffer *ret;
121 GstAudioInfo info;
122 GstAudioBuffer abuf;
123 guint8 *data;
124
125 /* Clip start and end */
126 buf = make_buffer (&data);
127
128 gst_audio_info_init (&info);
129 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S8, 44100, 1, NULL);
130 info.layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
131 gst_buffer_add_audio_meta (buf, &info, 1000, NULL);
132
133 setup_segment (&s, GST_FORMAT_TIME, 4 * GST_SECOND, 8 * GST_SECOND,
134 4 * GST_SECOND);
135
136 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
137 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
138 GST_BUFFER_OFFSET (buf) = 200;
139 GST_BUFFER_OFFSET_END (buf) = 1200;
140
141 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
142 fail_unless (ret != NULL);
143
144 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
145 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 4 * GST_SECOND);
146 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
147 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 800);
148 gst_audio_buffer_map (&abuf, &info, ret, GST_MAP_READ);
149 fail_unless_equals_int (abuf.n_planes, 1);
150 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&abuf), 400);
151 fail_unless_equals_pointer (abuf.planes[0], data + 200);
152 gst_audio_buffer_unmap (&abuf);
153
154 gst_buffer_unref (ret);
155 }
156
157 GST_END_TEST;
158
GST_START_TEST(test_buffer_clip_time_start)159 GST_START_TEST (test_buffer_clip_time_start)
160 {
161 GstSegment s;
162 GstBuffer *buf;
163 GstBuffer *ret;
164 GstMapInfo map;
165 guint8 *data;
166
167 /* Clip only start */
168 buf = make_buffer (&data);
169 setup_segment (&s, GST_FORMAT_TIME, 4 * GST_SECOND, 12 * GST_SECOND,
170 4 * GST_SECOND);
171
172 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
173 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
174 GST_BUFFER_OFFSET (buf) = 200;
175 GST_BUFFER_OFFSET_END (buf) = 1200;
176
177 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
178 fail_unless (ret != NULL);
179
180 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
181 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 8 * GST_SECOND);
182 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
183 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 1200);
184 gst_buffer_map (ret, &map, GST_MAP_READ);
185 fail_unless (map.data == data + 200);
186 fail_unless (map.size == 800);
187 gst_buffer_unmap (ret, &map);
188
189 gst_buffer_unref (ret);
190 }
191
192 GST_END_TEST;
193
GST_START_TEST(test_buffer_clip_time_start_planar)194 GST_START_TEST (test_buffer_clip_time_start_planar)
195 {
196 GstSegment s;
197 GstBuffer *buf;
198 GstBuffer *ret;
199 GstAudioInfo info;
200 GstAudioMeta *meta;
201 GstAudioBuffer abuf;
202 guint8 *data;
203
204 /* Clip only start */
205 buf = make_buffer (&data);
206
207 gst_audio_info_init (&info);
208 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S8, 44100, 2, NULL);
209 info.layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
210 gst_buffer_add_audio_meta (buf, &info, 500, NULL);
211
212 setup_segment (&s, GST_FORMAT_TIME, 4 * GST_SECOND, 12 * GST_SECOND,
213 4 * GST_SECOND);
214
215 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
216 GST_BUFFER_DURATION (buf) = 5 * GST_SECOND;
217 GST_BUFFER_OFFSET (buf) = 200;
218 GST_BUFFER_OFFSET_END (buf) = 700;
219
220 ret = gst_audio_buffer_clip (buf, &s, 100, 2);
221 fail_unless (ret != NULL);
222
223 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
224 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 3 * GST_SECOND);
225 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
226 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 700);
227
228 meta = gst_buffer_get_audio_meta (ret);
229 fail_unless (meta);
230 fail_unless_equals_int (meta->info.channels, 2);
231 fail_unless_equals_int (meta->samples, 300);
232
233 gst_audio_buffer_map (&abuf, &info, ret, GST_MAP_READ);
234 fail_unless_equals_int (abuf.n_planes, 2);
235 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&abuf), 300);
236 fail_unless_equals_pointer (abuf.planes[0], data + 200);
237 fail_unless_equals_pointer (abuf.planes[1], data + 700);
238 gst_audio_buffer_unmap (&abuf);
239
240 gst_buffer_unref (ret);
241 }
242
243 GST_END_TEST;
244
GST_START_TEST(test_buffer_clip_time_stop)245 GST_START_TEST (test_buffer_clip_time_stop)
246 {
247 GstSegment s;
248 GstBuffer *buf;
249 GstBuffer *ret;
250 GstMapInfo map;
251 guint8 *data;
252
253 /* Clip only stop */
254 buf = make_buffer (&data);
255 setup_segment (&s, GST_FORMAT_TIME, 2 * GST_SECOND, 10 * GST_SECOND,
256 2 * GST_SECOND);
257
258 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
259 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
260 GST_BUFFER_OFFSET (buf) = 200;
261 GST_BUFFER_OFFSET_END (buf) = 1200;
262
263 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
264 fail_unless (ret != NULL);
265
266 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 2 * GST_SECOND);
267 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 8 * GST_SECOND);
268 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 200);
269 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 1000);
270 gst_buffer_map (ret, &map, GST_MAP_READ);
271 fail_unless (map.data == data);
272 fail_unless (map.size == 800);
273 gst_buffer_unmap (ret, &map);
274
275 gst_buffer_unref (ret);
276 }
277
278 GST_END_TEST;
279
GST_START_TEST(test_buffer_clip_time_stop_planar)280 GST_START_TEST (test_buffer_clip_time_stop_planar)
281 {
282 GstSegment s;
283 GstBuffer *buf;
284 GstBuffer *ret;
285 GstAudioInfo info;
286 GstAudioMeta *meta;
287 GstAudioBuffer abuf;
288 guint8 *data;
289
290 /* Clip only stop */
291 buf = make_buffer (&data);
292
293 gst_audio_info_init (&info);
294 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S8, 44100, 2, NULL);
295 info.layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
296 gst_buffer_add_audio_meta (buf, &info, 500, NULL);
297
298 setup_segment (&s, GST_FORMAT_TIME, 2 * GST_SECOND, 6 * GST_SECOND,
299 2 * GST_SECOND);
300
301 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
302 GST_BUFFER_DURATION (buf) = 5 * GST_SECOND;
303 GST_BUFFER_OFFSET (buf) = 200;
304 GST_BUFFER_OFFSET_END (buf) = 700;
305
306 ret = gst_audio_buffer_clip (buf, &s, 100, 2);
307 fail_unless (ret != NULL);
308
309 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 2 * GST_SECOND);
310 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 4 * GST_SECOND);
311 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 200);
312 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 600);
313
314 meta = gst_buffer_get_audio_meta (ret);
315 fail_unless (meta);
316 fail_unless_equals_int (meta->info.channels, 2);
317 fail_unless_equals_int (meta->samples, 400);
318
319 gst_audio_buffer_map (&abuf, &info, ret, GST_MAP_READ);
320 fail_unless_equals_int (abuf.n_planes, 2);
321 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&abuf), 400);
322 fail_unless_equals_pointer (abuf.planes[0], data);
323 fail_unless_equals_pointer (abuf.planes[1], data + 500);
324 gst_audio_buffer_unmap (&abuf);
325
326 gst_buffer_unref (ret);
327 }
328
329 GST_END_TEST;
330
GST_START_TEST(test_buffer_clip_time_outside)331 GST_START_TEST (test_buffer_clip_time_outside)
332 {
333 GstSegment s;
334 GstBuffer *buf;
335 GstBuffer *ret;
336
337 /* Buffer outside segment */
338 buf = make_buffer (NULL);
339 setup_segment (&s, GST_FORMAT_TIME, 12 * GST_SECOND, 20 * GST_SECOND,
340 12 * GST_SECOND);
341
342 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
343 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
344 GST_BUFFER_OFFSET (buf) = 200;
345 GST_BUFFER_OFFSET_END (buf) = 1200;
346
347 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
348 fail_unless (ret == NULL);
349 }
350
351 GST_END_TEST;
352
GST_START_TEST(test_buffer_clip_time_start_and_stop_no_meta)353 GST_START_TEST (test_buffer_clip_time_start_and_stop_no_meta)
354 {
355 GstSegment s;
356 GstBuffer *buf;
357 GstBuffer *ret;
358 GstMapInfo map;
359 guint8 *data;
360
361 /* Clip start and end but don't touch duration, offset and offset_end */
362 buf = make_buffer (&data);
363 setup_segment (&s, GST_FORMAT_TIME, 4 * GST_SECOND, 8 * GST_SECOND,
364 4 * GST_SECOND);
365
366 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
367 GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
368 GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
369 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
370
371 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
372 fail_unless (ret != NULL);
373
374 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
375 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), GST_CLOCK_TIME_NONE);
376 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), GST_BUFFER_OFFSET_NONE);
377 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret),
378 GST_BUFFER_OFFSET_NONE);
379 gst_buffer_map (ret, &map, GST_MAP_READ);
380 fail_unless (map.data == data + 200);
381 fail_unless (map.size == 400);
382 gst_buffer_unmap (ret, &map);
383
384 gst_buffer_unref (ret);
385 }
386
387 GST_END_TEST;
388
GST_START_TEST(test_buffer_clip_time_no_timestamp)389 GST_START_TEST (test_buffer_clip_time_no_timestamp)
390 {
391 GstSegment s;
392 GstBuffer *buf;
393 GstBuffer *ret;
394
395 /* If the buffer has no timestamp it should assert()
396 * FIXME: check if return value is the same as the input buffer.
397 * probably can't be done because the assert() does a SIGABRT.
398 */
399 buf = make_buffer (NULL);
400 setup_segment (&s, GST_FORMAT_TIME, 0 * GST_SECOND, 10 * GST_SECOND,
401 0 * GST_SECOND);
402
403 GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
404 GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
405 GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
406 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
407
408 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
409 fail_unless (ret == buf);
410
411 gst_buffer_unref (buf);
412 }
413
414 GST_END_TEST;
415
GST_START_TEST(test_buffer_clip_time_handles_rounding)416 GST_START_TEST (test_buffer_clip_time_handles_rounding)
417 {
418 GstSegment s;
419 GstBuffer *buf;
420 GstBuffer *ret;
421 GstMapInfo map;
422 guint8 *data;
423 GstClockTime time_per_sample = GST_SECOND / 100;
424
425 /* Clip only stop */
426 buf = make_buffer (&data);
427 setup_segment (&s, GST_FORMAT_TIME, 2 * GST_SECOND, 10 * GST_SECOND,
428 2 * GST_SECOND);
429
430 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
431 /* the max duration that still converts back to the same size of samples */
432 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND + (time_per_sample - 1);
433 GST_BUFFER_OFFSET (buf) = 200;
434 GST_BUFFER_OFFSET_END (buf) = 1200;
435
436 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
437 fail_unless (ret != NULL);
438
439 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 2 * GST_SECOND);
440 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 8 * GST_SECOND);
441 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 200);
442 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 1000);
443 gst_buffer_map (ret, &map, GST_MAP_READ);
444 fail_unless (map.data == data);
445 fail_unless (map.size == 800);
446 gst_buffer_unmap (ret, &map);
447
448 gst_buffer_unref (ret);
449 }
450
451 GST_END_TEST;
452
GST_START_TEST(test_buffer_clip_samples_start_and_stop)453 GST_START_TEST (test_buffer_clip_samples_start_and_stop)
454 {
455 GstSegment s;
456 GstBuffer *buf;
457 GstBuffer *ret;
458 GstMapInfo map;
459 guint8 *data;
460
461 /* Clip start and end */
462 buf = make_buffer (&data);
463 setup_segment (&s, GST_FORMAT_DEFAULT, 400, 800, 400);
464
465 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
466 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
467 GST_BUFFER_OFFSET (buf) = 200;
468 GST_BUFFER_OFFSET_END (buf) = 1200;
469
470 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
471 fail_unless (ret != NULL);
472
473 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
474 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 4 * GST_SECOND);
475 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
476 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 800);
477 gst_buffer_map (ret, &map, GST_MAP_READ);
478 fail_unless (map.data == data + 200);
479 fail_unless (map.size == 400);
480 gst_buffer_unmap (ret, &map);
481
482 gst_buffer_unref (ret);
483 }
484
485 GST_END_TEST;
486
GST_START_TEST(test_buffer_clip_samples_start_and_stop_planar)487 GST_START_TEST (test_buffer_clip_samples_start_and_stop_planar)
488 {
489 GstSegment s;
490 GstBuffer *buf;
491 GstBuffer *ret;
492 GstAudioInfo info;
493 GstAudioMeta *meta;
494 GstAudioBuffer abuf;
495 guint8 *data;
496
497 /* Clip start and end */
498 buf = make_buffer (&data);
499
500 gst_audio_info_init (&info);
501 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S8, 44100, 2, NULL);
502 info.layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
503 gst_buffer_add_audio_meta (buf, &info, 500, NULL);
504
505
506 setup_segment (&s, GST_FORMAT_DEFAULT, 400, 600, 400);
507
508 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
509 GST_BUFFER_DURATION (buf) = 5 * GST_SECOND;
510 GST_BUFFER_OFFSET (buf) = 200;
511 GST_BUFFER_OFFSET_END (buf) = 700;
512
513 ret = gst_audio_buffer_clip (buf, &s, 100, 2);
514 fail_unless (ret != NULL);
515
516 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
517 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 2 * GST_SECOND);
518 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
519 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 600);
520
521 meta = gst_buffer_get_audio_meta (ret);
522 fail_unless (meta);
523 fail_unless_equals_int (meta->info.channels, 2);
524 fail_unless_equals_int (meta->samples, 200);
525
526 gst_audio_buffer_map (&abuf, &info, ret, GST_MAP_READ);
527 fail_unless_equals_int (abuf.n_planes, 2);
528 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&abuf), 200);
529 fail_unless_equals_pointer (abuf.planes[0], data + 200);
530 fail_unless_equals_pointer (abuf.planes[1], data + 700);
531 gst_audio_buffer_unmap (&abuf);
532
533 gst_buffer_unref (ret);
534 }
535
536 GST_END_TEST;
537
GST_START_TEST(test_buffer_clip_samples_start)538 GST_START_TEST (test_buffer_clip_samples_start)
539 {
540 GstSegment s;
541 GstBuffer *buf;
542 GstBuffer *ret;
543 GstMapInfo map;
544 guint8 *data;
545
546 /* Clip only start */
547 buf = make_buffer (&data);
548 setup_segment (&s, GST_FORMAT_DEFAULT, 400, 1200, 400);
549
550 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
551 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
552 GST_BUFFER_OFFSET (buf) = 200;
553 GST_BUFFER_OFFSET_END (buf) = 1200;
554
555 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
556 fail_unless (ret != NULL);
557
558 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
559 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 8 * GST_SECOND);
560 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
561 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 1200);
562 gst_buffer_map (ret, &map, GST_MAP_READ);
563 fail_unless (map.data == data + 200);
564 fail_unless (map.size == 800);
565 gst_buffer_unmap (ret, &map);
566
567 gst_buffer_unref (ret);
568 }
569
570 GST_END_TEST;
571
GST_START_TEST(test_buffer_clip_samples_stop)572 GST_START_TEST (test_buffer_clip_samples_stop)
573 {
574 GstSegment s;
575 GstBuffer *buf;
576 GstBuffer *ret;
577 GstMapInfo map;
578 guint8 *data;
579
580 /* Clip only stop */
581 buf = make_buffer (&data);
582 setup_segment (&s, GST_FORMAT_DEFAULT, 200, 1000, 200);
583
584 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
585 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
586 GST_BUFFER_OFFSET (buf) = 200;
587 GST_BUFFER_OFFSET_END (buf) = 1200;
588
589 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
590 fail_unless (ret != NULL);
591
592 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 2 * GST_SECOND);
593 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), 8 * GST_SECOND);
594 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 200);
595 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 1000);
596 gst_buffer_map (ret, &map, GST_MAP_READ);
597 fail_unless (map.data == data);
598 fail_unless (map.size == 800);
599 gst_buffer_unmap (ret, &map);
600
601 gst_buffer_unref (ret);
602 }
603
604 GST_END_TEST;
605
GST_START_TEST(test_buffer_clip_samples_outside)606 GST_START_TEST (test_buffer_clip_samples_outside)
607 {
608 GstSegment s;
609 GstBuffer *buf;
610 GstBuffer *ret;
611
612 /* Buffer outside segment */
613 buf = make_buffer (NULL);
614 setup_segment (&s, GST_FORMAT_DEFAULT, 1200, 2000, 1200);
615
616 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
617 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
618 GST_BUFFER_OFFSET (buf) = 200;
619 GST_BUFFER_OFFSET_END (buf) = 1200;
620
621 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
622 fail_unless (ret == NULL);
623 }
624
625 GST_END_TEST;
626
GST_START_TEST(test_buffer_clip_samples_start_and_stop_no_meta)627 GST_START_TEST (test_buffer_clip_samples_start_and_stop_no_meta)
628 {
629 GstSegment s;
630 GstBuffer *buf;
631 GstBuffer *ret;
632 GstMapInfo map;
633 guint8 *data;
634
635 /* Clip start and end but don't touch duration and offset_end */
636 buf = make_buffer (&data);
637 setup_segment (&s, GST_FORMAT_DEFAULT, 400, 800, 400);
638
639 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
640 GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
641 GST_BUFFER_OFFSET (buf) = 200;
642 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
643
644 ret = gst_audio_buffer_clip (buf, &s, 100, 1);
645 fail_unless (ret != NULL);
646
647 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), 4 * GST_SECOND);
648 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), GST_CLOCK_TIME_NONE);
649 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 400);
650 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 800);
651 gst_buffer_map (ret, &map, GST_MAP_READ);
652 fail_unless (map.data == data + 200);
653 fail_unless (map.size == 400);
654 gst_buffer_unmap (ret, &map);
655
656 gst_buffer_unref (ret);
657 }
658
659 GST_END_TEST;
660
GST_START_TEST(test_buffer_clip_samples_no_timestamp)661 GST_START_TEST (test_buffer_clip_samples_no_timestamp)
662 {
663 GstSegment s;
664 GstBuffer *buf;
665
666 /* If the buffer has no offset it should assert() in DEFAULT format
667 * FIXME: check if return value is the same as the input buffer.
668 * probably can't be done because the assert() does a SIGABRT.
669 */
670 buf = make_buffer (NULL);
671 setup_segment (&s, GST_FORMAT_DEFAULT, 0, 10, 0);
672
673 GST_BUFFER_TIMESTAMP (buf) = 0 * GST_SECOND;
674 GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
675 GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
676 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
677
678 ASSERT_CRITICAL (gst_audio_buffer_clip (buf, &s, 100, 1));
679
680 gst_buffer_unref (buf);
681 }
682
683 GST_END_TEST;
684
GST_START_TEST(test_buffer_truncate_samples_offset_end)685 GST_START_TEST (test_buffer_truncate_samples_offset_end)
686 {
687 GstBuffer *buf;
688 GstBuffer *ret;
689 guint8 *data;
690
691 buf = make_buffer (&data);
692 GST_BUFFER_TIMESTAMP (buf) = 2 * GST_SECOND;
693 GST_BUFFER_DURATION (buf) = 10 * GST_SECOND;
694 GST_BUFFER_OFFSET (buf) = 200;
695 GST_BUFFER_OFFSET_END (buf) = 1200;
696
697 ret = gst_audio_buffer_truncate (buf, 4, 100, 100);
698 fail_unless (ret != NULL);
699
700 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), GST_CLOCK_TIME_NONE);
701 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), GST_CLOCK_TIME_NONE);
702 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), 300);
703 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret), 400);
704
705 gst_buffer_unref (ret);
706 }
707
708 GST_END_TEST;
709
GST_START_TEST(test_buffer_truncate_samples_no_timestamp)710 GST_START_TEST (test_buffer_truncate_samples_no_timestamp)
711 {
712 GstBuffer *buf;
713 GstBuffer *ret;
714 guint8 *data;
715
716 buf = make_buffer (&data);
717 GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
718 GST_BUFFER_DURATION (buf) = GST_CLOCK_TIME_NONE;
719 GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
720 GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
721
722 ret = gst_audio_buffer_truncate (buf, 4, 100, 1);
723 fail_unless (ret != NULL);
724
725 fail_unless_equals_int64 (GST_BUFFER_TIMESTAMP (ret), GST_CLOCK_TIME_NONE);
726 fail_unless_equals_int64 (GST_BUFFER_DURATION (ret), GST_CLOCK_TIME_NONE);
727 fail_unless_equals_int64 (GST_BUFFER_OFFSET (ret), GST_BUFFER_OFFSET_NONE);
728 fail_unless_equals_int64 (GST_BUFFER_OFFSET_END (ret),
729 GST_BUFFER_OFFSET_NONE);
730
731 gst_buffer_unref (ret);
732 }
733
734 GST_END_TEST;
735
GST_START_TEST(test_multichannel_checks)736 GST_START_TEST (test_multichannel_checks)
737 {
738 GstAudioChannelPosition pos_2_mixed[2] = {
739 GST_AUDIO_CHANNEL_POSITION_MONO,
740 GST_AUDIO_CHANNEL_POSITION_NONE
741 };
742 GstAudioChannelPosition pos_2_none[2] = {
743 GST_AUDIO_CHANNEL_POSITION_NONE,
744 GST_AUDIO_CHANNEL_POSITION_NONE
745 };
746 GstAudioChannelPosition pos_2_flr[2] = {
747 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
748 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
749 };
750 GstAudioChannelPosition pos_2_frl[2] = {
751 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
752 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
753 };
754 GstAudioChannelPosition pos_2_frr[2] = {
755 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
756 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
757 };
758 GstAudioChannelPosition pos_3_flrc[3] = {
759 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
760 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
761 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER
762 };
763 GstAudioChannelPosition pos_3_frcl[3] = {
764 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
765 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
766 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT
767 };
768 GstAudioInfo info, info2;
769 GstCaps *caps;
770
771 gst_audio_info_init (&info);
772 gst_audio_info_init (&info2);
773
774 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000, 2, NULL);
775 fail_unless (memcmp (&info.position, pos_2_flr, sizeof (pos_2_flr)) == 0);
776
777 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000, 2, pos_2_flr);
778 fail_unless (memcmp (&info.position, pos_2_flr, sizeof (pos_2_flr)) == 0);
779 caps = gst_audio_info_to_caps (&info);
780 fail_unless (gst_audio_info_from_caps (&info2, caps));
781 fail_unless (memcmp (&info, &info2, sizeof (info)) == 0);
782 gst_caps_unref (caps);
783
784 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000, 2, pos_2_none);
785 fail_unless (memcmp (&info.position, pos_2_none, sizeof (pos_2_none)) == 0);
786 caps = gst_audio_info_to_caps (&info);
787 fail_unless (gst_audio_info_from_caps (&info2, caps));
788 fail_unless (memcmp (&info, &info2, sizeof (info)) == 0);
789 gst_caps_unref (caps);
790
791 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000, 3, pos_3_flrc);
792 fail_unless (memcmp (&info.position, pos_3_flrc, sizeof (pos_3_flrc)) == 0);
793 caps = gst_audio_info_to_caps (&info);
794 fail_unless (gst_audio_info_from_caps (&info2, caps));
795 fail_unless (memcmp (&info, &info2, sizeof (info)) == 0);
796 gst_caps_unref (caps);
797
798 ASSERT_WARNING (gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000,
799 2, pos_2_frl));
800 ASSERT_WARNING (gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000,
801 2, pos_2_mixed));
802 ASSERT_WARNING (gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000,
803 2, pos_2_frr));
804 ASSERT_WARNING (gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_F32, 48000,
805 3, pos_3_frcl));
806 }
807
808 GST_END_TEST;
809
810 typedef struct
811 {
812 gint channels;
813 GstAudioChannelPosition from[32], to[32];
814 gint32 in[32], out[32];
815 gint32 plane_offsets[32];
816 gboolean fail;
817 } MultichannelReorderData;
818
GST_START_TEST(test_multichannel_reorder)819 GST_START_TEST (test_multichannel_reorder)
820 {
821 MultichannelReorderData tests[] = {
822 {1,
823 {GST_AUDIO_CHANNEL_POSITION_MONO},
824 {GST_AUDIO_CHANNEL_POSITION_MONO},
825 {0, 1, 2, 3},
826 {0, 1, 2, 3},
827 {0},
828 FALSE},
829 {1,
830 {GST_AUDIO_CHANNEL_POSITION_MONO},
831 {GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER},
832 {0, 1, 2, 3},
833 {0, 1, 2, 3},
834 {0},
835 TRUE},
836 {2,
837 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
838 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT},
839 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
840 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT},
841 {0, 1, 2, 3},
842 {0, 1, 2, 3},
843 {0, 1},
844 FALSE},
845 {2,
846 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
847 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT},
848 {GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
849 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT},
850 {0, 1, 2, 3},
851 {1, 0, 3, 2},
852 {1, 0},
853 FALSE},
854 {4,
855 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
856 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
857 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
858 GST_AUDIO_CHANNEL_POSITION_REAR_CENTER},
859 {GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
860 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
861 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
862 GST_AUDIO_CHANNEL_POSITION_REAR_CENTER},
863 {0, 1, 2, 3},
864 {1, 2, 0, 3},
865 {1, 2, 0, 3},
866 FALSE},
867 {4,
868 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
869 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
870 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
871 GST_AUDIO_CHANNEL_POSITION_REAR_CENTER},
872 {GST_AUDIO_CHANNEL_POSITION_REAR_CENTER,
873 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
874 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
875 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER},
876 {0, 1, 2, 3},
877 {3, 0, 1, 2},
878 {3, 0, 1, 2},
879 FALSE},
880 {4,
881 {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
882 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
883 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
884 GST_AUDIO_CHANNEL_POSITION_REAR_CENTER},
885 {GST_AUDIO_CHANNEL_POSITION_REAR_CENTER,
886 GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
887 GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
888 GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT},
889 {0, 1, 2, 3},
890 {3, 2, 1, 0},
891 {3, 2, 1, 0},
892 FALSE},
893 };
894 gint i, j;
895 GstBuffer *buf;
896 GstMapInfo map;
897 GstAudioInfo info;
898 GstAudioBuffer abuf;
899
900 for (i = 0; i < G_N_ELEMENTS (tests); i++) {
901 buf =
902 gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY, tests[i].in,
903 sizeof (tests[i].in), 0, sizeof (tests[i].in), NULL, NULL);
904
905 if (tests[i].fail) {
906 fail_if (gst_audio_buffer_reorder_channels (buf, GST_AUDIO_FORMAT_S32,
907 tests[i].channels, tests[i].from, tests[i].to));
908 } else {
909 /* first interpret as interleaved */
910
911 fail_unless (gst_audio_buffer_reorder_channels (buf, GST_AUDIO_FORMAT_S32,
912 tests[i].channels, tests[i].from, tests[i].to));
913
914 gst_buffer_map (buf, &map, GST_MAP_READ);
915 fail_unless_equals_int (map.size, sizeof (tests[i].in));
916 fail_unless (memcmp (tests[i].out, map.data, map.size) == 0);
917 gst_buffer_unmap (buf, &map);
918
919 /* now interpret as planar */
920
921 gst_audio_info_init (&info);
922 gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S32, 44100,
923 tests[i].channels, NULL);
924 info.layout = GST_AUDIO_LAYOUT_NON_INTERLEAVED;
925
926 gst_buffer_add_audio_meta (buf, &info,
927 sizeof (tests[i].in) / (tests[i].channels * sizeof (gint32)), NULL);
928
929 fail_unless (gst_audio_buffer_reorder_channels (buf, GST_AUDIO_FORMAT_S32,
930 tests[i].channels, tests[i].from, tests[i].to));
931
932 fail_unless (gst_audio_buffer_map (&abuf, &info, buf, GST_MAP_READ));
933 fail_unless_equals_int (abuf.n_planes, tests[i].channels);
934 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&abuf),
935 sizeof (tests[i].in) / tests[i].channels);
936 for (j = 0; j < abuf.n_planes; j++) {
937 fail_unless_equals_pointer (abuf.planes[j],
938 abuf.map_infos[0].data +
939 tests[i].plane_offsets[j] * GST_AUDIO_BUFFER_PLANE_SIZE (&abuf));
940 }
941 gst_audio_buffer_unmap (&abuf);
942 }
943 gst_buffer_unref (buf);
944 }
945 }
946
947 GST_END_TEST;
948
GST_START_TEST(test_audio_format_s8)949 GST_START_TEST (test_audio_format_s8)
950 {
951 GstAudioFormat fmt;
952
953 fmt = gst_audio_format_build_integer (TRUE, G_BYTE_ORDER, 8, 8);
954 fail_unless (fmt == GST_AUDIO_FORMAT_S8);
955
956 }
957
958 GST_END_TEST;
959
GST_START_TEST(test_audio_format_u8)960 GST_START_TEST (test_audio_format_u8)
961 {
962 GstAudioFormat fmt;
963 fmt = gst_audio_format_build_integer (FALSE, G_BYTE_ORDER, 8, 8);
964 fail_unless (fmt == GST_AUDIO_FORMAT_U8);
965 }
966
967 GST_END_TEST;
968
GST_START_TEST(test_fill_silence)969 GST_START_TEST (test_fill_silence)
970 {
971 GstAudioInfo info;
972 GstAudioFormat f;
973 gint i;
974 guint8 test_silence[32];
975
976 for (f = GST_AUDIO_FORMAT_S8; f < GST_AUDIO_FORMAT_F64; f++) {
977 gst_audio_info_set_format (&info, f, 48000, 1, NULL);
978
979 gst_audio_format_info_fill_silence (info.finfo, test_silence,
980 GST_AUDIO_INFO_BPF (&info) * 4);
981
982 for (i = 0; i < 4; i++)
983 fail_unless (memcmp (test_silence + i * GST_AUDIO_INFO_BPF (&info),
984 info.finfo->silence, GST_AUDIO_INFO_BPF (&info)) == 0);
985 }
986 }
987
988 GST_END_TEST;
989
GST_START_TEST(test_stream_align)990 GST_START_TEST (test_stream_align)
991 {
992 GstAudioStreamAlign *align;
993 guint i;
994 GstClockTime timestamp;
995 GstClockTime out_timestamp, out_duration;
996 gboolean discont;
997
998 align = gst_audio_stream_align_new (1000, 40 * GST_MSECOND, 1 * GST_SECOND);
999
1000 for (i = 0; i < 500; i++) {
1001 timestamp = 10 * GST_MSECOND * i;
1002 discont = i == 0;
1003
1004 discont =
1005 gst_audio_stream_align_process (align, discont, timestamp, 10,
1006 &out_timestamp, &out_duration, NULL);
1007
1008 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1009 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1010 if (i == 0)
1011 fail_unless (discont);
1012 else
1013 fail_unless (!discont);
1014 }
1015
1016 /* Drift forwards by 1ms per 10ms buffer for the first 40 buffers.
1017 * - after 40 buffers we're above alignment threshold
1018 * - after 40 + 100 buffers we're at discont wait
1019 */
1020 for (i = 0; i < 500; i++) {
1021 timestamp = 10 * GST_MSECOND * i;
1022 discont = i == 0;
1023 if (i > 0)
1024 timestamp += 1 * GST_MSECOND * MIN (i, 40);
1025
1026 discont =
1027 gst_audio_stream_align_process (align, discont, timestamp, 10,
1028 &out_timestamp, &out_duration, NULL);
1029
1030 if (i < 140) {
1031 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1032 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1033 if (i == 0)
1034 fail_unless (discont);
1035 else
1036 fail_unless (!discont);
1037 } else {
1038 if (i == 140)
1039 fail_unless (discont);
1040 else
1041 fail_unless (!discont);
1042 fail_unless_equals_uint64 (out_timestamp,
1043 10 * GST_MSECOND * i + 40 * GST_MSECOND);
1044 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1045 }
1046 }
1047
1048 /* Drift backwards by 1ms per 10ms buffer for the first 40 buffers.
1049 * - after 40 buffers we're above alignment threshold
1050 * - after 40 + 100 buffers we're at discont wait
1051 */
1052 for (i = 0; i < 500; i++) {
1053 timestamp = 10 * GST_MSECOND * i;
1054 discont = i == 0;
1055 if (i > 0)
1056 timestamp -= 1 * GST_MSECOND * MIN (i, 40);
1057
1058 discont =
1059 gst_audio_stream_align_process (align, discont, timestamp, 10,
1060 &out_timestamp, &out_duration, NULL);
1061
1062 if (i < 140) {
1063 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1064 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1065 if (i == 0)
1066 fail_unless (discont);
1067 else
1068 fail_unless (!discont);
1069 } else {
1070 if (i == 140)
1071 fail_unless (discont);
1072 else
1073 fail_unless (!discont);
1074
1075 fail_unless_equals_uint64 (out_timestamp,
1076 10 * GST_MSECOND * i - 40 * GST_MSECOND);
1077 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1078 }
1079 }
1080
1081 /* Shift all buffers but the first by 40ms
1082 * - after 1 buffers we're above alignment threshold
1083 * - after 101 buffers we're at discont wait
1084 */
1085 for (i = 0; i < 500; i++) {
1086 timestamp = 10 * GST_MSECOND * i;
1087 discont = i == 0;
1088 if (i > 0)
1089 timestamp += 40 * GST_MSECOND;
1090
1091 discont =
1092 gst_audio_stream_align_process (align, discont, timestamp, 10,
1093 &out_timestamp, &out_duration, NULL);
1094
1095 if (i < 101) {
1096 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1097 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1098 if (i == 0)
1099 fail_unless (discont);
1100 else
1101 fail_unless (!discont);
1102 } else {
1103 if (i == 101)
1104 fail_unless (discont);
1105 else
1106 fail_unless (!discont);
1107 fail_unless_equals_uint64 (out_timestamp,
1108 10 * GST_MSECOND * i + 40 * GST_MSECOND);
1109 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1110 }
1111 }
1112
1113 /* Shift every second buffer by 40ms:
1114 * - never discont!
1115 */
1116 for (i = 0; i < 500; i++) {
1117 timestamp = 10 * GST_MSECOND * i;
1118 discont = i == 0;
1119
1120 if (i % 2 == 0 && i > 0)
1121 timestamp += 40 * GST_MSECOND;
1122
1123 discont =
1124 gst_audio_stream_align_process (align, discont, timestamp, 10,
1125 &out_timestamp, &out_duration, NULL);
1126
1127 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1128 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1129 if (i == 0)
1130 fail_unless (discont);
1131 else
1132 fail_unless (!discont);
1133 }
1134
1135 /* Shift every buffer 100 by 2: discont at buffer 200
1136 */
1137 for (i = 0; i < 500; i++) {
1138 timestamp = 10 * GST_MSECOND * i;
1139 discont = i == 0;
1140 if (i >= 100)
1141 timestamp += 2 * GST_SECOND;
1142
1143 discont =
1144 gst_audio_stream_align_process (align, discont, timestamp, 10,
1145 &out_timestamp, &out_duration, NULL);
1146
1147 if (i < 200) {
1148 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1149 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1150 if (i == 0)
1151 fail_unless (discont);
1152 else
1153 fail_unless (!discont);
1154 } else {
1155 fail_unless_equals_uint64 (out_timestamp,
1156 10 * GST_MSECOND * i + 2 * GST_SECOND);
1157 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1158 if (i == 200)
1159 fail_unless (discont);
1160 else
1161 fail_unless (!discont);
1162 }
1163 }
1164
1165 gst_audio_stream_align_free (align);
1166 }
1167
1168 GST_END_TEST;
1169
GST_START_TEST(test_stream_align_reverse)1170 GST_START_TEST (test_stream_align_reverse)
1171 {
1172 GstAudioStreamAlign *align;
1173 gint i;
1174 GstClockTime timestamp;
1175 GstClockTime out_timestamp, out_duration;
1176 gboolean discont;
1177
1178 align = gst_audio_stream_align_new (-1000, 40 * GST_MSECOND, 1 * GST_SECOND);
1179
1180 for (i = 499; i >= 0; i--) {
1181 timestamp = 10 * GST_MSECOND * i;
1182 discont = i == 499;
1183
1184 discont =
1185 gst_audio_stream_align_process (align, discont, timestamp, 10,
1186 &out_timestamp, &out_duration, NULL);
1187
1188 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1189 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1190 if (i == 499)
1191 fail_unless (discont);
1192 else
1193 fail_unless (!discont);
1194 }
1195
1196 /* Drift forwards by 1ms per 10ms buffer for the first 40 buffers.
1197 * - after 40 buffers we're above alignment threshold
1198 * - after 40 + 100 buffers we're at discont wait
1199 */
1200 for (i = 499; i >= 0; i--) {
1201 timestamp = 10 * GST_MSECOND * i;
1202 discont = i == 499;
1203 if (i < 499)
1204 timestamp += 1 * GST_MSECOND * MIN (499 - i, 40);
1205
1206 discont =
1207 gst_audio_stream_align_process (align, discont, timestamp, 10,
1208 &out_timestamp, &out_duration, NULL);
1209
1210 if (i >= 500 - 140) {
1211 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1212 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1213 if (i == 499)
1214 fail_unless (discont);
1215 else
1216 fail_unless (!discont);
1217 } else {
1218 if (i == 499 - 140)
1219 fail_unless (discont);
1220 else
1221 fail_unless (!discont);
1222 fail_unless_equals_uint64 (out_timestamp,
1223 10 * GST_MSECOND * i + 40 * GST_MSECOND);
1224 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1225 }
1226 }
1227
1228 /* Drift backwards by 1ms per 10ms buffer for the first 40 buffers.
1229 * - after 40 buffers we're above alignment threshold
1230 * - after 40 + 100 buffers we're at discont wait
1231 */
1232 for (i = 499; i >= 4; i--) {
1233 timestamp = 10 * GST_MSECOND * i;
1234 discont = i == 499;
1235 if (i < 499)
1236 timestamp -= 1 * GST_MSECOND * MIN (499 - i, 40);
1237
1238 discont =
1239 gst_audio_stream_align_process (align, discont, timestamp, 10,
1240 &out_timestamp, &out_duration, NULL);
1241
1242 if (i >= 500 - 140) {
1243 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1244 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1245 if (i == 499)
1246 fail_unless (discont);
1247 else
1248 fail_unless (!discont);
1249 } else {
1250 if (i == 499 - 140)
1251 fail_unless (discont);
1252 else
1253 fail_unless (!discont);
1254
1255 fail_unless_equals_uint64 (out_timestamp,
1256 10 * GST_MSECOND * i - 40 * GST_MSECOND);
1257 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1258 }
1259 }
1260
1261 /* Shift all buffers but the first by 40ms
1262 * - after 1 buffers we're above alignment threshold
1263 * - after 101 buffers we're at discont wait
1264 */
1265 for (i = 499; i >= 0; i--) {
1266 timestamp = 10 * GST_MSECOND * i;
1267 discont = i == 499;
1268 if (i < 499)
1269 timestamp += 40 * GST_MSECOND;
1270
1271 discont =
1272 gst_audio_stream_align_process (align, discont, timestamp, 10,
1273 &out_timestamp, &out_duration, NULL);
1274
1275 if (i >= 500 - 101) {
1276 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1277 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1278 if (i == 499)
1279 fail_unless (discont);
1280 else
1281 fail_unless (!discont);
1282 } else {
1283 if (i == 499 - 101)
1284 fail_unless (discont);
1285 else
1286 fail_unless (!discont);
1287 fail_unless_equals_uint64 (out_timestamp,
1288 10 * GST_MSECOND * i + 40 * GST_MSECOND);
1289 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1290 }
1291 }
1292
1293 /* Shift every second buffer by 40ms:
1294 * - never discont!
1295 */
1296 for (i = 499; i >= 0; i--) {
1297 timestamp = 10 * GST_MSECOND * i;
1298 discont = i == 499;
1299
1300 if (i % 2 == 0 && i < 499)
1301 timestamp += 40 * GST_MSECOND;
1302
1303 discont =
1304 gst_audio_stream_align_process (align, discont, timestamp, 10,
1305 &out_timestamp, &out_duration, NULL);
1306
1307 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1308 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1309 if (i == 499)
1310 fail_unless (discont);
1311 else
1312 fail_unless (!discont);
1313 }
1314
1315 /* Shift buffer 100 by 2: discont at buffer 200
1316 */
1317 for (i = 499; i >= 0; i--) {
1318 timestamp = 10 * GST_MSECOND * i;
1319 discont = i == 499;
1320 if (i < 500 - 100)
1321 timestamp += 2 * GST_SECOND;
1322
1323 discont =
1324 gst_audio_stream_align_process (align, discont, timestamp, 10,
1325 &out_timestamp, &out_duration, NULL);
1326
1327 if (i >= 500 - 200) {
1328 fail_unless_equals_uint64 (out_timestamp, 10 * GST_MSECOND * i);
1329 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1330 if (i == 499)
1331 fail_unless (discont);
1332 else
1333 fail_unless (!discont);
1334 } else {
1335 fail_unless_equals_uint64 (out_timestamp,
1336 10 * GST_MSECOND * i + 2 * GST_SECOND);
1337 fail_unless_equals_uint64 (out_duration, 10 * GST_MSECOND);
1338 if (i == 499 - 200)
1339 fail_unless (discont);
1340 else
1341 fail_unless (!discont);
1342 }
1343 }
1344
1345 gst_audio_stream_align_free (align);
1346 }
1347
1348 GST_END_TEST;
1349
1350 typedef struct
1351 {
1352 GstAudioFormat format;
1353 GstAudioLayout layout;
1354 gint channels;
1355 gsize samples;
1356 gsize plane_size;
1357 gsize offsets[10];
1358 gboolean add_meta;
1359 gboolean use_offsets;
1360 } AudioBufferTestData;
1361
GST_START_TEST(test_audio_buffer_and_audio_meta)1362 GST_START_TEST (test_audio_buffer_and_audio_meta)
1363 {
1364 AudioBufferTestData td[] = {
1365 {GST_AUDIO_FORMAT_S24_32, GST_AUDIO_LAYOUT_NON_INTERLEAVED,
1366 4, 60, 240, {10, 760, 510, 260}, TRUE, TRUE},
1367 {GST_AUDIO_FORMAT_F32, GST_AUDIO_LAYOUT_NON_INTERLEAVED,
1368 4, 60, 240, {0, 240, 480, 720}, TRUE, FALSE},
1369 {GST_AUDIO_FORMAT_S16, GST_AUDIO_LAYOUT_INTERLEAVED,
1370 4, 125, 1000, {0}, TRUE, FALSE},
1371 {GST_AUDIO_FORMAT_S16, GST_AUDIO_LAYOUT_INTERLEAVED,
1372 4, 125, 1000, {0}, FALSE, FALSE},
1373 {GST_AUDIO_FORMAT_S8, GST_AUDIO_LAYOUT_INTERLEAVED,
1374 8, 125, 1000, {0}, FALSE, FALSE},
1375 {GST_AUDIO_FORMAT_U8, GST_AUDIO_LAYOUT_NON_INTERLEAVED,
1376 8, 125, 125, {0, 125, 250, 375, 500, 625, 750, 875}, TRUE, FALSE},
1377 {GST_AUDIO_FORMAT_U32, GST_AUDIO_LAYOUT_NON_INTERLEAVED,
1378 10, 25, 100, {0, 100, 200, 300, 400, 500, 600, 700, 800, 900}, TRUE,
1379 FALSE},
1380 {GST_AUDIO_FORMAT_U32, GST_AUDIO_LAYOUT_INTERLEAVED,
1381 10, 25, 1000, {0}, FALSE, FALSE},
1382 };
1383 gint i;
1384
1385 for (i = 0; i < G_N_ELEMENTS (td); i++) {
1386 GstBuffer *buf;
1387 guint8 *data;
1388 GstAudioInfo info;
1389 GstAudioMeta *meta;
1390 GstAudioBuffer buffer;
1391 gint j;
1392
1393 gst_audio_info_init (&info);
1394 gst_audio_info_set_format (&info, td[i].format, 44100, td[i].channels,
1395 NULL);
1396 info.layout = td[i].layout;
1397
1398 buf = make_buffer (&data);
1399 if (td[i].add_meta) {
1400 meta = gst_buffer_add_audio_meta (buf, &info, td[i].samples,
1401 td[i].use_offsets ? td[i].offsets : NULL);
1402
1403 fail_unless (meta);
1404 fail_unless (GST_AUDIO_INFO_IS_VALID (&meta->info));
1405 fail_unless (gst_audio_info_is_equal (&meta->info, &info));
1406 fail_unless_equals_int (meta->info.finfo->format, td[i].format);
1407 fail_unless_equals_int (meta->info.layout, td[i].layout);
1408 fail_unless_equals_int (meta->info.channels, td[i].channels);
1409 fail_unless_equals_int (meta->samples, td[i].samples);
1410
1411 if (td[i].layout == GST_AUDIO_LAYOUT_NON_INTERLEAVED) {
1412 fail_unless (meta->offsets);
1413 for (j = 0; j < td[i].channels; j++) {
1414 fail_unless_equals_int (meta->offsets[j], td[i].offsets[j]);
1415 }
1416 } else {
1417 fail_if (meta->offsets);
1418 }
1419 }
1420
1421 fail_unless (gst_audio_buffer_map (&buffer, &info, buf, GST_MAP_READ));
1422 fail_unless_equals_pointer (buffer.buffer, buf);
1423 fail_unless (GST_AUDIO_INFO_IS_VALID (&buffer.info));
1424 fail_unless (gst_audio_info_is_equal (&buffer.info, &info));
1425 fail_unless_equals_int (buffer.n_samples, td[i].samples);
1426
1427 if (td[i].layout == GST_AUDIO_LAYOUT_NON_INTERLEAVED) {
1428 fail_unless_equals_int (buffer.n_planes, td[i].channels);
1429 for (j = 0; j < td[i].channels; j++) {
1430 fail_unless_equals_pointer (buffer.planes[j], data + td[i].offsets[j]);
1431 }
1432 } else {
1433 fail_unless_equals_int (buffer.n_planes, 1);
1434 fail_unless_equals_pointer (buffer.planes[0], data);
1435 }
1436
1437 fail_unless_equals_int (GST_AUDIO_BUFFER_PLANE_SIZE (&buffer),
1438 td[i].plane_size);
1439
1440 if (buffer.n_planes <= 8) {
1441 fail_unless_equals_pointer (buffer.map_infos, buffer.priv_map_infos_arr);
1442 fail_unless_equals_pointer (buffer.planes, buffer.priv_planes_arr);
1443 } else {
1444 fail_if (buffer.map_infos == buffer.priv_map_infos_arr);
1445 fail_if (buffer.planes == buffer.priv_planes_arr);
1446 }
1447
1448 gst_audio_buffer_unmap (&buffer);
1449 gst_buffer_unref (buf);
1450 }
1451 }
1452
1453 GST_END_TEST;
1454
1455 typedef struct
1456 {
1457 const gchar *str;
1458 GstAudioFormat format;
1459 GstAudioLayout layout;
1460 gint rate;
1461 gint channels;
1462 gboolean ret;
1463 } AudioInfoFromCapsData;
1464
GST_START_TEST(test_audio_info_from_caps)1465 GST_START_TEST (test_audio_info_from_caps)
1466 {
1467 static const AudioInfoFromCapsData format_list[] = {
1468 /* raw format, positive */
1469 {"audio/x-raw, format = (string) S8, layout = (string) non-interleaved, "
1470 "rate = (int) 44100, channels = (int) 2", GST_AUDIO_FORMAT_S8,
1471 GST_AUDIO_LAYOUT_NON_INTERLEAVED, 44100, 2, TRUE},
1472 {"audio/x-raw, format = (string) U8, layout = (string) interleaved, "
1473 "rate = (int) 44100, channels = (int) 1", GST_AUDIO_FORMAT_U8,
1474 GST_AUDIO_LAYOUT_INTERLEAVED, 44100, 1, TRUE},
1475
1476 /* raw format, negative */
1477 /* unknown format */
1478 {"audio/x-raw, format = (string) foo, layout = (string) interleaved, "
1479 "rate = (int) 44100, channels = (int) 2", GST_AUDIO_FORMAT_UNKNOWN,
1480 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1481 {"audio/x-raw, layout = (string) non-interleaved, "
1482 "rate = (int) 44100, channels = (int) 2", GST_AUDIO_FORMAT_UNKNOWN,
1483 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1484 /* unknown layout */
1485 {"audio/x-raw, format = (string) U8, "
1486 "rate = (int) 44100, channels = (int) 2", GST_AUDIO_FORMAT_UNKNOWN,
1487 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1488 /* unknown rate */
1489 {"audio/x-raw, format = (string) U8, layout = (string) interleaved, "
1490 "channels = (int) 2", GST_AUDIO_FORMAT_UNKNOWN,
1491 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1492 /* unknown channels */
1493 {"audio/x-raw, format = (string) U8, layout = (string) interleaved, "
1494 "rate = (int) 44100", GST_AUDIO_FORMAT_UNKNOWN,
1495 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1496 /* video caps */
1497 {"video/x-raw, format = (string) NV12",
1498 GST_AUDIO_FORMAT_UNKNOWN, GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, FALSE},
1499
1500 /* encoded format, it allow empty fields */
1501 {"audio/x-opus", GST_AUDIO_FORMAT_ENCODED,
1502 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 0, TRUE},
1503 /* rate only */
1504 {"audio/x-opus, rate = (int) 44100", GST_AUDIO_FORMAT_ENCODED,
1505 GST_AUDIO_LAYOUT_INTERLEAVED, 44100, 0, TRUE},
1506 /* channels only */
1507 {"audio/x-opus, channels = (int) 2", GST_AUDIO_FORMAT_ENCODED,
1508 GST_AUDIO_LAYOUT_INTERLEAVED, 0, 2, TRUE},
1509 /* rate and channels */
1510 {"audio/x-opus, rate = (int) 44100, channels = (int) 2",
1511 GST_AUDIO_FORMAT_ENCODED, GST_AUDIO_LAYOUT_INTERLEAVED, 44100, 2, TRUE},
1512 };
1513 gint i;
1514
1515 for (i = 0; i < G_N_ELEMENTS (format_list); i++) {
1516 GstAudioInfo info;
1517 GstCaps *caps;
1518
1519 GST_LOG ("checking %dth format", i);
1520
1521 caps = gst_caps_from_string (format_list[i].str);
1522 fail_unless (caps != NULL);
1523
1524 gst_audio_info_init (&info);
1525 fail_unless_equals_int (gst_audio_info_from_caps (&info, caps),
1526 format_list[i].ret);
1527
1528 if (format_list[i].ret) {
1529 fail_unless_equals_int (GST_AUDIO_INFO_FORMAT (&info),
1530 format_list[i].format);
1531 fail_unless_equals_int (GST_AUDIO_INFO_LAYOUT (&info),
1532 format_list[i].layout);
1533 fail_unless_equals_int (GST_AUDIO_INFO_RATE (&info), format_list[i].rate);
1534 fail_unless_equals_int (GST_AUDIO_INFO_CHANNELS (&info),
1535 format_list[i].channels);
1536 }
1537
1538 gst_caps_unref (caps);
1539 }
1540 }
1541
1542 GST_END_TEST;
1543
GST_START_TEST(test_audio_make_raw_caps)1544 GST_START_TEST (test_audio_make_raw_caps)
1545 {
1546 GstCaps *caps, *expected;
1547 GstAudioFormat f1[] = { GST_AUDIO_FORMAT_U8 };
1548 GstAudioFormat f2[] = { GST_AUDIO_FORMAT_U8, GST_AUDIO_FORMAT_S8 };
1549
1550 caps =
1551 gst_audio_make_raw_caps (f1, G_N_ELEMENTS (f1),
1552 GST_AUDIO_LAYOUT_INTERLEAVED);
1553 expected =
1554 gst_caps_from_string
1555 ("audio/x-raw, format = (string) U8, rate = (int) [ 1, max ], channels = (int) [ 1, max ], layout = (string) interleaved");
1556 fail_unless (gst_caps_is_equal (caps, expected));
1557 gst_caps_unref (caps);
1558 gst_caps_unref (expected);
1559
1560 caps =
1561 gst_audio_make_raw_caps (f2, G_N_ELEMENTS (f2),
1562 GST_AUDIO_LAYOUT_NON_INTERLEAVED);
1563 expected =
1564 gst_caps_from_string
1565 ("audio/x-raw, format = (string) { U8, S8 }, rate = (int) [ 1, max ], channels = (int) [ 1, max ], layout = (string) non-interleaved");
1566 fail_unless (gst_caps_is_equal (caps, expected));
1567 gst_caps_unref (caps);
1568 gst_caps_unref (expected);
1569
1570 caps = gst_audio_make_raw_caps (NULL, 0, GST_AUDIO_LAYOUT_INTERLEAVED);
1571 expected =
1572 gst_caps_from_string
1573 ("audio/x-raw, format = (string) { S8, U8, S16LE, S16BE, U16LE, U16BE, S24_32LE, S24_32BE, U24_32LE, U24_32BE, S32LE, S32BE, U32LE, U32BE, S24LE, S24BE, U24LE, U24BE, S20LE, S20BE, U20LE, U20BE, S18LE, S18BE, U18LE, U18BE, F32LE, F32BE, F64LE, F64BE }, rate = (int) [ 1, max ], channels = (int) [ 1, max ], layout = (string) interleaved");
1574 fail_unless (gst_caps_is_equal (caps, expected));
1575 gst_caps_unref (caps);
1576 gst_caps_unref (expected);
1577 }
1578
1579 GST_END_TEST;
1580
1581 static Suite *
audio_suite(void)1582 audio_suite (void)
1583 {
1584 Suite *s = suite_create ("audio support library");
1585
1586 TCase *tc_chain = tcase_create ("general");
1587
1588 suite_add_tcase (s, tc_chain);
1589 tcase_add_test (tc_chain, test_buffer_clip_unsupported_format);
1590 tcase_add_test (tc_chain, test_buffer_clip_time_start_and_stop);
1591 tcase_add_test (tc_chain, test_buffer_clip_time_start_and_stop_planar);
1592 tcase_add_test (tc_chain, test_buffer_clip_time_start);
1593 tcase_add_test (tc_chain, test_buffer_clip_time_start_planar);
1594 tcase_add_test (tc_chain, test_buffer_clip_time_stop);
1595 tcase_add_test (tc_chain, test_buffer_clip_time_stop_planar);
1596 tcase_add_test (tc_chain, test_buffer_clip_time_outside);
1597 tcase_add_test (tc_chain, test_buffer_clip_time_start_and_stop_no_meta);
1598 tcase_add_test (tc_chain, test_buffer_clip_time_no_timestamp);
1599 tcase_add_test (tc_chain, test_buffer_clip_time_handles_rounding);
1600 tcase_add_test (tc_chain, test_buffer_clip_samples_start_and_stop);
1601 tcase_add_test (tc_chain, test_buffer_clip_samples_start_and_stop_planar);
1602 tcase_add_test (tc_chain, test_buffer_clip_samples_start);
1603 tcase_add_test (tc_chain, test_buffer_clip_samples_stop);
1604 tcase_add_test (tc_chain, test_buffer_clip_samples_outside);
1605 tcase_add_test (tc_chain, test_buffer_clip_samples_start_and_stop_no_meta);
1606 tcase_add_test (tc_chain, test_buffer_clip_samples_no_timestamp);
1607 tcase_add_test (tc_chain, test_buffer_truncate_samples_offset_end);
1608 tcase_add_test (tc_chain, test_buffer_truncate_samples_no_timestamp);
1609 tcase_add_test (tc_chain, test_multichannel_checks);
1610 tcase_add_test (tc_chain, test_multichannel_reorder);
1611 tcase_add_test (tc_chain, test_audio_format_s8);
1612 tcase_add_test (tc_chain, test_audio_format_u8);
1613 tcase_add_test (tc_chain, test_fill_silence);
1614 tcase_add_test (tc_chain, test_stream_align);
1615 tcase_add_test (tc_chain, test_stream_align_reverse);
1616 tcase_add_test (tc_chain, test_audio_buffer_and_audio_meta);
1617 tcase_add_test (tc_chain, test_audio_info_from_caps);
1618 tcase_add_test (tc_chain, test_audio_make_raw_caps);
1619
1620 return s;
1621 }
1622
1623 GST_CHECK_MAIN (audio);
1624