1 /* GStreamer
2 *
3 * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22 #include <string.h>
23
24 #include <gst/check/gstcheck.h>
25 #include <gst/audio/audio.h>
26 #include "../../gst/gdp/dataprotocol.c"
27
28 /* For ease of programming we use globals to keep refs for our floating
29 * src and sink pads we create; otherwise we always have to do get_pad,
30 * get_peer, and then remove references in every test function */
31 static GstPad *mysrcpad, *myshsrcpad, *mysinkpad;
32
33 #define FORMATS "{ S8, "GST_AUDIO_NE(S16)" }"
34
35 #define AUDIO_CAPS_TEMPLATE_STRING \
36 "audio/x-raw, " \
37 "format = (string) "FORMATS", " \
38 "rate = (int) [ 1, MAX ], " \
39 "channels = (int) [ 1, 8 ]"
40
41 #define AUDIO_CAPS_STRING \
42 "audio/x-raw, " \
43 "format = (string) "GST_AUDIO_NE(S16)", " \
44 "rate = (int) 1000, " \
45 "channels = (int) 2"
46
47
48 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
49 GST_PAD_SINK,
50 GST_PAD_ALWAYS,
51 GST_STATIC_CAPS ("application/x-gdp")
52 );
53 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
54 GST_PAD_SRC,
55 GST_PAD_ALWAYS,
56 GST_STATIC_CAPS (AUDIO_CAPS_TEMPLATE_STRING)
57 );
58
59 /* takes over reference for outcaps */
60 static GstElement *
setup_gdppay(void)61 setup_gdppay (void)
62 {
63 GstElement *gdppay;
64
65 GST_DEBUG ("setup_gdppay");
66 gdppay = gst_check_setup_element ("gdppay");
67 mysrcpad = gst_check_setup_src_pad (gdppay, &srctemplate);
68 mysinkpad = gst_check_setup_sink_pad (gdppay, &sinktemplate);
69 gst_pad_set_active (mysrcpad, TRUE);
70 gst_pad_set_active (mysinkpad, TRUE);
71
72 return gdppay;
73 }
74
75 static void
cleanup_gdppay(GstElement * gdppay)76 cleanup_gdppay (GstElement * gdppay)
77 {
78 GST_DEBUG ("cleanup_gdppay");
79
80 if (mysrcpad)
81 gst_pad_set_active (mysrcpad, FALSE);
82 if (myshsrcpad)
83 gst_pad_set_active (myshsrcpad, FALSE);
84 gst_pad_set_active (mysinkpad, FALSE);
85 gst_check_teardown_src_pad (gdppay);
86 gst_check_teardown_sink_pad (gdppay);
87 gst_check_teardown_element (gdppay);
88 mysrcpad = NULL;
89 myshsrcpad = NULL;
90 }
91
92 static void
check_stream_start_buffer(gint refcount)93 check_stream_start_buffer (gint refcount)
94 {
95 GstBuffer *outbuffer;
96
97 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
98 buffers = g_list_remove (buffers, outbuffer);
99 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", refcount);
100 gst_buffer_unref (outbuffer);
101 }
102
103 static void
check_caps_buffer(gint refcount,GstCaps * caps)104 check_caps_buffer (gint refcount, GstCaps * caps)
105 {
106 GstBuffer *outbuffer;
107 gchar *caps_string = gst_caps_to_string (caps);
108 guint length;
109
110 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
111 buffers = g_list_remove (buffers, outbuffer);
112 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", refcount);
113 length = GST_DP_HEADER_LENGTH + (strlen (caps_string) + 1);
114 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
115 gst_buffer_unref (outbuffer);
116 g_free (caps_string);
117 }
118
119 static void
check_segment_buffer(gint refcount)120 check_segment_buffer (gint refcount)
121 {
122 GstBuffer *outbuffer;
123
124 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
125 buffers = g_list_remove (buffers, outbuffer);
126 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", refcount);
127 gst_buffer_unref (outbuffer);
128 }
129
130
GST_START_TEST(test_audio)131 GST_START_TEST (test_audio)
132 {
133 GstCaps *caps;
134 GstElement *gdppay;
135 GstBuffer *inbuffer, *outbuffer;
136 gint length;
137
138 gdppay = setup_gdppay ();
139
140 fail_unless (gst_element_set_state (gdppay,
141 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
142 "could not set to playing");
143
144 /* no buffer should be pushed yet, waiting for caps */
145 fail_unless_equals_int (g_list_length (buffers), 0);
146
147 GST_DEBUG ("first buffer");
148 inbuffer = gst_buffer_new_and_alloc (4);
149 gst_buffer_memset (inbuffer, 0, 0x00, 4);
150 caps = gst_caps_from_string (AUDIO_CAPS_STRING);
151 gst_check_setup_events (mysrcpad, gdppay, caps, GST_FORMAT_TIME);
152
153 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
154
155 /* pushing gives away my reference */
156 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
157
158 /* we should have four buffers now */
159 fail_unless_equals_int (g_list_length (buffers), 4);
160
161 /* first buffer is the stream-start event */
162 check_stream_start_buffer (1);
163
164 /* second buffer is the serialized caps */
165 check_caps_buffer (1, caps);
166
167 /* third buffer is the serialized new_segment event */
168 check_segment_buffer (1);
169
170 /* the fourth buffer is the GDP buffer for our pushed buffer */
171 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
172 buffers = g_list_remove (buffers, outbuffer);
173 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
174 length = GST_DP_HEADER_LENGTH + 4;
175 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
176 gst_buffer_unref (outbuffer);
177
178 /* second buffer */
179 GST_DEBUG ("second buffer");
180 inbuffer = gst_buffer_new_and_alloc (4);
181 gst_buffer_memset (inbuffer, 0, 0x00, 4);
182
183 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
184
185 /* pushing gives away my reference */
186 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
187
188 fail_unless_equals_int (g_list_length (buffers), 1);
189 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
190 buffers = g_list_remove (buffers, outbuffer);
191 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
192
193 /* the third output buffer is data */
194 length = GST_DP_HEADER_LENGTH + 4;
195 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
196 gst_buffer_unref (outbuffer);
197
198 /* a third buffer without caps set explicitly; should work */
199 GST_DEBUG ("Creating third buffer, no caps set");
200 inbuffer = gst_buffer_new_and_alloc (4);
201 gst_buffer_memset (inbuffer, 0, 0x00, 4);
202
203 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
204
205 /* pushing gives away my reference */
206 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
207
208 fail_unless_equals_int (g_list_length (buffers), 1);
209 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
210 buffers = g_list_remove (buffers, outbuffer);
211 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
212
213 /* the fourth output buffer is data */
214 length = GST_DP_HEADER_LENGTH + 4;
215 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
216 gst_buffer_unref (outbuffer);
217
218
219 fail_unless (gst_element_set_state (gdppay,
220 GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
221
222 gst_caps_unref (caps);
223 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
224 g_list_free (buffers);
225 buffers = NULL;
226 ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
227 cleanup_gdppay (gdppay);
228 }
229
230 GST_END_TEST;
231
232 static GstStaticPadTemplate shsrctemplate = GST_STATIC_PAD_TEMPLATE ("src",
233 GST_PAD_SRC,
234 GST_PAD_ALWAYS,
235 GST_STATIC_CAPS ("application/x-gst-test-streamheader")
236 );
237
238
239 static GstElement *
setup_gdppay_streamheader(void)240 setup_gdppay_streamheader (void)
241 {
242 GstElement *gdppay;
243
244 GST_DEBUG ("setup_gdppay");
245 gdppay = gst_check_setup_element ("gdppay");
246 myshsrcpad = gst_check_setup_src_pad (gdppay, &shsrctemplate);
247 mysinkpad = gst_check_setup_sink_pad (gdppay, &sinktemplate);
248 gst_pad_set_active (myshsrcpad, TRUE);
249 gst_pad_set_active (mysinkpad, TRUE);
250
251 return gdppay;
252 }
253
254 /* this test serializes a stream that already has a streamheader of its own.
255 * the streamheader should then be serialized and put on the GDP stream's
256 * streamheader */
GST_START_TEST(test_streamheader)257 GST_START_TEST (test_streamheader)
258 {
259 GstCaps *caps, *sinkcaps;
260 GstElement *gdppay;
261 GstBuffer *inbuffer, *outbuffer, *shbuffer;
262 gchar *caps_string;
263 gint length;
264 GstStructure *structure;
265 GValue array = { 0 };
266 GValue value = { 0 };
267 const GValue *sh;
268 GArray *shbuffers;
269
270 gdppay = setup_gdppay_streamheader ();
271
272 fail_unless (gst_element_set_state (gdppay,
273 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
274 "could not set to playing");
275
276 /* no buffer should be pushed yet, still waiting for caps */
277 fail_unless_equals_int (g_list_length (buffers), 0);
278
279 GST_DEBUG ("first buffer");
280 inbuffer = gst_buffer_new_and_alloc (4);
281 gst_buffer_fill (inbuffer, 0, "head", 4);
282 caps = gst_caps_from_string ("application/x-gst-test-streamheader");
283 structure = gst_caps_get_structure (caps, 0);
284 GST_BUFFER_FLAG_SET (inbuffer, GST_BUFFER_FLAG_HEADER);
285 g_value_init (&array, GST_TYPE_ARRAY);
286 g_value_init (&value, GST_TYPE_BUFFER);
287 shbuffer = gst_buffer_copy (inbuffer);
288 gst_value_set_buffer (&value, shbuffer);
289 gst_buffer_unref (shbuffer);
290 gst_value_array_append_value (&array, &value);
291 g_value_unset (&value);
292 gst_structure_set_value (structure, "streamheader", &array);
293 g_value_unset (&array);
294 caps_string = gst_caps_to_string (caps);
295
296 gst_check_setup_events (myshsrcpad, gdppay, caps, GST_FORMAT_TIME);
297 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
298
299 /* pushing gives away my reference */
300 fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
301
302 /* we should have four buffers now */
303 fail_unless_equals_int (g_list_length (buffers), 4);
304
305 /* our sink pad should now have GDP caps with a streamheader that includes
306 * GDP wrappings of our streamheader */
307 sinkcaps = gst_pad_get_current_caps (mysinkpad);
308 structure = gst_caps_get_structure (sinkcaps, 0);
309 fail_unless_equals_string ((gchar *) gst_structure_get_name (structure),
310 "application/x-gdp");
311 fail_unless (gst_structure_has_field (structure, "streamheader"));
312 sh = gst_structure_get_value (structure, "streamheader");
313 fail_unless (G_VALUE_TYPE (sh) == GST_TYPE_ARRAY);
314 shbuffers = g_value_peek_pointer (sh);
315 /* a serialized stream-start-id, a serialized new_segment,
316 * a serialized caps, and serialization of our
317 * incoming streamheader */
318 fail_unless_equals_int (shbuffers->len, 4);
319
320 gst_caps_unref (sinkcaps);
321
322 /* first buffer is the stream-start event */
323 check_stream_start_buffer (1);
324
325 /* second buffer is the serialized caps;
326 * the element also holds a ref to it */
327 check_caps_buffer (1, caps);
328
329 /* third buffer is the serialized new_segment event;
330 * the element also holds a ref to it */
331 check_segment_buffer (1);
332
333 /* the fourth buffer is the GDP buffer for our pushed buffer */
334 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
335 buffers = g_list_remove (buffers, outbuffer);
336 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
337 length = GST_DP_HEADER_LENGTH + 4;
338 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
339 gst_buffer_unref (outbuffer);
340
341 /* second buffer */
342 GST_DEBUG ("second buffer");
343 inbuffer = gst_buffer_new_and_alloc (4);
344 gst_buffer_memset (inbuffer, 0, 0x02, 4);
345
346 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
347
348 /* pushing gives away my reference */
349 fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
350
351 fail_unless_equals_int (g_list_length (buffers), 1);
352 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
353 buffers = g_list_remove (buffers, outbuffer);
354 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
355
356 /* the third output buffer is data */
357 length = GST_DP_HEADER_LENGTH + 4;
358 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
359 gst_buffer_unref (outbuffer);
360
361 /* a third buffer without caps set explicitly; should work */
362 GST_DEBUG ("Creating third buffer, no caps set");
363 inbuffer = gst_buffer_new_and_alloc (4);
364 gst_buffer_memset (inbuffer, 0, 0x03, 4);
365
366 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
367
368 /* pushing gives away my reference */
369 fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
370
371 fail_unless_equals_int (g_list_length (buffers), 1);
372 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
373 buffers = g_list_remove (buffers, outbuffer);
374 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
375
376 /* the fourth output buffer is data */
377 length = GST_DP_HEADER_LENGTH + 4;
378 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
379 gst_buffer_unref (outbuffer);
380
381
382 fail_unless (gst_element_set_state (gdppay,
383 GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
384
385 gst_caps_unref (caps);
386 g_free (caps_string);
387 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
388 g_list_free (buffers);
389 buffers = NULL;
390 ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
391 cleanup_gdppay (gdppay);
392 }
393
394 GST_END_TEST;
395
396
GST_START_TEST(test_first_no_caps)397 GST_START_TEST (test_first_no_caps)
398 {
399 GstElement *gdppay;
400 GstBuffer *inbuffer;
401
402 gdppay = setup_gdppay ();
403
404 fail_unless (gst_element_set_state (gdppay,
405 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
406 "could not set to playing");
407
408 gst_check_setup_events (mysrcpad, gdppay, NULL, GST_FORMAT_TIME);
409
410 GST_DEBUG ("first buffer");
411 inbuffer = gst_buffer_new_and_alloc (4);
412 gst_buffer_memset (inbuffer, 0, 0x01, 4);
413 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
414
415 /* pushing should trigger an error */
416 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_NOT_NEGOTIATED);
417
418 fail_unless_equals_int (g_list_length (buffers), 0);
419
420 fail_unless (gst_element_set_state (gdppay,
421 GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
422
423 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
424 g_list_free (buffers);
425 buffers = NULL;
426 ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
427 cleanup_gdppay (gdppay);
428 }
429
430 GST_END_TEST;
431
432 /* element should still work if no new_segment is sent before the first
433 * buffer */
GST_START_TEST(test_first_no_new_segment)434 GST_START_TEST (test_first_no_new_segment)
435 {
436 GstElement *gdppay;
437 GstBuffer *inbuffer;
438 GstCaps *caps;
439
440 gdppay = setup_gdppay ();
441
442 fail_unless (gst_element_set_state (gdppay,
443 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
444 "could not set to playing");
445
446 GST_DEBUG ("first buffer");
447 inbuffer = gst_buffer_new_and_alloc (4);
448 gst_buffer_memset (inbuffer, 0, 0x01, 4);
449 caps = gst_caps_from_string (AUDIO_CAPS_STRING);
450 gst_check_setup_events (mysrcpad, gdppay, caps, GST_FORMAT_TIME);
451 gst_caps_unref (caps);
452
453 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
454
455 /* pushing gives away my reference */
456 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
457
458 /* we should have three buffers now;
459 * one for the stream-start, one for an "invented" new segment,
460 * one for GDP caps, and one with our buffer */
461 fail_unless_equals_int (g_list_length (buffers), 4);
462
463 fail_unless (gst_element_set_state (gdppay,
464 GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
465
466 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
467 g_list_free (buffers);
468 buffers = NULL;
469 ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
470 cleanup_gdppay (gdppay);
471 }
472
473 GST_END_TEST;
474
GST_START_TEST(test_crc)475 GST_START_TEST (test_crc)
476 {
477 GstCaps *caps;
478 GstElement *gdppay;
479 GstBuffer *inbuffer, *outbuffer;
480 gint length;
481 GstMapInfo map;
482 guint16 crc_calculated, crc_read;
483
484 gdppay = setup_gdppay ();
485 g_object_set (gdppay, "crc-header", TRUE, NULL);
486
487 fail_unless (gst_element_set_state (gdppay,
488 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
489 "could not set to playing");
490
491 /* no buffer should be pushed yet, waiting for caps */
492 fail_unless_equals_int (g_list_length (buffers), 0);
493
494 GST_DEBUG ("first buffer");
495 inbuffer = gst_buffer_new_and_alloc (4);
496 gst_buffer_memset (inbuffer, 0, g_random_int () & 0xff, 4);
497 caps = gst_caps_from_string (AUDIO_CAPS_STRING);
498 gst_check_setup_events (mysrcpad, gdppay, caps, GST_FORMAT_TIME);
499
500 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
501
502 /* pushing gives away my reference */
503 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
504
505 /* we should have four buffers now */
506 fail_unless_equals_int (g_list_length (buffers), 4);
507
508 /* first buffer is the stream-start event */
509 check_stream_start_buffer (1);
510
511 /* second buffer is the serialized caps;
512 * the element also holds a ref to it */
513 check_caps_buffer (1, caps);
514
515 /* third buffer is the serialized new_segment event */
516 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
517 buffers = g_list_remove (buffers, outbuffer);
518 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
519
520 /* verify the header checksum */
521 /* CRC's start at 58 in the header */
522 outbuffer = gst_buffer_make_writable (outbuffer);
523 gst_buffer_map (outbuffer, &map, GST_MAP_READWRITE);
524 crc_calculated = gst_dp_crc (map.data, 58);
525 crc_read = GST_READ_UINT16_BE (map.data + 58);
526 fail_unless_equals_int (crc_calculated, crc_read);
527
528 /* change a byte in the header and verify that the checksum now fails */
529 map.data[0] = 0xff;
530 crc_calculated = gst_dp_crc (map.data, 58);
531 fail_if (crc_calculated == crc_read,
532 "Introducing a byte error in the header should make the checksum fail");
533
534 gst_buffer_unmap (outbuffer, &map);
535 gst_buffer_unref (outbuffer);
536
537 /* the fourth buffer is the GDP buffer for our pushed buffer */
538 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
539 buffers = g_list_remove (buffers, outbuffer);
540 ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
541 length = GST_DP_HEADER_LENGTH + 4;
542 fail_unless_equals_int (gst_buffer_get_size (outbuffer), length);
543 gst_buffer_unref (outbuffer);
544
545 fail_unless (gst_element_set_state (gdppay,
546 GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
547
548 gst_caps_unref (caps);
549 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
550 g_list_free (buffers);
551 buffers = NULL;
552 ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
553 cleanup_gdppay (gdppay);
554 }
555
556 GST_END_TEST;
557
558
559 static Suite *
gdppay_suite(void)560 gdppay_suite (void)
561 {
562 Suite *s = suite_create ("gdppay");
563 TCase *tc_chain = tcase_create ("general");
564
565 suite_add_tcase (s, tc_chain);
566 tcase_add_test (tc_chain, test_audio);
567 tcase_add_test (tc_chain, test_first_no_caps);
568 tcase_add_test (tc_chain, test_first_no_new_segment);
569 tcase_add_test (tc_chain, test_streamheader);
570 tcase_add_test (tc_chain, test_crc);
571
572 return s;
573 }
574
575 GST_CHECK_MAIN (gdppay);
576