1 /* GStreamer
2 *
3 * unit test for uvch264_demux
4 *
5 * Copyright (C) <2012> Collabora Ltd.
6 * Author: Youness Alaoui <youness.alaoui@collabora.co.uk>
7 * Copyright (C) <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Library General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Library General Public License for more details.
18 *
19 * You should have received a copy of the GNU Library General Public
20 * License along with this library; if not, write to the
21 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
23 */
24
25 #include <gst/check/gstcheck.h>
26 #include <string.h>
27
28 static GstElement *demux;
29 static GstPad *mjpg_pad, *h264_pad, *yuy2_pad, *nv12_pad, *jpg_pad;
30 static gboolean have_h264_eos, have_yuy2_eos, have_nv12_eos, have_jpg_eos;
31 static GstBuffer *buffer_h264, *buffer_yuy2, *buffer_nv12, *buffer_jpg;
32 static GstCaps *negotiated_caps_h264, *negotiated_caps_yuy2;
33 static GstCaps *negotiated_caps_nv12, *negotiated_caps_jpg;
34 static GError *gerror;
35 static gchar *error_debug;
36
37 static GstStaticPadTemplate mjpg_template =
38 GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
39 GST_STATIC_CAPS ("image/jpeg, width=640, height=480, framerate=15/1"));
40
41 static GstStaticPadTemplate sink_template =
42 GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
43 GST_STATIC_CAPS_ANY);
44
45 #define STRINGIFY_(x) #x
46 #define STRINGIFY(x) STRINGIFY_ (x)
47 #define DATADIR STRINGIFY (UVCH264DEMUX_DATADIR)
48 #define VALID_H264_JPG_MJPG_FILENAME DATADIR "/valid_h264_jpg.mjpg"
49 #define VALID_H264_JPG_JPG_FILENAME DATADIR "/valid_h264_jpg.jpg"
50 #define VALID_H264_JPG_H264_FILENAME DATADIR "/valid_h264_jpg.h264"
51 #define VALID_H264_YUY2_MJPG_FILENAME DATADIR "/valid_h264_yuy2.mjpg"
52 #define VALID_H264_YUY2_YUY2_FILENAME DATADIR "/valid_h264_yuy2.yuy2"
53 #define VALID_H264_YUY2_H264_FILENAME DATADIR "/valid_h264_yuy2.h264"
54
55 #define _sink_chain_func(type) \
56 static GstFlowReturn \
57 _sink_##type##_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) \
58 { \
59 fail_unless (negotiated_caps_##type != NULL); \
60 \
61 buffer_##type = buffer; \
62 \
63 return GST_FLOW_OK; \
64 }
65
66 #define _sink_event_func(type) \
67 static gboolean \
68 _sink_##type##_event (GstPad * pad, GstObject * parent, GstEvent * event) \
69 { \
70 if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) \
71 have_##type##_eos = TRUE; \
72 \
73 if (GST_EVENT_TYPE (event) == GST_EVENT_CAPS) { \
74 gst_event_parse_caps (event, &negotiated_caps_##type); \
75 gst_caps_ref (negotiated_caps_##type); \
76 } \
77 \
78 gst_event_unref (event); \
79 \
80 return TRUE; \
81 }
82
83
84 _sink_chain_func (h264);
85 _sink_chain_func (yuy2);
86 _sink_chain_func (nv12);
87 _sink_chain_func (jpg);
88
89 _sink_event_func (h264);
90 _sink_event_func (yuy2);
91 _sink_event_func (nv12);
92 _sink_event_func (jpg);
93
94
95 static GstBusSyncReply
_bus_sync_handler(GstBus * bus,GstMessage * message,gpointer data)96 _bus_sync_handler (GstBus * bus, GstMessage * message, gpointer data)
97 {
98 if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ERROR) {
99 fail_unless (gerror == NULL && error_debug == NULL);
100 fail_unless (GST_MESSAGE_SRC (message) == GST_OBJECT (demux));
101 gst_message_parse_error (message, &gerror, &error_debug);
102 }
103 return GST_BUS_PASS;
104 }
105
106 static void
_teardown_test(void)107 _teardown_test (void)
108 {
109 GstBus *bus;
110 gst_element_set_state (demux, GST_STATE_NULL);
111
112 bus = GST_ELEMENT_BUS (demux);
113 gst_bus_set_flushing (bus, TRUE);
114 gst_object_unref (bus);
115
116 gst_pad_set_active (mjpg_pad, FALSE);
117 gst_object_unref (mjpg_pad);
118 if (h264_pad) {
119 gst_pad_set_active (h264_pad, FALSE);
120 gst_object_unref (h264_pad);
121 }
122 if (yuy2_pad) {
123 gst_pad_set_active (yuy2_pad, FALSE);
124 gst_object_unref (yuy2_pad);
125 }
126 if (nv12_pad) {
127 gst_pad_set_active (nv12_pad, FALSE);
128 gst_object_unref (nv12_pad);
129 }
130 if (jpg_pad) {
131 gst_pad_set_active (jpg_pad, FALSE);
132 gst_object_unref (jpg_pad);
133 }
134 if (gerror) {
135 g_error_free (gerror);
136 gerror = NULL;
137 }
138 if (error_debug) {
139 g_free (error_debug);
140 error_debug = NULL;
141 }
142
143 gst_object_unref (demux);
144 mjpg_pad = h264_pad = yuy2_pad = nv12_pad = jpg_pad = NULL;
145 demux = NULL;
146
147 gst_caps_replace (&negotiated_caps_h264, NULL);
148 gst_caps_replace (&negotiated_caps_yuy2, NULL);
149 gst_caps_replace (&negotiated_caps_nv12, NULL);
150 gst_caps_replace (&negotiated_caps_jpg, NULL);
151 }
152
153 static void
_setup_test(gboolean link_h264,gboolean link_yuy2,gboolean link_nv12,gboolean link_jpg)154 _setup_test (gboolean link_h264, gboolean link_yuy2, gboolean link_nv12,
155 gboolean link_jpg)
156 {
157 GstCaps *caps;
158 GstPad *sinkpad, *h264pad, *yuy2pad, *nv12pad, *jpgpad;
159 GstBus *bus;
160
161 bus = gst_bus_new ();
162
163 have_h264_eos = have_yuy2_eos = have_nv12_eos = have_jpg_eos = FALSE;
164 buffer_h264 = buffer_yuy2 = buffer_nv12 = buffer_jpg = NULL;
165
166 demux = gst_element_factory_make ("uvch264mjpgdemux", NULL);
167 fail_unless (demux != NULL);
168
169 gst_element_set_bus (demux, bus);
170 gst_bus_set_sync_handler (bus, _bus_sync_handler, NULL, NULL);
171
172 mjpg_pad = gst_pad_new_from_static_template (&mjpg_template, "src");
173 fail_unless (mjpg_pad != NULL);
174 sinkpad = gst_element_get_static_pad (demux, "sink");
175 fail_unless (sinkpad != NULL);
176 fail_unless (gst_pad_link (mjpg_pad, sinkpad) == GST_PAD_LINK_OK);
177 gst_object_unref (sinkpad);
178
179 gst_pad_set_active (mjpg_pad, TRUE);
180
181 if (link_h264) {
182 h264pad = gst_element_get_static_pad (demux, "h264");
183 fail_unless (h264pad != NULL);
184
185 h264_pad = gst_pad_new_from_static_template (&sink_template, "h264");
186 fail_unless (h264_pad != NULL);
187 gst_pad_set_chain_function (h264_pad, _sink_h264_chain);
188 gst_pad_set_event_function (h264_pad, _sink_h264_event);
189
190 fail_unless (gst_pad_link (h264pad, h264_pad) == GST_PAD_LINK_OK);
191 gst_object_unref (h264pad);
192
193 gst_pad_set_active (h264_pad, TRUE);
194 }
195 if (link_yuy2) {
196 yuy2pad = gst_element_get_static_pad (demux, "yuy2");
197 fail_unless (yuy2pad != NULL);
198
199 yuy2_pad = gst_pad_new_from_static_template (&sink_template, "yuy2");
200 fail_unless (yuy2_pad != NULL);
201 gst_pad_set_chain_function (yuy2_pad, _sink_yuy2_chain);
202 gst_pad_set_event_function (yuy2_pad, _sink_yuy2_event);
203
204 fail_unless (gst_pad_link (yuy2pad, yuy2_pad) == GST_PAD_LINK_OK);
205 gst_object_unref (yuy2pad);
206
207 gst_pad_set_active (yuy2_pad, TRUE);
208 }
209 if (link_nv12) {
210 nv12pad = gst_element_get_static_pad (demux, "nv12");
211 fail_unless (nv12pad != NULL);
212
213 nv12_pad = gst_pad_new_from_static_template (&sink_template, "nv12");
214 fail_unless (nv12_pad != NULL);
215 gst_pad_set_chain_function (nv12_pad, _sink_nv12_chain);
216 gst_pad_set_event_function (nv12_pad, _sink_nv12_event);
217
218 fail_unless (gst_pad_link (nv12pad, nv12_pad) == GST_PAD_LINK_OK);
219 gst_object_unref (nv12pad);
220 gst_pad_set_active (nv12_pad, TRUE);
221 }
222 if (link_jpg) {
223 jpgpad = gst_element_get_static_pad (demux, "jpeg");
224 fail_unless (jpgpad != NULL);
225
226 jpg_pad = gst_pad_new_from_static_template (&sink_template, "jpeg");
227 fail_unless (jpg_pad != NULL);
228 gst_pad_set_chain_function (jpg_pad, _sink_jpg_chain);
229 gst_pad_set_event_function (jpg_pad, _sink_jpg_event);
230
231 fail_unless (gst_pad_link (jpgpad, jpg_pad) == GST_PAD_LINK_OK);
232 gst_object_unref (jpgpad);
233
234 gst_pad_set_active (jpg_pad, TRUE);
235 }
236
237 gst_element_set_state (demux, GST_STATE_PLAYING);
238
239 caps = gst_static_pad_template_get_caps (&mjpg_template);
240 gst_check_setup_events_with_stream_id (mjpg_pad, demux, caps,
241 GST_FORMAT_TIME, "uvch264demux-test");
242 gst_caps_unref (caps);
243 }
244
245 static GstBuffer *
_buffer_from_file(const gchar * filename)246 _buffer_from_file (const gchar * filename)
247 {
248 GstBuffer *buffer;
249 gchar *contents = NULL;
250 gsize length = 0;
251
252 fail_unless (g_file_get_contents (filename, &contents, &length, NULL));
253
254 buffer = gst_buffer_new_wrapped (contents, length);
255 GST_BUFFER_OFFSET (buffer) = 0;
256
257 return buffer;
258 }
259
GST_START_TEST(test_valid_h264_jpg)260 GST_START_TEST (test_valid_h264_jpg)
261 {
262 GstCaps *mjpg_caps = gst_static_pad_template_get_caps (&mjpg_template);
263 GstCaps *h264_caps;
264 GstBuffer *buffer;
265 gchar *h264_data, *jpg_data;
266 gsize h264_size, jpg_size;
267
268 _setup_test (TRUE, TRUE, TRUE, TRUE);
269
270 h264_caps = gst_caps_new_simple ("video/x-h264",
271 "width", G_TYPE_INT, 640, "height", G_TYPE_INT, 480,
272 "framerate", GST_TYPE_FRACTION, 15, 1, NULL);
273 buffer = _buffer_from_file (VALID_H264_JPG_MJPG_FILENAME);
274
275 fail_unless (g_file_get_contents (VALID_H264_JPG_H264_FILENAME,
276 &h264_data, &h264_size, NULL));
277 fail_unless (g_file_get_contents (VALID_H264_JPG_JPG_FILENAME,
278 &jpg_data, &jpg_size, NULL));
279
280 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
281 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
282
283 fail_unless (have_h264_eos);
284 fail_unless (have_yuy2_eos);
285 fail_unless (have_nv12_eos);
286 fail_unless (have_jpg_eos);
287 fail_unless (buffer_h264 != NULL);
288 fail_unless (buffer_jpg != NULL);
289 fail_unless (buffer_nv12 == NULL);
290 fail_unless (buffer_yuy2 == NULL);
291 fail_unless (gerror == NULL && error_debug == NULL);
292 fail_unless (gst_caps_is_always_compatible (negotiated_caps_h264, h264_caps));
293 fail_unless (gst_caps_is_always_compatible (negotiated_caps_jpg, mjpg_caps));
294 fail_unless (gst_buffer_get_size (buffer_h264) == h264_size);
295 fail_unless (gst_buffer_get_size (buffer_jpg) == jpg_size);
296 fail_unless (gst_buffer_memcmp (buffer_h264, 0, h264_data, h264_size) == 0);
297 fail_unless (gst_buffer_memcmp (buffer_jpg, 0, jpg_data, jpg_size) == 0);
298
299 gst_caps_unref (mjpg_caps);
300 gst_caps_unref (h264_caps);
301 g_free (h264_data);
302 g_free (jpg_data);
303 gst_buffer_unref (buffer_h264);
304 gst_buffer_unref (buffer_jpg);
305 _teardown_test ();
306 }
307
308 GST_END_TEST;
309
GST_START_TEST(test_valid_h264_yuy2)310 GST_START_TEST (test_valid_h264_yuy2)
311 {
312 GstCaps *h264_caps;
313 GstCaps *yuy2_caps;
314 GstBuffer *buffer;
315 gchar *h264_data, *yuy2_data;
316 gsize h264_size, yuy2_size;
317
318 _setup_test (TRUE, TRUE, TRUE, TRUE);
319
320 h264_caps = gst_caps_new_simple ("video/x-h264",
321 "width", G_TYPE_INT, 640, "height", G_TYPE_INT, 480,
322 "framerate", GST_TYPE_FRACTION, 15, 1, NULL);
323 yuy2_caps = gst_caps_new_simple ("video/x-raw",
324 "format", G_TYPE_STRING, "YUY2",
325 "width", G_TYPE_INT, 160, "height", G_TYPE_INT, 90,
326 "framerate", GST_TYPE_FRACTION, 15, 1, NULL);
327 buffer = _buffer_from_file (VALID_H264_YUY2_MJPG_FILENAME);
328 fail_unless (g_file_get_contents (VALID_H264_YUY2_H264_FILENAME,
329 &h264_data, &h264_size, NULL));
330 fail_unless (g_file_get_contents (VALID_H264_YUY2_YUY2_FILENAME,
331 &yuy2_data, &yuy2_size, NULL));
332
333 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
334 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
335
336 fail_unless (have_h264_eos);
337 fail_unless (have_yuy2_eos);
338 fail_unless (have_nv12_eos);
339 fail_unless (have_jpg_eos);
340 fail_unless (buffer_h264 != NULL);
341 fail_unless (buffer_jpg == NULL);
342 fail_unless (buffer_nv12 == NULL);
343 fail_unless (buffer_yuy2 != NULL);
344 fail_unless (gerror == NULL && error_debug == NULL);
345 fail_unless (gst_caps_is_always_compatible (negotiated_caps_h264, h264_caps));
346 fail_unless (gst_caps_is_always_compatible (negotiated_caps_yuy2, yuy2_caps));
347 fail_unless (gst_buffer_get_size (buffer_h264) == h264_size);
348 fail_unless (gst_buffer_get_size (buffer_yuy2) == yuy2_size);
349 fail_unless (gst_buffer_memcmp (buffer_h264, 0, h264_data, h264_size) == 0);
350 fail_unless (gst_buffer_memcmp (buffer_yuy2, 0, yuy2_data, yuy2_size) == 0);
351
352 gst_caps_unref (yuy2_caps);
353 gst_caps_unref (h264_caps);
354 g_free (h264_data);
355 g_free (yuy2_data);
356 gst_buffer_unref (buffer_h264);
357 gst_buffer_unref (buffer_yuy2);
358 _teardown_test ();
359 }
360
361 GST_END_TEST;
362
GST_START_TEST(test_no_data)363 GST_START_TEST (test_no_data)
364 {
365 GstBuffer *buffer = gst_buffer_new ();
366
367 _setup_test (TRUE, TRUE, TRUE, TRUE);
368
369 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
370 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
371
372 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
373 fail_unless (buffer_h264 == NULL && buffer_jpg != NULL);
374 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
375 fail_unless (gerror == NULL && error_debug == NULL);
376 gst_buffer_unref (buffer_jpg);
377
378 _teardown_test ();
379 }
380
381 GST_END_TEST;
382
GST_START_TEST(test_data_zero)383 GST_START_TEST (test_data_zero)
384 {
385 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
386
387 _setup_test (TRUE, TRUE, TRUE, TRUE);
388
389 gst_buffer_memset (buffer, 0, 0, 1024);
390 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
391 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
392
393 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
394 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
395 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
396
397 _teardown_test ();
398 }
399
400 GST_END_TEST;
401
GST_START_TEST(test_no_marker_size)402 GST_START_TEST (test_no_marker_size)
403 {
404 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
405 const guchar data[] = {
406 0xff, 0xd8, 0xff, 0xe4, 0x00
407 };
408
409 _setup_test (TRUE, TRUE, TRUE, TRUE);
410
411 gst_buffer_fill (buffer, 0, data, sizeof (data));
412 gst_buffer_set_size (buffer, sizeof (data));
413 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_ERROR);
414 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
415
416 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
417 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
418 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
419 fail_unless (gerror != NULL);
420 fail_unless (gerror->domain == GST_STREAM_ERROR);
421 fail_unless (gerror->code == GST_STREAM_ERROR_DEMUX);
422 fail_unless (memcmp (gerror->message,
423 "Not enough data to read marker size",
424 strlen (gerror->message)) == 0);
425
426 _teardown_test ();
427 }
428
429 GST_END_TEST;
430
GST_START_TEST(test_not_enough_data)431 GST_START_TEST (test_not_enough_data)
432 {
433 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
434 const guchar data[] = {
435 0xff, 0xd8, 0xff, 0xe4, 0x00, 0xff, 0x00, 0x00
436 };
437
438 _setup_test (TRUE, TRUE, TRUE, TRUE);
439
440 gst_buffer_fill (buffer, 0, data, sizeof (data));
441 gst_buffer_set_size (buffer, sizeof (data));
442 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_ERROR);
443 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
444
445 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
446 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
447 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
448 fail_unless (gerror != NULL);
449 fail_unless (gerror->domain == GST_STREAM_ERROR);
450 fail_unless (gerror->code == GST_STREAM_ERROR_DEMUX);
451 fail_unless (memcmp (gerror->message,
452 "Not enough data to read marker content",
453 strlen (gerror->message)) == 0);
454
455 _teardown_test ();
456 }
457
458 GST_END_TEST;
459
GST_START_TEST(test_no_aux_header)460 GST_START_TEST (test_no_aux_header)
461 {
462 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
463 const guchar data[] = {
464 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x02, 0x00, 0x00,
465 0xff, 0xd9
466 };
467
468 _setup_test (TRUE, TRUE, TRUE, TRUE);
469
470 gst_buffer_fill (buffer, 0, data, sizeof (data));
471 gst_buffer_set_size (buffer, sizeof (data));
472 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_ERROR);
473 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
474
475 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
476 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
477 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
478 fail_unless (gerror != NULL);
479 fail_unless (gerror->domain == GST_STREAM_ERROR);
480 fail_unless (gerror->code == GST_STREAM_ERROR_DEMUX);
481 fail_unless (memcmp (gerror->message,
482 "Not enough data to read aux header", strlen (gerror->message)) == 0);
483
484 _teardown_test ();
485 }
486
487 GST_END_TEST;
488
GST_START_TEST(test_empty_aux_data)489 GST_START_TEST (test_empty_aux_data)
490 {
491 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
492 const guchar data[] = {
493 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x1C, 0x00, 0x01,
494 0x16, 0x00, 0x48, 0x32, 0x36, 0x34, 0x80, 0x07,
495 0x38, 0x04, 0x2a, 0x2c, 0x0a, 0x00, 0x1b, 0x00,
496 0x40, 0x62, 0xcb, 0x0a, 0x00, 0x00, 0x00, 0x00,
497 0xff, 0xd9
498 };
499
500 _setup_test (TRUE, TRUE, TRUE, TRUE);
501
502 gst_buffer_fill (buffer, 0, data, sizeof (data));
503 gst_buffer_set_size (buffer, sizeof (data));
504 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
505 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
506
507 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
508 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
509 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
510 fail_unless (gerror == NULL);
511
512 _teardown_test ();
513 }
514
515 GST_END_TEST;
516
GST_START_TEST(test_unknown_fcc)517 GST_START_TEST (test_unknown_fcc)
518 {
519 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
520 const guchar data[] = {
521 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x2C, 0x00, 0x01,
522 0x16, 0x00, 0x48, 0x30, 0x30, 0x30, 0x80, 0x07,
523 0x38, 0x04, 0x2a, 0x2c, 0x0a, 0x00, 0x1b, 0x00,
524 0x40, 0x62, 0xcb, 0x0a, 0x10, 0x00, 0x00, 0x00,
525 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
526 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
527 0xff, 0xd9
528 };
529
530 _setup_test (TRUE, TRUE, TRUE, TRUE);
531
532 gst_buffer_fill (buffer, 0, data, sizeof (data));
533 gst_buffer_set_size (buffer, sizeof (data));
534 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_ERROR);
535 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
536
537 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
538 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
539 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
540 fail_unless (gerror != NULL);
541 fail_unless (gerror->domain == GST_STREAM_ERROR);
542 fail_unless (gerror->code == GST_STREAM_ERROR_DEMUX);
543 fail_unless (memcmp (gerror->message,
544 "Unknown auxiliary stream format : H000",
545 strlen (gerror->message)) == 0);
546
547 _teardown_test ();
548 }
549
550 GST_END_TEST;
551
GST_START_TEST(test_not_enough_aux_data)552 GST_START_TEST (test_not_enough_aux_data)
553 {
554 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
555 const guchar data[] = {
556 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x1C, 0x00, 0x01,
557 0x16, 0x00, 0x48, 0x32, 0x36, 0x34, 0x80, 0x07,
558 0x38, 0x04, 0x2a, 0x2c, 0x0a, 0x00, 0x1b, 0x00,
559 0x40, 0x62, 0xcb, 0x0a, 0x10, 0x00, 0x00, 0x00,
560 0xff, 0xd9
561 };
562
563 _setup_test (TRUE, TRUE, TRUE, TRUE);
564
565 gst_buffer_fill (buffer, 0, data, sizeof (data));
566 gst_buffer_set_size (buffer, sizeof (data));
567 /* It's actually silently ignored */
568 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
569 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
570
571 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
572 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
573 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
574
575 _teardown_test ();
576 }
577
578 GST_END_TEST;
579
GST_START_TEST(test_too_much_aux_data)580 GST_START_TEST (test_too_much_aux_data)
581 {
582 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
583 const guchar data[] = {
584 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x3C, 0x00, 0x01,
585 0x16, 0x00, 0x48, 0x32, 0x36, 0x34, 0x80, 0x07,
586 0x38, 0x04, 0x2a, 0x2c, 0x0a, 0x00, 0x1b, 0x00,
587 0x40, 0x62, 0xcb, 0x0a, 0x10, 0x00, 0x00, 0x00,
588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
589 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
590 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
591 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
592 0xff, 0xd9
593 };
594
595 _setup_test (TRUE, TRUE, TRUE, TRUE);
596
597 gst_buffer_fill (buffer, 0, data, sizeof (data));
598 gst_buffer_set_size (buffer, sizeof (data));
599 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_ERROR);
600 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
601
602 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
603 fail_unless (buffer_h264 == NULL && buffer_jpg == NULL);
604 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
605 fail_unless (gerror != NULL);
606 fail_unless (gerror->domain == GST_STREAM_ERROR);
607 fail_unless (gerror->code == GST_STREAM_ERROR_DEMUX);
608 fail_unless (memcmp (gerror->message,
609 "Expected 16 auxiliary data, got 32 bytes",
610 strlen (gerror->message)) == 0);
611
612 _teardown_test ();
613 }
614
615 GST_END_TEST;
616
617
GST_START_TEST(test_no_sos_marker)618 GST_START_TEST (test_no_sos_marker)
619 {
620 GstBuffer *buffer = gst_buffer_new_and_alloc (1024);
621 const guchar data[] = {
622 0xff, 0xd8, 0xff, 0xe4, 0x00, 0x2C, 0x00, 0x01,
623 0x16, 0x00, 0x48, 0x32, 0x36, 0x34, 0x80, 0x07,
624 0x38, 0x04, 0x2a, 0x2c, 0x0a, 0x00, 0x1b, 0x00,
625 0x40, 0x62, 0xcb, 0x0a, 0x10, 0x00, 0x00, 0x00,
626 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
627 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
628 0xff, 0xd9
629 };
630 const guchar h264_data[] = {
631 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
632 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
633 };
634
635 _setup_test (TRUE, TRUE, TRUE, TRUE);
636
637 gst_buffer_fill (buffer, 0, data, sizeof (data));
638 gst_buffer_set_size (buffer, sizeof (data));
639 fail_unless (gst_pad_push (mjpg_pad, buffer) == GST_FLOW_OK);
640 fail_unless (gst_pad_push_event (mjpg_pad, gst_event_new_eos ()));
641
642 fail_unless (have_h264_eos && have_yuy2_eos && have_nv12_eos && have_jpg_eos);
643 fail_unless (buffer_h264 != NULL && buffer_jpg == NULL);
644 fail_unless (buffer_nv12 == NULL && buffer_yuy2 == NULL);
645 fail_unless (gerror == NULL);
646 fail_unless (gst_buffer_get_size (buffer_h264) == sizeof (h264_data));
647 fail_if (gst_buffer_memcmp (buffer_h264, 0, h264_data, sizeof (h264_data)));
648 gst_buffer_unref (buffer_h264);
649
650 _teardown_test ();
651 }
652
653 GST_END_TEST;
654
655 static Suite *
uvch264demux_suite(void)656 uvch264demux_suite (void)
657 {
658 Suite *s = suite_create ("uvch264demux");
659 TCase *tc_chain = tcase_create ("general");
660
661 suite_add_tcase (s, tc_chain);
662 tcase_set_timeout (tc_chain, 180);
663 tcase_add_test (tc_chain, test_valid_h264_jpg);
664 tcase_add_test (tc_chain, test_valid_h264_yuy2);
665 tcase_add_test (tc_chain, test_no_data);
666 tcase_add_test (tc_chain, test_data_zero);
667 tcase_add_test (tc_chain, test_no_marker_size);
668 tcase_add_test (tc_chain, test_not_enough_data);
669 tcase_add_test (tc_chain, test_no_aux_header);
670 tcase_add_test (tc_chain, test_empty_aux_data);
671 tcase_add_test (tc_chain, test_unknown_fcc);
672 tcase_add_test (tc_chain, test_no_sos_marker);
673 tcase_add_test (tc_chain, test_not_enough_aux_data);
674 tcase_add_test (tc_chain, test_too_much_aux_data);
675
676 return s;
677 }
678
679 GST_CHECK_MAIN (uvch264demux);
680