5 * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
25 #include <gst/base/gstbasetransform.h>
26 #include <gst/check/gstcheck.h>
27 #include <gst/interfaces/streamvolume.h>
28 #include <gst/controller/gstinterpolationcontrolsource.h>
30 /* For ease of programming we use globals to keep refs for our floating
31 * src and sink pads we create; otherwise we always have to do get_pad,
32 * get_peer, and then remove references in every test function */
33 static GstPad *mysrcpad, *mysinkpad;
35 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
36 #define FORMATS1 "{ S8, S16LE, S24LE, S32LE, F32LE, F64LE }"
38 #define FORMATS3 "S16LE"
39 #define FORMATS4 "S24LE"
40 #define FORMATS5 "S32LE"
41 #define FORMATS6 "F32LE"
42 #define FORMATS7 "F64LE"
43 #define FORMATS8 "U16LE"
45 #define FORMATS1 "{ S8, S16BE, S24BE, S32BE, F32BE, F64BE }"
47 #define FORMATS3 "S16BE"
48 #define FORMATS4 "S24BE"
49 #define FORMATS5 "S32BE"
50 #define FORMATS6 "F32BE"
51 #define FORMATS7 "F64BE"
52 #define FORMATS8 "U16BE"
55 #define VOLUME_CAPS_TEMPLATE_STRING \
57 "format = (string) "FORMATS1", " \
58 "channels = (int) [ 1, MAX ], " \
59 "rate = (int) [ 1, MAX ]"
61 #define VOLUME_CAPS_STRING_S8 \
63 "formats = (string) "FORMATS2", " \
64 "channels = (int) 1, " \
67 #define VOLUME_CAPS_STRING_S16 \
69 "formats = (string) "FORMATS3", " \
70 "channels = (int) 1, " \
73 #define VOLUME_CAPS_STRING_S24 \
75 "formats = (string) "FORMATS4", " \
76 "channels = (int) 1, " \
79 #define VOLUME_CAPS_STRING_S32 \
81 "formats = (string) "FORMATS5", " \
82 "channels = (int) 1, " \
85 #define VOLUME_CAPS_STRING_F32 \
87 "formats = (string) "FORMATS6", " \
88 "channels = (int) 1, " \
91 #define VOLUME_CAPS_STRING_F64 \
93 "formats = (string) "FORMATS7", " \
94 "channels = (int) 1, " \
97 #define VOLUME_WRONG_CAPS_STRING \
99 "formats = (string) "FORMATS8", " \
100 "channels = (int) 1, " \
104 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
107 GST_STATIC_CAPS (VOLUME_CAPS_TEMPLATE_STRING)
109 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
112 GST_STATIC_CAPS (VOLUME_CAPS_TEMPLATE_STRING)
120 GST_DEBUG ("setup_volume");
121 volume = gst_check_setup_element ("volume");
122 mysrcpad = gst_check_setup_src_pad (volume, &srctemplate, NULL);
123 mysinkpad = gst_check_setup_sink_pad (volume, &sinktemplate, NULL);
124 gst_pad_set_active (mysrcpad, TRUE);
125 gst_pad_set_active (mysinkpad, TRUE);
131 cleanup_volume (GstElement * volume)
133 GST_DEBUG ("cleanup_volume");
135 g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
136 g_list_free (buffers);
139 gst_pad_set_active (mysrcpad, FALSE);
140 gst_pad_set_active (mysinkpad, FALSE);
141 gst_check_teardown_src_pad (volume);
142 gst_check_teardown_sink_pad (volume);
143 gst_check_teardown_element (volume);
146 GST_START_TEST (test_get_set)
148 GstElement *volume = gst_element_factory_make ("volume", NULL);
151 fail_unless (volume != NULL);
152 g_object_get (G_OBJECT (volume), "volume", &val, NULL);
153 fail_unless (val == 1.0);
154 fail_unless (val == gst_stream_volume_get_volume (GST_STREAM_VOLUME (volume),
155 GST_STREAM_VOLUME_FORMAT_LINEAR));
157 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
158 g_object_get (G_OBJECT (volume), "volume", &val, NULL);
159 fail_unless (val == 0.5);
160 fail_unless (val == gst_stream_volume_get_volume (GST_STREAM_VOLUME (volume),
161 GST_STREAM_VOLUME_FORMAT_LINEAR));
163 gst_stream_volume_set_volume (GST_STREAM_VOLUME (volume),
164 GST_STREAM_VOLUME_FORMAT_LINEAR, 1.0);
165 g_object_get (G_OBJECT (volume), "volume", &val, NULL);
166 fail_unless (val == 1.0);
167 fail_unless (val == gst_stream_volume_get_volume (GST_STREAM_VOLUME (volume),
168 GST_STREAM_VOLUME_FORMAT_LINEAR));
170 gst_object_unref (volume);
175 GST_START_TEST (test_unity_s8)
178 GstBuffer *inbuffer, *outbuffer;
180 gint8 in[2] = { 64, -16 };
184 volume = setup_volume ();
185 fail_unless (gst_element_set_state (volume,
186 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
187 "could not set to playing");
189 inbuffer = gst_buffer_new_and_alloc (2);
190 gst_buffer_fill (inbuffer, 0, in, 2);
191 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
192 gst_buffer_set_caps (inbuffer, caps);
193 gst_caps_unref (caps);
194 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
196 /* pushing gives away my reference ... */
197 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
198 /* ... but it ends up being collected on the global buffer list */
199 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
200 fail_unless_equals_int (g_list_length (buffers), 1);
201 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
202 fail_unless (inbuffer == outbuffer);
203 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
204 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in[0], in[1], res[0], res[1]);
205 fail_unless (memcmp (res, in, 2) == 0);
206 gst_buffer_unmap (outbuffer, res, size);
209 cleanup_volume (volume);
214 GST_START_TEST (test_half_s8)
218 GstBuffer *outbuffer;
220 gint8 in[2] = { 64, -16 };
221 gint8 out[2] = { 32, -8 };
225 volume = setup_volume ();
226 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
227 fail_unless (gst_element_set_state (volume,
228 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
229 "could not set to playing");
231 inbuffer = gst_buffer_new_and_alloc (2);
232 gst_buffer_fill (inbuffer, 0, in, 2);
233 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
234 gst_buffer_set_caps (inbuffer, caps);
235 gst_caps_unref (caps);
236 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
237 /* FIXME: reffing the inbuffer should make the transformation not be
239 gst_buffer_ref (inbuffer);
242 /* pushing gives away my reference ... */
243 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
244 /* ... but it ends up being modified inplace and
245 * collected on the global buffer list */
246 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
247 fail_unless_equals_int (g_list_length (buffers), 1);
248 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
249 fail_unless (inbuffer == outbuffer);
250 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
251 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
253 fail_unless (memcmp (res, out, 2) == 0);
254 gst_buffer_unmap (outbuffer, res, size);
257 cleanup_volume (volume);
262 GST_START_TEST (test_double_s8)
266 GstBuffer *outbuffer;
268 gint8 in[2] = { 64, -16 };
269 gint8 out[2] = { 127, -32 }; /* notice the clamped sample */
273 volume = setup_volume ();
274 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
275 fail_unless (gst_element_set_state (volume,
276 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
277 "could not set to playing");
279 inbuffer = gst_buffer_new_and_alloc (2);
280 gst_buffer_fill (inbuffer, 0, in, 2);
281 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
282 gst_buffer_set_caps (inbuffer, caps);
283 gst_caps_unref (caps);
284 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
285 /* FIXME: reffing the inbuffer should make the transformation not be
287 gst_buffer_ref (inbuffer);
290 /* pushing gives away my reference ... */
291 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
292 /* ... but it ends up being modified inplace and
293 * collected on the global buffer list */
294 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
295 fail_unless_equals_int (g_list_length (buffers), 1);
296 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
297 fail_unless (inbuffer == outbuffer);
298 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
299 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
301 fail_unless (memcmp (res, out, 2) == 0);
302 gst_buffer_unmap (outbuffer, res, size);
305 cleanup_volume (volume);
310 GST_START_TEST (test_ten_s8)
314 GstBuffer *outbuffer;
316 gint8 in[2] = { 64, -10 };
317 gint8 out[2] = { 127, -100 }; /* notice the clamped sample */
320 volume = setup_volume ();
321 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
322 fail_unless (gst_element_set_state (volume,
323 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
324 "could not set to playing");
326 inbuffer = gst_buffer_new_and_alloc (2);
327 memcpy (GST_BUFFER_DATA (inbuffer), in, 2);
328 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 2) == 0);
329 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
330 gst_buffer_set_caps (inbuffer, caps);
331 gst_caps_unref (caps);
332 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
333 /* FIXME: reffing the inbuffer should make the transformation not be
335 gst_buffer_ref (inbuffer);
338 /* pushing gives away my reference ... */
339 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
340 /* ... but it ends up being modified inplace and
341 * collected on the global buffer list */
342 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
343 fail_unless_equals_int (g_list_length (buffers), 1);
344 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
345 fail_unless (inbuffer == outbuffer);
346 res = (gint8 *) GST_BUFFER_DATA (outbuffer);
347 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
349 fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 2) == 0);
352 cleanup_volume (volume);
357 GST_START_TEST (test_mute_s8)
361 GstBuffer *outbuffer;
363 gint8 in[2] = { 64, -16 };
364 gint8 out[2] = { 0, 0 };
368 volume = setup_volume ();
369 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
370 fail_unless (gst_element_set_state (volume,
371 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
372 "could not set to playing");
374 inbuffer = gst_buffer_new_and_alloc (2);
375 gst_buffer_fill (inbuffer, 0, in, 2);
376 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S8);
377 gst_buffer_set_caps (inbuffer, caps);
378 gst_caps_unref (caps);
379 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
380 /* FIXME: reffing the inbuffer should make the transformation not be
382 gst_buffer_ref (inbuffer);
385 /* pushing gives away my reference ... */
386 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
387 /* ... but it ends up being modified inplace and
388 * collected on the global buffer list */
389 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
390 fail_unless_equals_int (g_list_length (buffers), 1);
391 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
392 fail_unless (inbuffer == outbuffer);
393 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
394 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
396 fail_unless (memcmp (res, out, 2) == 0);
397 gst_buffer_unmap (outbuffer, res, size);
400 cleanup_volume (volume);
405 GST_START_TEST (test_unity_s16)
408 GstBuffer *inbuffer, *outbuffer;
410 gint16 in[2] = { 16384, -256 };
414 volume = setup_volume ();
415 fail_unless (gst_element_set_state (volume,
416 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
417 "could not set to playing");
419 inbuffer = gst_buffer_new_and_alloc (4);
420 gst_buffer_fill (inbuffer, 0, in, 4);
421 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
422 gst_buffer_set_caps (inbuffer, caps);
423 gst_caps_unref (caps);
424 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
426 /* pushing gives away my reference ... */
427 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
428 /* ... but it ends up being collected on the global buffer list */
429 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
430 fail_unless_equals_int (g_list_length (buffers), 1);
431 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
432 fail_unless (inbuffer == outbuffer);
433 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
434 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in[0], in[1], res[0], res[1]);
435 fail_unless (memcmp (res, in, 4) == 0);
436 gst_buffer_unmap (outbuffer, res, size);
439 cleanup_volume (volume);
444 GST_START_TEST (test_half_s16)
448 GstBuffer *outbuffer;
450 gint16 in[2] = { 16384, -256 };
451 gint16 out[2] = { 8192, -128 };
455 volume = setup_volume ();
456 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
457 fail_unless (gst_element_set_state (volume,
458 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
459 "could not set to playing");
461 inbuffer = gst_buffer_new_and_alloc (4);
462 gst_buffer_fill (inbuffer, 0, in, 4);
463 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
464 gst_buffer_set_caps (inbuffer, caps);
465 gst_caps_unref (caps);
466 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
467 /* FIXME: reffing the inbuffer should make the transformation not be
469 gst_buffer_ref (inbuffer);
472 /* pushing gives away my reference ... */
473 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
474 /* ... but it ends up being modified inplace and
475 * collected on the global buffer list */
476 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
477 fail_unless_equals_int (g_list_length (buffers), 1);
478 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
479 fail_unless (inbuffer == outbuffer);
480 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
481 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
483 fail_unless (memcmp (res, out, 4) == 0);
484 gst_buffer_unmap (outbuffer, res, size);
487 cleanup_volume (volume);
492 GST_START_TEST (test_double_s16)
496 GstBuffer *outbuffer;
498 gint16 in[2] = { 16384, -256 };
499 gint16 out[2] = { 32767, -512 }; /* notice the clamped sample */
503 volume = setup_volume ();
504 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
505 fail_unless (gst_element_set_state (volume,
506 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
507 "could not set to playing");
509 inbuffer = gst_buffer_new_and_alloc (4);
510 gst_buffer_fill (inbuffer, 0, in, 4);
511 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
512 gst_buffer_set_caps (inbuffer, caps);
513 gst_caps_unref (caps);
514 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
515 /* FIXME: reffing the inbuffer should make the transformation not be
517 gst_buffer_ref (inbuffer);
520 /* pushing gives away my reference ... */
521 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
522 /* ... but it ends up being modified inplace and
523 * collected on the global buffer list */
524 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
525 fail_unless_equals_int (g_list_length (buffers), 1);
526 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
527 fail_unless (inbuffer == outbuffer);
528 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
529 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
531 fail_unless (memcmp (res, out, 4) == 0);
532 gst_buffer_unmap (outbuffer, res, size);
535 cleanup_volume (volume);
540 GST_START_TEST (test_ten_s16)
544 GstBuffer *outbuffer;
546 gint16 in[2] = { 16384, -10 };
547 gint16 out[2] = { 32767, -100 }; /* notice the clamped sample */
550 volume = setup_volume ();
551 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
552 fail_unless (gst_element_set_state (volume,
553 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
554 "could not set to playing");
556 inbuffer = gst_buffer_new_and_alloc (4);
557 memcpy (GST_BUFFER_DATA (inbuffer), in, 4);
558 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 4) == 0);
559 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
560 gst_buffer_set_caps (inbuffer, caps);
561 gst_caps_unref (caps);
562 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
563 /* FIXME: reffing the inbuffer should make the transformation not be
565 gst_buffer_ref (inbuffer);
568 /* pushing gives away my reference ... */
569 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
570 /* ... but it ends up being modified inplace and
571 * collected on the global buffer list */
572 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
573 fail_unless_equals_int (g_list_length (buffers), 1);
574 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
575 fail_unless (inbuffer == outbuffer);
576 res = (gint16 *) GST_BUFFER_DATA (outbuffer);
577 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
579 fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 4) == 0);
582 cleanup_volume (volume);
588 GST_START_TEST (test_mute_s16)
592 GstBuffer *outbuffer;
594 gint16 in[2] = { 16384, -256 };
595 gint16 out[2] = { 0, 0 };
599 volume = setup_volume ();
600 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
601 fail_unless (gst_element_set_state (volume,
602 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
603 "could not set to playing");
605 inbuffer = gst_buffer_new_and_alloc (4);
606 gst_buffer_fill (inbuffer, 0, in, 4);
607 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
608 gst_buffer_set_caps (inbuffer, caps);
609 gst_caps_unref (caps);
610 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
611 /* FIXME: reffing the inbuffer should make the transformation not be
613 gst_buffer_ref (inbuffer);
616 /* pushing gives away my reference ... */
617 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
618 /* ... but it ends up being modified inplace and
619 * collected on the global buffer list */
620 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
621 fail_unless_equals_int (g_list_length (buffers), 1);
622 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
623 fail_unless (inbuffer == outbuffer);
624 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
625 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
627 fail_unless (memcmp (res, out, 4) == 0);
628 gst_buffer_unmap (outbuffer, res, size);
631 cleanup_volume (volume);
636 #if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
637 #define get_unaligned_i24(_x) ( (((guint8*)_x)[0]) | ((((guint8*)_x)[1]) << 8) | ((((gint8*)_x)[2]) << 16) )
638 #define write_unaligned_u24(_x,samp) do { (((guint8*)_x)[0]) = samp & 0xFF; (((guint8*)_x)[1]) = (samp >> 8) & 0xFF; (((guint8*)_x)[2]) = (samp >> 16) & 0xFF; } while (0)
639 #else /* BIG ENDIAN */
640 #define get_unaligned_i24(_x) ( (((guint8*)_x)[2]) | ((((guint8*)_x)[1]) << 8) | ((((gint8*)_x)[0]) << 16) )
641 #define write_unaligned_u24(_x,samp) do { (((guint8*)_x)[0]) = (samp >> 16) & 0xFF; (((guint8*)_x)[1]) = (samp >> 8) & 0xFF; (((guint8*)_x)[2]) = samp & 0xFF; } while (0)
644 GST_START_TEST (test_unity_s24)
647 GstBuffer *inbuffer, *outbuffer;
649 gint32 in_32[2] = { 4194304, -4096 };
655 write_unaligned_u24 (in, in_32[0]);
656 write_unaligned_u24 (in + 3, in_32[1]);
658 volume = setup_volume ();
659 fail_unless (gst_element_set_state (volume,
660 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
661 "could not set to playing");
663 inbuffer = gst_buffer_new_and_alloc (6);
664 gst_buffer_fill (inbuffer, 0, in, 6);
665 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
666 gst_buffer_set_caps (inbuffer, caps);
667 gst_caps_unref (caps);
668 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
670 /* pushing gives away my reference ... */
671 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
672 /* ... but it ends up being collected on the global buffer list */
673 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
674 fail_unless_equals_int (g_list_length (buffers), 1);
675 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
676 fail_unless (inbuffer == outbuffer);
677 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
679 res_32[0] = get_unaligned_i24 (res);
680 res_32[1] = get_unaligned_i24 ((res + 3));
682 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in_32[0], in_32[1], res_32[0],
684 fail_unless (memcmp (res, in, 6) == 0);
685 gst_buffer_unmap (outbuffer, res, size);
688 cleanup_volume (volume);
693 GST_START_TEST (test_half_s24)
697 GstBuffer *outbuffer;
699 gint32 in_32[2] = { 4194304, -4096 };
703 gint32 out_32[2] = { 2097152, -2048 };
706 write_unaligned_u24 (in, in_32[0]);
707 write_unaligned_u24 (in + 3, in_32[1]);
709 volume = setup_volume ();
710 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
711 fail_unless (gst_element_set_state (volume,
712 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
713 "could not set to playing");
715 inbuffer = gst_buffer_new_and_alloc (6);
716 gst_buffer_fill (inbuffer, 0, in, 6);
717 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
718 gst_buffer_set_caps (inbuffer, caps);
719 gst_caps_unref (caps);
720 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
721 /* FIXME: reffing the inbuffer should make the transformation not be
723 gst_buffer_ref (inbuffer);
726 /* pushing gives away my reference ... */
727 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
728 /* ... but it ends up being modified inplace and
729 * collected on the global buffer list */
730 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
731 fail_unless_equals_int (g_list_length (buffers), 1);
732 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
733 fail_unless (inbuffer == outbuffer);
734 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
736 res_32[0] = get_unaligned_i24 (res);
737 res_32[1] = get_unaligned_i24 ((res + 3));
739 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out_32[0], out_32[1],
740 res_32[0], res_32[1]);
741 fail_unless (memcmp (res_32, out_32, 8) == 0);
742 gst_buffer_unmap (outbuffer, res, size);
745 cleanup_volume (volume);
750 GST_START_TEST (test_double_s24)
754 GstBuffer *outbuffer;
756 gint32 in_32[2] = { 4194304, -4096 };
760 gint32 out_32[2] = { 8388607, -8192 }; /* notice the clamped sample */
763 write_unaligned_u24 (in, in_32[0]);
764 write_unaligned_u24 (in + 3, in_32[1]);
766 volume = setup_volume ();
767 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
768 fail_unless (gst_element_set_state (volume,
769 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
770 "could not set to playing");
772 inbuffer = gst_buffer_new_and_alloc (6);
773 gst_buffer_fill (inbuffer, 0, in, 6);
774 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
775 gst_buffer_set_caps (inbuffer, caps);
776 gst_caps_unref (caps);
777 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
778 /* FIXME: reffing the inbuffer should make the transformation not be
780 gst_buffer_ref (inbuffer);
783 /* pushing gives away my reference ... */
784 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
785 /* ... but it ends up being modified inplace and
786 * collected on the global buffer list */
787 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
788 fail_unless_equals_int (g_list_length (buffers), 1);
789 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
790 fail_unless (inbuffer == outbuffer);
791 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
793 res_32[0] = get_unaligned_i24 (res);
794 res_32[1] = get_unaligned_i24 ((res + 3));
796 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out_32[0], out_32[1],
797 res_32[0], res_32[1]);
798 fail_unless (memcmp (res_32, out_32, 8) == 0);
799 gst_buffer_unmap (outbuffer, res, size);
802 cleanup_volume (volume);
807 GST_START_TEST (test_ten_s24)
811 GstBuffer *outbuffer;
813 gint32 in_32[2] = { 4194304, -10 };
817 gint32 out_32[2] = { 8388607, -100 }; /* notice the clamped sample */
819 write_unaligned_u24 (in, in_32[0]);
820 write_unaligned_u24 (in + 3, in_32[1]);
822 volume = setup_volume ();
823 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
824 fail_unless (gst_element_set_state (volume,
825 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
826 "could not set to playing");
828 inbuffer = gst_buffer_new_and_alloc (6);
829 memcpy (GST_BUFFER_DATA (inbuffer), in, 6);
830 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 6) == 0);
831 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
832 gst_buffer_set_caps (inbuffer, caps);
833 gst_caps_unref (caps);
834 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
835 /* FIXME: reffing the inbuffer should make the transformation not be
837 gst_buffer_ref (inbuffer);
840 /* pushing gives away my reference ... */
841 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
842 /* ... but it ends up being modified inplace and
843 * collected on the global buffer list */
844 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
845 fail_unless_equals_int (g_list_length (buffers), 1);
846 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
847 fail_unless (inbuffer == outbuffer);
848 res = GST_BUFFER_DATA (outbuffer);
850 res_32[0] = get_unaligned_i24 (res);
851 res_32[1] = get_unaligned_i24 ((res + 3));
853 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out_32[0], out_32[1],
854 res_32[0], res_32[1]);
855 fail_unless (memcmp (res_32, out_32, 8) == 0);
858 cleanup_volume (volume);
863 GST_START_TEST (test_mute_s24)
867 GstBuffer *outbuffer;
869 gint32 in_32[2] = { 4194304, -4096 };
873 gint32 out_32[2] = { 0, 0 }; /* notice the clamped sample */
876 write_unaligned_u24 (in, in_32[0]);
877 write_unaligned_u24 (in + 3, in_32[1]);
879 volume = setup_volume ();
880 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
881 fail_unless (gst_element_set_state (volume,
882 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
883 "could not set to playing");
885 inbuffer = gst_buffer_new_and_alloc (6);
886 gst_buffer_fill (inbuffer, 0, in, 6);
887 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S24);
888 gst_buffer_set_caps (inbuffer, caps);
889 gst_caps_unref (caps);
890 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
891 /* FIXME: reffing the inbuffer should make the transformation not be
893 gst_buffer_ref (inbuffer);
896 /* pushing gives away my reference ... */
897 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
898 /* ... but it ends up being modified inplace and
899 * collected on the global buffer list */
900 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
901 fail_unless_equals_int (g_list_length (buffers), 1);
902 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
903 fail_unless (inbuffer == outbuffer);
905 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
907 res_32[0] = get_unaligned_i24 (res);
908 res_32[1] = get_unaligned_i24 ((res + 3));
910 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out_32[0], out_32[1],
911 res_32[0], res_32[1]);
912 fail_unless (memcmp (res_32, out_32, 8) == 0);
913 gst_buffer_unmap (outbuffer, res, size);
916 cleanup_volume (volume);
921 GST_START_TEST (test_unity_s32)
924 GstBuffer *inbuffer, *outbuffer;
926 gint32 in[2] = { 1073741824, -65536 };
930 volume = setup_volume ();
931 fail_unless (gst_element_set_state (volume,
932 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
933 "could not set to playing");
935 inbuffer = gst_buffer_new_and_alloc (8);
936 gst_buffer_fill (inbuffer, 0, in, 8);
937 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
938 gst_buffer_set_caps (inbuffer, caps);
939 gst_caps_unref (caps);
940 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
942 /* pushing gives away my reference ... */
943 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
944 /* ... but it ends up being collected on the global buffer list */
945 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
946 fail_unless_equals_int (g_list_length (buffers), 1);
947 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
948 fail_unless (inbuffer == outbuffer);
949 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
950 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in[0], in[1], res[0], res[1]);
951 fail_unless (memcmp (res, in, 8) == 0);
952 gst_buffer_unmap (outbuffer, res, size);
955 cleanup_volume (volume);
960 GST_START_TEST (test_half_s32)
964 GstBuffer *outbuffer;
966 gint32 in[2] = { 1073741824, -65536 };
967 gint32 out[2] = { 536870912, -32768 };
971 volume = setup_volume ();
972 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
973 fail_unless (gst_element_set_state (volume,
974 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
975 "could not set to playing");
977 inbuffer = gst_buffer_new_and_alloc (8);
978 gst_buffer_fill (inbuffer, 0, in, 8);
979 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
980 gst_buffer_set_caps (inbuffer, caps);
981 gst_caps_unref (caps);
982 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
983 /* FIXME: reffing the inbuffer should make the transformation not be
985 gst_buffer_ref (inbuffer);
988 /* pushing gives away my reference ... */
989 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
990 /* ... but it ends up being modified inplace and
991 * collected on the global buffer list */
992 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
993 fail_unless_equals_int (g_list_length (buffers), 1);
994 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
995 fail_unless (inbuffer == outbuffer);
996 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
997 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
999 fail_unless (memcmp (res, out, 8) == 0);
1000 gst_buffer_unmap (outbuffer, res, size);
1003 cleanup_volume (volume);
1008 GST_START_TEST (test_double_s32)
1011 GstBuffer *inbuffer;
1012 GstBuffer *outbuffer;
1014 gint32 in[2] = { 1073741824, -65536 };
1015 gint32 out[2] = { 2147483647, -131072 }; /* notice the clamped sample */
1019 volume = setup_volume ();
1020 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
1021 fail_unless (gst_element_set_state (volume,
1022 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1023 "could not set to playing");
1025 inbuffer = gst_buffer_new_and_alloc (8);
1026 gst_buffer_fill (inbuffer, 0, in, 8);
1027 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
1028 gst_buffer_set_caps (inbuffer, caps);
1029 gst_caps_unref (caps);
1030 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1031 /* FIXME: reffing the inbuffer should make the transformation not be
1033 gst_buffer_ref (inbuffer);
1036 /* pushing gives away my reference ... */
1037 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1038 /* ... but it ends up being modified inplace and
1039 * collected on the global buffer list */
1040 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1041 fail_unless_equals_int (g_list_length (buffers), 1);
1042 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1043 fail_unless (inbuffer == outbuffer);
1044 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1045 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
1047 fail_unless (memcmp (res, out, 8) == 0);
1048 gst_buffer_unmap (outbuffer, res, size);
1051 cleanup_volume (volume);
1056 GST_START_TEST (test_ten_s32)
1059 GstBuffer *inbuffer;
1060 GstBuffer *outbuffer;
1062 gint32 in[2] = { 1073741824, -10 };
1063 gint32 out[2] = { 2147483647, -100 }; /* notice the clamped sample */
1066 volume = setup_volume ();
1067 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
1068 fail_unless (gst_element_set_state (volume,
1069 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1070 "could not set to playing");
1072 inbuffer = gst_buffer_new_and_alloc (8);
1073 memcpy (GST_BUFFER_DATA (inbuffer), in, 8);
1074 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 8) == 0);
1075 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
1076 gst_buffer_set_caps (inbuffer, caps);
1077 gst_caps_unref (caps);
1078 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1079 /* FIXME: reffing the inbuffer should make the transformation not be
1081 gst_buffer_ref (inbuffer);
1084 /* pushing gives away my reference ... */
1085 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1086 /* ... but it ends up being modified inplace and
1087 * collected on the global buffer list */
1088 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1089 fail_unless_equals_int (g_list_length (buffers), 1);
1090 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1091 fail_unless (inbuffer == outbuffer);
1092 res = (gint32 *) GST_BUFFER_DATA (outbuffer);
1093 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
1095 fail_unless (memcmp (GST_BUFFER_DATA (outbuffer), out, 8) == 0);
1098 cleanup_volume (volume);
1103 GST_START_TEST (test_mute_s32)
1106 GstBuffer *inbuffer;
1107 GstBuffer *outbuffer;
1109 gint32 in[2] = { 1073741824, -65536 };
1110 gint32 out[2] = { 0, 0 };
1114 volume = setup_volume ();
1115 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
1116 fail_unless (gst_element_set_state (volume,
1117 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1118 "could not set to playing");
1120 inbuffer = gst_buffer_new_and_alloc (8);
1121 gst_buffer_fill (inbuffer, 0, in, 8);
1122 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S32);
1123 gst_buffer_set_caps (inbuffer, caps);
1124 gst_caps_unref (caps);
1125 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1126 /* FIXME: reffing the inbuffer should make the transformation not be
1128 gst_buffer_ref (inbuffer);
1131 /* pushing gives away my reference ... */
1132 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1133 /* ... but it ends up being modified inplace and
1134 * collected on the global buffer list */
1135 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1136 fail_unless_equals_int (g_list_length (buffers), 1);
1137 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1138 fail_unless (inbuffer == outbuffer);
1139 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1140 GST_INFO ("expected %+5d %+5d real %+5d %+5d", out[0], out[1], res[0],
1142 fail_unless (memcmp (res, out, 8) == 0);
1143 gst_buffer_unmap (outbuffer, res, size);
1146 cleanup_volume (volume);
1151 GST_START_TEST (test_unity_f32)
1154 GstBuffer *inbuffer, *outbuffer;
1156 gfloat in[2] = { 0.75, -0.25 };
1160 volume = setup_volume ();
1161 fail_unless (gst_element_set_state (volume,
1162 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1163 "could not set to playing");
1165 inbuffer = gst_buffer_new_and_alloc (8);
1166 gst_buffer_fill (inbuffer, 0, in, 8);
1167 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
1168 gst_buffer_set_caps (inbuffer, caps);
1169 gst_caps_unref (caps);
1170 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1172 /* pushing gives away my reference ... */
1173 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1174 /* ... but it ends up being collected on the global buffer list */
1175 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1176 fail_unless_equals_int (g_list_length (buffers), 1);
1177 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1178 fail_unless (inbuffer == outbuffer);
1179 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1180 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", in[0], in[1], res[0],
1182 fail_unless_equals_float (res[0], in[0]);
1183 fail_unless_equals_float (res[1], in[1]);
1186 cleanup_volume (volume);
1191 GST_START_TEST (test_half_f32)
1194 GstBuffer *inbuffer;
1195 GstBuffer *outbuffer;
1197 gfloat in[2] = { 0.75, -0.25 };
1198 gfloat out[2] = { 0.375, -0.125 };
1202 volume = setup_volume ();
1203 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
1204 fail_unless (gst_element_set_state (volume,
1205 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1206 "could not set to playing");
1208 inbuffer = gst_buffer_new_and_alloc (8);
1209 gst_buffer_fill (inbuffer, 0, in, 8);
1210 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
1211 gst_buffer_set_caps (inbuffer, caps);
1212 gst_caps_unref (caps);
1213 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1214 /* FIXME: reffing the inbuffer should make the transformation not be
1216 gst_buffer_ref (inbuffer);
1219 /* pushing gives away my reference ... */
1220 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1221 /* ... but it ends up being modified inplace and
1222 * collected on the global buffer list */
1223 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1224 fail_unless_equals_int (g_list_length (buffers), 1);
1225 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1226 fail_unless (inbuffer == outbuffer);
1227 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1228 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1230 fail_unless_equals_float (res[0], out[0]);
1231 fail_unless_equals_float (res[1], out[1]);
1232 gst_buffer_unmap (outbuffer, res, size);
1235 cleanup_volume (volume);
1240 GST_START_TEST (test_double_f32)
1243 GstBuffer *inbuffer;
1244 GstBuffer *outbuffer;
1246 gfloat in[2] = { 0.75, -0.25 };
1247 gfloat out[2] = { 1.5, -0.5 }; /* nothing is clamped */
1251 volume = setup_volume ();
1252 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
1253 fail_unless (gst_element_set_state (volume,
1254 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1255 "could not set to playing");
1257 inbuffer = gst_buffer_new_and_alloc (8);
1258 gst_buffer_fill (inbuffer, 0, in, 8);
1259 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
1260 gst_buffer_set_caps (inbuffer, caps);
1261 gst_caps_unref (caps);
1262 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1263 /* FIXME: reffing the inbuffer should make the transformation not be
1265 gst_buffer_ref (inbuffer);
1268 /* pushing gives away my reference ... */
1269 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1270 /* ... but it ends up being modified inplace and
1271 * collected on the global buffer list */
1272 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1273 fail_unless_equals_int (g_list_length (buffers), 1);
1274 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1275 fail_unless (inbuffer == outbuffer);
1276 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1277 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1279 fail_unless_equals_float (res[0], out[0]);
1280 fail_unless_equals_float (res[1], out[1]);
1281 gst_buffer_unmap (outbuffer, res, size);
1284 cleanup_volume (volume);
1289 GST_START_TEST (test_ten_f32)
1292 GstBuffer *inbuffer;
1293 GstBuffer *outbuffer;
1295 gfloat in[2] = { 0.75, -0.25 };
1296 gfloat out[2] = { 7.5, -2.5 }; /* nothing is clamped */
1299 volume = setup_volume ();
1300 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
1301 fail_unless (gst_element_set_state (volume,
1302 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1303 "could not set to playing");
1305 inbuffer = gst_buffer_new_and_alloc (8);
1306 memcpy (GST_BUFFER_DATA (inbuffer), in, 8);
1307 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 8) == 0);
1308 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
1309 gst_buffer_set_caps (inbuffer, caps);
1310 gst_caps_unref (caps);
1311 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1312 /* FIXME: reffing the inbuffer should make the transformation not be
1314 gst_buffer_ref (inbuffer);
1317 /* pushing gives away my reference ... */
1318 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1319 /* ... but it ends up being modified inplace and
1320 * collected on the global buffer list */
1321 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1322 fail_unless_equals_int (g_list_length (buffers), 1);
1323 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1324 fail_unless (inbuffer == outbuffer);
1325 res = (gfloat *) GST_BUFFER_DATA (outbuffer);
1326 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1328 fail_unless_equals_float (res[0], out[0]);
1329 fail_unless_equals_float (res[1], out[1]);
1332 cleanup_volume (volume);
1338 GST_START_TEST (test_mute_f32)
1341 GstBuffer *inbuffer;
1342 GstBuffer *outbuffer;
1344 gfloat in[2] = { 0.75, -0.25 };
1345 gfloat out[2] = { 0, 0 };
1349 volume = setup_volume ();
1350 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
1351 fail_unless (gst_element_set_state (volume,
1352 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1353 "could not set to playing");
1355 inbuffer = gst_buffer_new_and_alloc (8);
1356 gst_buffer_fill (inbuffer, 0, in, 8);
1357 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F32);
1358 gst_buffer_set_caps (inbuffer, caps);
1359 gst_caps_unref (caps);
1360 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1361 /* FIXME: reffing the inbuffer should make the transformation not be
1363 gst_buffer_ref (inbuffer);
1366 /* pushing gives away my reference ... */
1367 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1368 /* ... but it ends up being modified inplace and
1369 * collected on the global buffer list */
1370 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1371 fail_unless_equals_int (g_list_length (buffers), 1);
1372 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1373 fail_unless (inbuffer == outbuffer);
1374 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1375 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1377 fail_unless_equals_float (res[0], out[0]);
1378 fail_unless_equals_float (res[1], out[1]);
1379 gst_buffer_unmap (outbuffer, res, size);
1382 cleanup_volume (volume);
1387 GST_START_TEST (test_unity_f64)
1390 GstBuffer *inbuffer, *outbuffer;
1392 gdouble in[2] = { 0.75, -0.25 };
1396 volume = setup_volume ();
1397 fail_unless (gst_element_set_state (volume,
1398 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1399 "could not set to playing");
1401 inbuffer = gst_buffer_new_and_alloc (16);
1402 gst_buffer_fill (inbuffer, 0, in, 16);
1403 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
1404 gst_buffer_set_caps (inbuffer, caps);
1405 gst_caps_unref (caps);
1406 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1408 /* pushing gives away my reference ... */
1409 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1410 /* ... but it ends up being collected on the global buffer list */
1411 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1412 fail_unless_equals_int (g_list_length (buffers), 1);
1413 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1414 fail_unless (inbuffer == outbuffer);
1415 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1416 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", in[0], in[1], res[0],
1418 fail_unless_equals_float (res[0], in[0]);
1419 fail_unless_equals_float (res[1], in[1]);
1422 cleanup_volume (volume);
1427 GST_START_TEST (test_half_f64)
1430 GstBuffer *inbuffer;
1431 GstBuffer *outbuffer;
1433 gdouble in[2] = { 0.75, -0.25 };
1434 gdouble out[2] = { 0.375, -0.125 };
1438 volume = setup_volume ();
1439 g_object_set (G_OBJECT (volume), "volume", 0.5, NULL);
1440 fail_unless (gst_element_set_state (volume,
1441 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1442 "could not set to playing");
1444 inbuffer = gst_buffer_new_and_alloc (16);
1445 gst_buffer_fill (inbuffer, 0, in, 16);
1446 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
1447 gst_buffer_set_caps (inbuffer, caps);
1448 gst_caps_unref (caps);
1449 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1450 /* FIXME: reffing the inbuffer should make the transformation not be
1452 gst_buffer_ref (inbuffer);
1455 /* pushing gives away my reference ... */
1456 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1457 /* ... but it ends up being modified inplace and
1458 * collected on the global buffer list */
1459 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1460 fail_unless_equals_int (g_list_length (buffers), 1);
1461 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1462 fail_unless (inbuffer == outbuffer);
1463 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1464 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1466 fail_unless_equals_float (res[0], out[0]);
1467 fail_unless_equals_float (res[1], out[1]);
1468 gst_buffer_unmap (outbuffer, res, size);
1471 cleanup_volume (volume);
1476 GST_START_TEST (test_double_f64)
1479 GstBuffer *inbuffer;
1480 GstBuffer *outbuffer;
1482 gdouble in[2] = { 0.75, -0.25 };
1483 gdouble out[2] = { 1.5, -0.5 }; /* nothing is clamped */
1487 volume = setup_volume ();
1488 g_object_set (G_OBJECT (volume), "volume", 2.0, NULL);
1489 fail_unless (gst_element_set_state (volume,
1490 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1491 "could not set to playing");
1493 inbuffer = gst_buffer_new_and_alloc (16);
1494 gst_buffer_fill (inbuffer, 0, in, 16);
1495 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
1496 gst_buffer_set_caps (inbuffer, caps);
1497 gst_caps_unref (caps);
1498 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1499 /* FIXME: reffing the inbuffer should make the transformation not be
1501 gst_buffer_ref (inbuffer);
1504 /* pushing gives away my reference ... */
1505 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1506 /* ... but it ends up being modified inplace and
1507 * collected on the global buffer list */
1508 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1509 fail_unless_equals_int (g_list_length (buffers), 1);
1510 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1511 fail_unless (inbuffer == outbuffer);
1512 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1513 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1515 fail_unless_equals_float (res[0], out[0]);
1516 fail_unless_equals_float (res[1], out[1]);
1517 gst_buffer_unmap (outbuffer, res, size);
1520 cleanup_volume (volume);
1525 GST_START_TEST (test_ten_f64)
1528 GstBuffer *inbuffer;
1529 GstBuffer *outbuffer;
1531 gdouble in[2] = { 0.75, -0.25 };
1532 gdouble out[2] = { 7.5, -2.5 }; /* nothing is clamped */
1535 volume = setup_volume ();
1536 g_object_set (G_OBJECT (volume), "volume", 10.0, NULL);
1537 fail_unless (gst_element_set_state (volume,
1538 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1539 "could not set to playing");
1541 inbuffer = gst_buffer_new_and_alloc (16);
1542 memcpy (GST_BUFFER_DATA (inbuffer), in, 16);
1543 fail_unless (memcmp (GST_BUFFER_DATA (inbuffer), in, 16) == 0);
1544 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
1545 gst_buffer_set_caps (inbuffer, caps);
1546 gst_caps_unref (caps);
1547 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1548 /* FIXME: reffing the inbuffer should make the transformation not be
1550 gst_buffer_ref (inbuffer);
1553 /* pushing gives away my reference ... */
1554 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1555 /* ... but it ends up being modified inplace and
1556 * collected on the global buffer list */
1557 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1558 fail_unless_equals_int (g_list_length (buffers), 1);
1559 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1560 fail_unless (inbuffer == outbuffer);
1561 res = (gdouble *) GST_BUFFER_DATA (outbuffer);
1562 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1564 fail_unless_equals_float (res[0], out[0]);
1565 fail_unless_equals_float (res[1], out[1]);
1568 cleanup_volume (volume);
1574 GST_START_TEST (test_mute_f64)
1577 GstBuffer *inbuffer;
1578 GstBuffer *outbuffer;
1580 gdouble in[2] = { 0.75, -0.25 };
1581 gdouble out[2] = { 0, 0 };
1585 volume = setup_volume ();
1586 g_object_set (G_OBJECT (volume), "mute", TRUE, NULL);
1587 fail_unless (gst_element_set_state (volume,
1588 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1589 "could not set to playing");
1591 inbuffer = gst_buffer_new_and_alloc (16);
1592 gst_buffer_fill (inbuffer, 0, in, 16);
1593 caps = gst_caps_from_string (VOLUME_CAPS_STRING_F64);
1594 gst_buffer_set_caps (inbuffer, caps);
1595 gst_caps_unref (caps);
1596 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1597 /* FIXME: reffing the inbuffer should make the transformation not be
1599 gst_buffer_ref (inbuffer);
1602 /* pushing gives away my reference ... */
1603 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1604 /* ... but it ends up being modified inplace and
1605 * collected on the global buffer list */
1606 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1607 fail_unless_equals_int (g_list_length (buffers), 1);
1608 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1609 fail_unless (inbuffer == outbuffer);
1610 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1611 GST_INFO ("expected %+1.4f %+1.4f real %+1.4f %+1.4f", out[0], out[1],
1613 fail_unless_equals_float (res[0], out[0]);
1614 fail_unless_equals_float (res[1], out[1]);
1615 gst_buffer_unmap (outbuffer, res, size);
1618 cleanup_volume (volume);
1623 GST_START_TEST (test_wrong_caps)
1626 GstBuffer *inbuffer;
1627 gint16 in[2] = { 16384, -256 };
1629 GstMessage *message;
1632 volume = setup_volume ();
1633 bus = gst_bus_new ();
1635 fail_unless (gst_element_set_state (volume,
1636 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1637 "could not set to playing");
1639 inbuffer = gst_buffer_new_and_alloc (4);
1640 gst_buffer_fill (inbuffer, 0, in, 4);
1641 caps = gst_caps_from_string (VOLUME_WRONG_CAPS_STRING);
1642 gst_buffer_set_caps (inbuffer, caps);
1643 gst_caps_unref (caps);
1644 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1645 gst_buffer_ref (inbuffer);
1647 /* set a bus here so we avoid getting state change messages */
1648 gst_element_set_bus (volume, bus);
1650 /* pushing gives an error because it can't negotiate with wrong caps */
1651 fail_unless_equals_int (gst_pad_push (mysrcpad, inbuffer),
1652 GST_FLOW_NOT_NEGOTIATED);
1653 /* ... and the buffer would have been lost if we didn't ref it ourselves */
1654 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1655 gst_buffer_unref (inbuffer);
1656 fail_unless_equals_int (g_list_length (buffers), 0);
1658 /* volume_set_caps should not have been called since basetransform caught
1659 * the negotiation problem */
1660 fail_if ((message = gst_bus_pop (bus)) != NULL);
1663 gst_element_set_bus (volume, NULL);
1664 gst_object_unref (GST_OBJECT (bus));
1665 cleanup_volume (volume);
1670 GST_START_TEST (test_passthrough)
1673 GstBuffer *inbuffer, *outbuffer;
1675 gint16 in[2] = { 16384, -256 };
1679 volume = setup_volume ();
1680 g_object_set (G_OBJECT (volume), "volume", 1.0, NULL);
1681 fail_unless (gst_element_set_state (volume,
1682 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1683 "could not set to playing");
1685 inbuffer = gst_buffer_new_and_alloc (4);
1686 gst_buffer_fill (inbuffer, 0, in, 4);
1687 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
1688 gst_buffer_set_caps (inbuffer, caps);
1689 gst_caps_unref (caps);
1690 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1692 /* pushing gives away my reference ... */
1693 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1694 /* ... but it ends up being collected on the global buffer list */
1695 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1696 fail_unless_equals_int (g_list_length (buffers), 1);
1697 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1698 fail_unless (inbuffer == outbuffer);
1699 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1700 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in[0], in[1], res[0], res[1]);
1701 fail_unless (memcmp (res, in, 4) == 0);
1702 gst_buffer_unmap (outbuffer, res, size);
1705 cleanup_volume (volume);
1710 GST_START_TEST (test_controller_usability)
1712 GstInterpolationControlSource *csource;
1715 GValue value = { 0, };
1717 /* note: the volume element should init the controller library for us */
1718 volume = setup_volume ();
1720 c = gst_controller_new (G_OBJECT (volume), "volume", NULL);
1722 fail_unless (GST_IS_CONTROLLER (c));
1724 /* this shouldn't crash, whether this mode is implemented or not */
1725 csource = gst_interpolation_control_source_new ();
1726 gst_interpolation_control_source_set_interpolation_mode (csource,
1727 GST_INTERPOLATE_CUBIC);
1728 gst_controller_set_control_source (c, "volume", GST_CONTROL_SOURCE (csource));
1729 g_object_unref (csource);
1731 g_value_init (&value, G_TYPE_DOUBLE);
1732 g_value_set_double (&value, 0.0);
1733 gst_interpolation_control_source_set (csource, 0 * GST_SECOND, &value);
1734 g_value_set_double (&value, 1.0);
1735 gst_interpolation_control_source_set (csource, 5 * GST_SECOND, &value);
1736 g_value_set_double (&value, 0.0);
1737 gst_interpolation_control_source_set (csource, 10 * GST_SECOND, &value);
1738 g_value_unset (&value);
1742 cleanup_volume (volume);
1747 GST_START_TEST (test_controller_processing)
1749 GstInterpolationControlSource *csource;
1752 GstBuffer *inbuffer, *outbuffer;
1754 gint16 in[2] = { 16384, -256 };
1758 volume = setup_volume ();
1760 c = gst_controller_new (G_OBJECT (volume), "volume", NULL);
1762 fail_unless (GST_IS_CONTROLLER (c));
1764 csource = gst_interpolation_control_source_new ();
1765 gst_interpolation_control_source_set_interpolation_mode (csource,
1766 GST_INTERPOLATE_CUBIC);
1767 gst_controller_set_control_source (c, "volume", GST_CONTROL_SOURCE (csource));
1768 g_object_unref (csource);
1770 fail_unless (gst_element_set_state (volume,
1771 GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
1772 "could not set to playing");
1774 inbuffer = gst_buffer_new_and_alloc (4);
1775 gst_buffer_fill (inbuffer, 0, in, 4);
1776 caps = gst_caps_from_string (VOLUME_CAPS_STRING_S16);
1777 gst_buffer_set_caps (inbuffer, caps);
1778 GST_BUFFER_TIMESTAMP (inbuffer) = 0;
1779 gst_caps_unref (caps);
1780 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1782 /* pushing gives away my reference ... */
1783 fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
1784 /* ... but it ends up being collected on the global buffer list */
1785 ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
1786 fail_unless_equals_int (g_list_length (buffers), 1);
1787 fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
1788 fail_unless (inbuffer == outbuffer);
1789 res = gst_buffer_map (outbuffer, &size, NULL, GST_MAP_READ);
1790 GST_INFO ("expected %+5d %+5d real %+5d %+5d", in[0], in[1], res[0], res[1]);
1791 fail_unless (memcmp (res, in, 4) == 0);
1792 gst_buffer_unmap (outbuffer, res, size);
1796 cleanup_volume (volume);
1804 Suite *s = suite_create ("volume");
1805 TCase *tc_chain = tcase_create ("general");
1807 suite_add_tcase (s, tc_chain);
1808 tcase_add_test (tc_chain, test_get_set);
1809 tcase_add_test (tc_chain, test_unity_s8);
1810 tcase_add_test (tc_chain, test_half_s8);
1811 tcase_add_test (tc_chain, test_double_s8);
1812 tcase_add_test (tc_chain, test_ten_s8);
1813 tcase_add_test (tc_chain, test_mute_s8);
1814 tcase_add_test (tc_chain, test_unity_s16);
1815 tcase_add_test (tc_chain, test_half_s16);
1816 tcase_add_test (tc_chain, test_double_s16);
1817 tcase_add_test (tc_chain, test_ten_s16);
1818 tcase_add_test (tc_chain, test_mute_s16);
1819 tcase_add_test (tc_chain, test_unity_s24);
1820 tcase_add_test (tc_chain, test_half_s24);
1821 tcase_add_test (tc_chain, test_double_s24);
1822 tcase_add_test (tc_chain, test_ten_s24);
1823 tcase_add_test (tc_chain, test_mute_s24);
1824 tcase_add_test (tc_chain, test_unity_s32);
1825 tcase_add_test (tc_chain, test_half_s32);
1826 tcase_add_test (tc_chain, test_double_s32);
1827 tcase_add_test (tc_chain, test_ten_s32);
1828 tcase_add_test (tc_chain, test_mute_s32);
1829 tcase_add_test (tc_chain, test_unity_f32);
1830 tcase_add_test (tc_chain, test_half_f32);
1831 tcase_add_test (tc_chain, test_double_f32);
1832 tcase_add_test (tc_chain, test_ten_f32);
1833 tcase_add_test (tc_chain, test_mute_f32);
1834 tcase_add_test (tc_chain, test_unity_f64);
1835 tcase_add_test (tc_chain, test_half_f64);
1836 tcase_add_test (tc_chain, test_double_f64);
1837 tcase_add_test (tc_chain, test_ten_f64);
1838 tcase_add_test (tc_chain, test_mute_f64);
1839 tcase_add_test (tc_chain, test_wrong_caps);
1840 tcase_add_test (tc_chain, test_passthrough);
1841 tcase_add_test (tc_chain, test_controller_usability);
1842 tcase_add_test (tc_chain, test_controller_processing);
1847 GST_CHECK_MAIN (volume)