tests/check/elements/audiocheblimit.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>
   4  *
   5  * audiocheblimit.c: Unit test for the audiocheblimit element
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public License
   9  * as published by the Free Software Foundation; either version 2.1 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include <gst/gst.h>
  24 #include <gst/base/gstbasetransform.h>
  25 #include <gst/check/gstcheck.h>
  26
  27 #include <math.h>
  28
  29 /* For ease of programming we use globals to keep refs for our floating
  30  * src and sink pads we create; otherwise we always have to do get_pad,
  31  * get_peer, and then remove references in every test function */
  32 GstPad *mysrcpad, *mysinkpad;
  33
  34 #define BUFFER_CAPS_STRING_32           \
  35     "audio/x-raw-float, "               \
  36     "channels = (int) 1, "              \
  37     "rate = (int) 44100, "              \
  38     "endianness = (int) BYTE_ORDER, "   \
  39     "width = (int) 32"                  \
  40
  41 #define BUFFER_CAPS_STRING_64           \
  42     "audio/x-raw-float, "               \
  43     "channels = (int) 1, "              \
  44     "rate = (int) 44100, "              \
  45     "endianness = (int) BYTE_ORDER, "   \
  46     "width = (int) 64"                  \
  47
  48 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  49     GST_PAD_SINK,
  50     GST_PAD_ALWAYS,
  51     GST_STATIC_CAPS ("audio/x-raw-float, "
  52         "channels = (int) 1, "
  53         "rate = (int) 44100, "
  54         "endianness = (int) BYTE_ORDER, " "width = (int) { 32, 64 }")
  55     );
  56 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  57     GST_PAD_SRC,
  58     GST_PAD_ALWAYS,
  59     GST_STATIC_CAPS ("audio/x-raw-float, "
  60         "channels = (int) 1, "
  61         "rate = (int) 44100, "
  62         "endianness = (int) BYTE_ORDER, " "width = (int) { 32, 64 }")
  63     );
  64
  65 static GstElement *
  66 setup_audiocheblimit (void)
  67 {
  68   GstElement *audiocheblimit;
  69
  70   GST_DEBUG ("setup_audiocheblimit");
  71   audiocheblimit = gst_check_setup_element ("audiocheblimit");
  72   mysrcpad = gst_check_setup_src_pad (audiocheblimit, &srctemplate, NULL);
  73   mysinkpad = gst_check_setup_sink_pad (audiocheblimit, &sinktemplate, NULL);
  74   gst_pad_set_active (mysrcpad, TRUE);
  75   gst_pad_set_active (mysinkpad, TRUE);
  76
  77   return audiocheblimit;
  78 }
  79
  80 static void
  81 cleanup_audiocheblimit (GstElement * audiocheblimit)
  82 {
  83   GST_DEBUG ("cleanup_audiocheblimit");
  84
  85   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
  86   g_list_free (buffers);
  87   buffers = NULL;
  88
  89   gst_pad_set_active (mysrcpad, FALSE);
  90   gst_pad_set_active (mysinkpad, FALSE);
  91   gst_check_teardown_src_pad (audiocheblimit);
  92   gst_check_teardown_sink_pad (audiocheblimit);
  93   gst_check_teardown_element (audiocheblimit);
  94 }
  95
  96 /* Test if data containing only one frequency component
  97  * at 0 is preserved with lowpass mode and a cutoff
  98  * at rate/4 */
  99 GST_START_TEST (test_type1_32_lp_0hz)
 100 {
 101   GstElement *audiocheblimit;
 102   GstBuffer *inbuffer, *outbuffer;
 103   GstCaps *caps;
 104   gfloat *in, *res, rms;
 105   gint i;
 106
 107   audiocheblimit = setup_audiocheblimit ();
 108   /* Set to lowpass */
 109   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 110   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 111   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 112   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 113
 114   fail_unless (gst_element_set_state (audiocheblimit,
 115           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 116       "could not set to playing");
 117
 118   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 119   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 120   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 121   for (i = 0; i < 128; i++)
 122     in[i] = 1.0;
 123
 124   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 125   gst_buffer_set_caps (inbuffer, caps);
 126   gst_caps_unref (caps);
 127   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 128
 129   /* pushing gives away my reference ... */
 130   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 131   /* ... and puts a new buffer on the global list */
 132   fail_unless_equals_int (g_list_length (buffers), 1);
 133   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 134
 135   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 136
 137   rms = 0.0;
 138   for (i = 0; i < 128; i++)
 139     rms += res[i] * res[i];
 140   rms = sqrt (rms / 128.0);
 141   fail_unless (rms >= 0.9);
 142
 143   /* cleanup */
 144   cleanup_audiocheblimit (audiocheblimit);
 145 }
 146
 147 GST_END_TEST;
 148
 149 /* Test if data containing only one frequency component
 150  * at rate/2 is erased with lowpass mode and a cutoff
 151  * at rate/4 */
 152 GST_START_TEST (test_type1_32_lp_22050hz)
 153 {
 154   GstElement *audiocheblimit;
 155   GstBuffer *inbuffer, *outbuffer;
 156   GstCaps *caps;
 157   gfloat *in, *res, rms;
 158   gint i;
 159
 160   audiocheblimit = setup_audiocheblimit ();
 161   /* Set to lowpass */
 162   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 163   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 164   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 165   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 166
 167   fail_unless (gst_element_set_state (audiocheblimit,
 168           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 169       "could not set to playing");
 170
 171   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 172   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 173   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 174   for (i = 0; i < 128; i += 2) {
 175     in[i] = 1.0;
 176     in[i + 1] = -1.0;
 177   }
 178
 179   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 180   gst_buffer_set_caps (inbuffer, caps);
 181   gst_caps_unref (caps);
 182   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 183
 184   /* pushing gives away my reference ... */
 185   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 186   /* ... and puts a new buffer on the global list */
 187   fail_unless_equals_int (g_list_length (buffers), 1);
 188   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 189
 190   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 191
 192   rms = 0.0;
 193   for (i = 0; i < 128; i++)
 194     rms += res[i] * res[i];
 195   rms = sqrt (rms / 128.0);
 196   fail_unless (rms <= 0.1);
 197
 198   /* cleanup */
 199   cleanup_audiocheblimit (audiocheblimit);
 200 }
 201
 202 GST_END_TEST;
 203
 204 /* Test if data containing only one frequency component
 205  * at 0 is erased with highpass mode and a cutoff
 206  * at rate/4 */
 207 GST_START_TEST (test_type1_32_hp_0hz)
 208 {
 209   GstElement *audiocheblimit;
 210   GstBuffer *inbuffer, *outbuffer;
 211   GstCaps *caps;
 212   gfloat *in, *res, rms;
 213   gint i;
 214
 215   audiocheblimit = setup_audiocheblimit ();
 216   /* Set to highpass */
 217   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 218   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 219   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 220   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 221
 222   fail_unless (gst_element_set_state (audiocheblimit,
 223           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 224       "could not set to playing");
 225
 226   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 227   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 228   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 229   for (i = 0; i < 128; i++)
 230     in[i] = 1.0;
 231
 232   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 233   gst_buffer_set_caps (inbuffer, caps);
 234   gst_caps_unref (caps);
 235   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 236
 237   /* pushing gives away my reference ... */
 238   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 239   /* ... and puts a new buffer on the global list */
 240   fail_unless_equals_int (g_list_length (buffers), 1);
 241   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 242
 243   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 244
 245   rms = 0.0;
 246   for (i = 0; i < 128; i++)
 247     rms += res[i] * res[i];
 248   rms = sqrt (rms / 128.0);
 249   fail_unless (rms <= 0.1);
 250
 251   /* cleanup */
 252   cleanup_audiocheblimit (audiocheblimit);
 253 }
 254
 255 GST_END_TEST;
 256
 257 /* Test if data containing only one frequency component
 258  * at rate/2 is preserved with highpass mode and a cutoff
 259  * at rate/4 */
 260 GST_START_TEST (test_type1_32_hp_22050hz)
 261 {
 262   GstElement *audiocheblimit;
 263   GstBuffer *inbuffer, *outbuffer;
 264   GstCaps *caps;
 265   gfloat *in, *res, rms;
 266   gint i;
 267
 268   audiocheblimit = setup_audiocheblimit ();
 269   /* Set to highpass */
 270   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 271   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 272   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 273   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 274
 275   fail_unless (gst_element_set_state (audiocheblimit,
 276           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 277       "could not set to playing");
 278
 279   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 280   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 281   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 282   for (i = 0; i < 128; i += 2) {
 283     in[i] = 1.0;
 284     in[i + 1] = -1.0;
 285   }
 286
 287   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 288   gst_buffer_set_caps (inbuffer, caps);
 289   gst_caps_unref (caps);
 290   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 291
 292   /* pushing gives away my reference ... */
 293   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 294   /* ... and puts a new buffer on the global list */
 295   fail_unless_equals_int (g_list_length (buffers), 1);
 296   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 297
 298   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 299
 300   rms = 0.0;
 301   for (i = 0; i < 128; i++)
 302     rms += res[i] * res[i];
 303   rms = sqrt (rms / 128.0);
 304   fail_unless (rms >= 0.9);
 305
 306   /* cleanup */
 307   cleanup_audiocheblimit (audiocheblimit);
 308 }
 309
 310 GST_END_TEST;
 311
 312 /* Test if data containing only one frequency component
 313  * at 0 is preserved with lowpass mode and a cutoff
 314  * at rate/4 */
 315 GST_START_TEST (test_type1_64_lp_0hz)
 316 {
 317   GstElement *audiocheblimit;
 318   GstBuffer *inbuffer, *outbuffer;
 319   GstCaps *caps;
 320   gdouble *in, *res, rms;
 321   gint i;
 322
 323   audiocheblimit = setup_audiocheblimit ();
 324   /* Set to lowpass */
 325   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 326   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 327   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 328   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 329
 330   fail_unless (gst_element_set_state (audiocheblimit,
 331           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 332       "could not set to playing");
 333
 334   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 335   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 336   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 337   for (i = 0; i < 128; i++)
 338     in[i] = 1.0;
 339
 340   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 341   gst_buffer_set_caps (inbuffer, caps);
 342   gst_caps_unref (caps);
 343   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 344
 345   /* pushing gives away my reference ... */
 346   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 347   /* ... and puts a new buffer on the global list */
 348   fail_unless_equals_int (g_list_length (buffers), 1);
 349   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 350
 351   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 352
 353   rms = 0.0;
 354   for (i = 0; i < 128; i++)
 355     rms += res[i] * res[i];
 356   rms = sqrt (rms / 128.0);
 357   fail_unless (rms >= 0.9);
 358
 359   /* cleanup */
 360   cleanup_audiocheblimit (audiocheblimit);
 361 }
 362
 363 GST_END_TEST;
 364
 365 /* Test if data containing only one frequency component
 366  * at rate/2 is erased with lowpass mode and a cutoff
 367  * at rate/4 */
 368 GST_START_TEST (test_type1_64_lp_22050hz)
 369 {
 370   GstElement *audiocheblimit;
 371   GstBuffer *inbuffer, *outbuffer;
 372   GstCaps *caps;
 373   gdouble *in, *res, rms;
 374   gint i;
 375
 376   audiocheblimit = setup_audiocheblimit ();
 377   /* Set to lowpass */
 378   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 379   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 380   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 381   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 382
 383   fail_unless (gst_element_set_state (audiocheblimit,
 384           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 385       "could not set to playing");
 386
 387   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 388   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 389   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 390   for (i = 0; i < 128; i += 2) {
 391     in[i] = 1.0;
 392     in[i + 1] = -1.0;
 393   }
 394
 395   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 396   gst_buffer_set_caps (inbuffer, caps);
 397   gst_caps_unref (caps);
 398   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 399
 400   /* pushing gives away my reference ... */
 401   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 402   /* ... and puts a new buffer on the global list */
 403   fail_unless_equals_int (g_list_length (buffers), 1);
 404   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 405
 406   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 407
 408   rms = 0.0;
 409   for (i = 0; i < 128; i++)
 410     rms += res[i] * res[i];
 411   rms = sqrt (rms / 128.0);
 412   fail_unless (rms <= 0.1);
 413
 414   /* cleanup */
 415   cleanup_audiocheblimit (audiocheblimit);
 416 }
 417
 418 GST_END_TEST;
 419
 420 /* Test if data containing only one frequency component
 421  * at 0 is erased with highpass mode and a cutoff
 422  * at rate/4 */
 423 GST_START_TEST (test_type1_64_hp_0hz)
 424 {
 425   GstElement *audiocheblimit;
 426   GstBuffer *inbuffer, *outbuffer;
 427   GstCaps *caps;
 428   gdouble *in, *res, rms;
 429   gint i;
 430
 431   audiocheblimit = setup_audiocheblimit ();
 432   /* Set to highpass */
 433   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 434   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 435   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 436   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 437
 438   fail_unless (gst_element_set_state (audiocheblimit,
 439           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 440       "could not set to playing");
 441
 442   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 443   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 444   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 445   for (i = 0; i < 128; i++)
 446     in[i] = 1.0;
 447
 448   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 449   gst_buffer_set_caps (inbuffer, caps);
 450   gst_caps_unref (caps);
 451   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 452
 453   /* pushing gives away my reference ... */
 454   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 455   /* ... and puts a new buffer on the global list */
 456   fail_unless_equals_int (g_list_length (buffers), 1);
 457   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 458
 459   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 460
 461   rms = 0.0;
 462   for (i = 0; i < 128; i++)
 463     rms += res[i] * res[i];
 464   rms = sqrt (rms / 128.0);
 465   fail_unless (rms <= 0.1);
 466
 467   /* cleanup */
 468   cleanup_audiocheblimit (audiocheblimit);
 469 }
 470
 471 GST_END_TEST;
 472
 473 /* Test if data containing only one frequency component
 474  * at rate/2 is preserved with highpass mode and a cutoff
 475  * at rate/4 */
 476 GST_START_TEST (test_type1_64_hp_22050hz)
 477 {
 478   GstElement *audiocheblimit;
 479   GstBuffer *inbuffer, *outbuffer;
 480   GstCaps *caps;
 481   gdouble *in, *res, rms;
 482   gint i;
 483
 484   audiocheblimit = setup_audiocheblimit ();
 485   /* Set to highpass */
 486   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 487   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 488   g_object_set (G_OBJECT (audiocheblimit), "type", 1, NULL);
 489   g_object_set (G_OBJECT (audiocheblimit), "ripple", 0.25, NULL);
 490
 491   fail_unless (gst_element_set_state (audiocheblimit,
 492           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 493       "could not set to playing");
 494
 495   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 496   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 497   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 498   for (i = 0; i < 128; i += 2) {
 499     in[i] = 1.0;
 500     in[i + 1] = -1.0;
 501   }
 502
 503   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 504   gst_buffer_set_caps (inbuffer, caps);
 505   gst_caps_unref (caps);
 506   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 507
 508   /* pushing gives away my reference ... */
 509   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 510   /* ... and puts a new buffer on the global list */
 511   fail_unless_equals_int (g_list_length (buffers), 1);
 512   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 513
 514   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 515
 516   rms = 0.0;
 517   for (i = 0; i < 128; i++)
 518     rms += res[i] * res[i];
 519   rms = sqrt (rms / 128.0);
 520   fail_unless (rms >= 0.9);
 521
 522   /* cleanup */
 523   cleanup_audiocheblimit (audiocheblimit);
 524 }
 525
 526 GST_END_TEST;
 527
 528 /* Test if data containing only one frequency component
 529  * at 0 is preserved with lowpass mode and a cutoff
 530  * at rate/4 */
 531 GST_START_TEST (test_type2_32_lp_0hz)
 532 {
 533   GstElement *audiocheblimit;
 534   GstBuffer *inbuffer, *outbuffer;
 535   GstCaps *caps;
 536   gfloat *in, *res, rms;
 537   gint i;
 538
 539   audiocheblimit = setup_audiocheblimit ();
 540   /* Set to lowpass */
 541   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 542   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 543   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 544   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 545
 546   fail_unless (gst_element_set_state (audiocheblimit,
 547           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 548       "could not set to playing");
 549
 550   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 551   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 552   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 553   for (i = 0; i < 128; i++)
 554     in[i] = 1.0;
 555
 556   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 557   gst_buffer_set_caps (inbuffer, caps);
 558   gst_caps_unref (caps);
 559   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 560
 561   /* pushing gives away my reference ... */
 562   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 563   /* ... and puts a new buffer on the global list */
 564   fail_unless_equals_int (g_list_length (buffers), 1);
 565   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 566
 567   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 568
 569   rms = 0.0;
 570   for (i = 0; i < 128; i++)
 571     rms += res[i] * res[i];
 572   rms = sqrt (rms / 128.0);
 573   fail_unless (rms >= 0.9);
 574
 575   /* cleanup */
 576   cleanup_audiocheblimit (audiocheblimit);
 577 }
 578
 579 GST_END_TEST;
 580
 581 /* Test if data containing only one frequency component
 582  * at rate/2 is erased with lowpass mode and a cutoff
 583  * at rate/4 */
 584 GST_START_TEST (test_type2_32_lp_22050hz)
 585 {
 586   GstElement *audiocheblimit;
 587   GstBuffer *inbuffer, *outbuffer;
 588   GstCaps *caps;
 589   gfloat *in, *res, rms;
 590   gint i;
 591
 592   audiocheblimit = setup_audiocheblimit ();
 593   /* Set to lowpass */
 594   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 595   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 596   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 597   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 598
 599   fail_unless (gst_element_set_state (audiocheblimit,
 600           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 601       "could not set to playing");
 602
 603   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 604   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 605   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 606   for (i = 0; i < 128; i += 2) {
 607     in[i] = 1.0;
 608     in[i + 1] = -1.0;
 609   }
 610
 611   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 612   gst_buffer_set_caps (inbuffer, caps);
 613   gst_caps_unref (caps);
 614   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 615
 616   /* pushing gives away my reference ... */
 617   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 618   /* ... and puts a new buffer on the global list */
 619   fail_unless_equals_int (g_list_length (buffers), 1);
 620   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 621
 622   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 623
 624   rms = 0.0;
 625   for (i = 0; i < 128; i++)
 626     rms += res[i] * res[i];
 627   rms = sqrt (rms / 128.0);
 628   fail_unless (rms <= 0.1);
 629
 630   /* cleanup */
 631   cleanup_audiocheblimit (audiocheblimit);
 632 }
 633
 634 GST_END_TEST;
 635
 636 /* Test if data containing only one frequency component
 637  * at 0 is erased with highpass mode and a cutoff
 638  * at rate/4 */
 639 GST_START_TEST (test_type2_32_hp_0hz)
 640 {
 641   GstElement *audiocheblimit;
 642   GstBuffer *inbuffer, *outbuffer;
 643   GstCaps *caps;
 644   gfloat *in, *res, rms;
 645   gint i;
 646
 647   audiocheblimit = setup_audiocheblimit ();
 648   /* Set to highpass */
 649   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 650   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 651   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 652   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 653
 654   fail_unless (gst_element_set_state (audiocheblimit,
 655           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 656       "could not set to playing");
 657
 658   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 659   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 660   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 661   for (i = 0; i < 128; i++)
 662     in[i] = 1.0;
 663
 664   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 665   gst_buffer_set_caps (inbuffer, caps);
 666   gst_caps_unref (caps);
 667   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 668
 669   /* pushing gives away my reference ... */
 670   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 671   /* ... and puts a new buffer on the global list */
 672   fail_unless_equals_int (g_list_length (buffers), 1);
 673   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 674
 675   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 676
 677   rms = 0.0;
 678   for (i = 0; i < 128; i++)
 679     rms += res[i] * res[i];
 680   rms = sqrt (rms / 128.0);
 681   fail_unless (rms <= 0.1);
 682
 683   /* cleanup */
 684   cleanup_audiocheblimit (audiocheblimit);
 685 }
 686
 687 GST_END_TEST;
 688
 689 /* Test if data containing only one frequency component
 690  * at rate/2 is preserved with highpass mode and a cutoff
 691  * at rate/4 */
 692 GST_START_TEST (test_type2_32_hp_22050hz)
 693 {
 694   GstElement *audiocheblimit;
 695   GstBuffer *inbuffer, *outbuffer;
 696   GstCaps *caps;
 697   gfloat *in, *res, rms;
 698   gint i;
 699
 700   audiocheblimit = setup_audiocheblimit ();
 701   /* Set to highpass */
 702   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 703   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 704   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 705   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 706
 707   fail_unless (gst_element_set_state (audiocheblimit,
 708           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 709       "could not set to playing");
 710
 711   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 712   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gfloat));
 713   in = (gfloat *) GST_BUFFER_DATA (inbuffer);
 714   for (i = 0; i < 128; i += 2) {
 715     in[i] = 1.0;
 716     in[i + 1] = -1.0;
 717   }
 718
 719   caps = gst_caps_from_string (BUFFER_CAPS_STRING_32);
 720   gst_buffer_set_caps (inbuffer, caps);
 721   gst_caps_unref (caps);
 722   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 723
 724   /* pushing gives away my reference ... */
 725   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 726   /* ... and puts a new buffer on the global list */
 727   fail_unless_equals_int (g_list_length (buffers), 1);
 728   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 729
 730   res = (gfloat *) GST_BUFFER_DATA (outbuffer);
 731
 732   rms = 0.0;
 733   for (i = 0; i < 128; i++)
 734     rms += res[i] * res[i];
 735   rms = sqrt (rms / 128.0);
 736   fail_unless (rms >= 0.9);
 737
 738   /* cleanup */
 739   cleanup_audiocheblimit (audiocheblimit);
 740 }
 741
 742 GST_END_TEST;
 743
 744 /* Test if data containing only one frequency component
 745  * at 0 is preserved with lowpass mode and a cutoff
 746  * at rate/4 */
 747 GST_START_TEST (test_type2_64_lp_0hz)
 748 {
 749   GstElement *audiocheblimit;
 750   GstBuffer *inbuffer, *outbuffer;
 751   GstCaps *caps;
 752   gdouble *in, *res, rms;
 753   gint i;
 754
 755   audiocheblimit = setup_audiocheblimit ();
 756   /* Set to lowpass */
 757   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 758   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 759   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 760   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 761
 762   fail_unless (gst_element_set_state (audiocheblimit,
 763           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 764       "could not set to playing");
 765
 766   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 767   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 768   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 769   for (i = 0; i < 128; i++)
 770     in[i] = 1.0;
 771
 772   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 773   gst_buffer_set_caps (inbuffer, caps);
 774   gst_caps_unref (caps);
 775   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 776
 777   /* pushing gives away my reference ... */
 778   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 779   /* ... and puts a new buffer on the global list */
 780   fail_unless_equals_int (g_list_length (buffers), 1);
 781   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 782
 783   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 784
 785   rms = 0.0;
 786   for (i = 0; i < 128; i++)
 787     rms += res[i] * res[i];
 788   rms = sqrt (rms / 128.0);
 789   fail_unless (rms >= 0.9);
 790
 791   /* cleanup */
 792   cleanup_audiocheblimit (audiocheblimit);
 793 }
 794
 795 GST_END_TEST;
 796
 797 /* Test if data containing only one frequency component
 798  * at rate/2 is erased with lowpass mode and a cutoff
 799  * at rate/4 */
 800 GST_START_TEST (test_type2_64_lp_22050hz)
 801 {
 802   GstElement *audiocheblimit;
 803   GstBuffer *inbuffer, *outbuffer;
 804   GstCaps *caps;
 805   gdouble *in, *res, rms;
 806   gint i;
 807
 808   audiocheblimit = setup_audiocheblimit ();
 809   /* Set to lowpass */
 810   g_object_set (G_OBJECT (audiocheblimit), "mode", 0, NULL);
 811   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 812   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 813   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 814
 815   fail_unless (gst_element_set_state (audiocheblimit,
 816           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 817       "could not set to playing");
 818
 819   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 820   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 821   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 822   for (i = 0; i < 128; i += 2) {
 823     in[i] = 1.0;
 824     in[i + 1] = -1.0;
 825   }
 826
 827   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 828   gst_buffer_set_caps (inbuffer, caps);
 829   gst_caps_unref (caps);
 830   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 831
 832   /* pushing gives away my reference ... */
 833   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 834   /* ... and puts a new buffer on the global list */
 835   fail_unless_equals_int (g_list_length (buffers), 1);
 836   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 837
 838   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 839
 840   rms = 0.0;
 841   for (i = 0; i < 128; i++)
 842     rms += res[i] * res[i];
 843   rms = sqrt (rms / 128.0);
 844   fail_unless (rms <= 0.1);
 845
 846   /* cleanup */
 847   cleanup_audiocheblimit (audiocheblimit);
 848 }
 849
 850 GST_END_TEST;
 851
 852 /* Test if data containing only one frequency component
 853  * at 0 is erased with highpass mode and a cutoff
 854  * at rate/4 */
 855 GST_START_TEST (test_type2_64_hp_0hz)
 856 {
 857   GstElement *audiocheblimit;
 858   GstBuffer *inbuffer, *outbuffer;
 859   GstCaps *caps;
 860   gdouble *in, *res, rms;
 861   gint i;
 862
 863   audiocheblimit = setup_audiocheblimit ();
 864   /* Set to highpass */
 865   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 866   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 867   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 868   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 869
 870   fail_unless (gst_element_set_state (audiocheblimit,
 871           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 872       "could not set to playing");
 873
 874   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 875   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 876   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 877   for (i = 0; i < 128; i++)
 878     in[i] = 1.0;
 879
 880   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 881   gst_buffer_set_caps (inbuffer, caps);
 882   gst_caps_unref (caps);
 883   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 884
 885   /* pushing gives away my reference ... */
 886   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 887   /* ... and puts a new buffer on the global list */
 888   fail_unless_equals_int (g_list_length (buffers), 1);
 889   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 890
 891   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 892
 893   rms = 0.0;
 894   for (i = 0; i < 128; i++)
 895     rms += res[i] * res[i];
 896   rms = sqrt (rms / 128.0);
 897   fail_unless (rms <= 0.1);
 898
 899   /* cleanup */
 900   cleanup_audiocheblimit (audiocheblimit);
 901 }
 902
 903 GST_END_TEST;
 904
 905 /* Test if data containing only one frequency component
 906  * at rate/2 is preserved with highpass mode and a cutoff
 907  * at rate/4 */
 908 GST_START_TEST (test_type2_64_hp_22050hz)
 909 {
 910   GstElement *audiocheblimit;
 911   GstBuffer *inbuffer, *outbuffer;
 912   GstCaps *caps;
 913   gdouble *in, *res, rms;
 914   gint i;
 915
 916   audiocheblimit = setup_audiocheblimit ();
 917   /* Set to highpass */
 918   g_object_set (G_OBJECT (audiocheblimit), "mode", 1, NULL);
 919   g_object_set (G_OBJECT (audiocheblimit), "poles", 8, NULL);
 920   g_object_set (G_OBJECT (audiocheblimit), "type", 2, NULL);
 921   g_object_set (G_OBJECT (audiocheblimit), "ripple", 40.0, NULL);
 922
 923   fail_unless (gst_element_set_state (audiocheblimit,
 924           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 925       "could not set to playing");
 926
 927   g_object_set (G_OBJECT (audiocheblimit), "cutoff", 44100 / 4.0, NULL);
 928   inbuffer = gst_buffer_new_and_alloc (128 * sizeof (gdouble));
 929   in = (gdouble *) GST_BUFFER_DATA (inbuffer);
 930   for (i = 0; i < 128; i += 2) {
 931     in[i] = 1.0;
 932     in[i + 1] = -1.0;
 933   }
 934
 935   caps = gst_caps_from_string (BUFFER_CAPS_STRING_64);
 936   gst_buffer_set_caps (inbuffer, caps);
 937   gst_caps_unref (caps);
 938   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 939
 940   /* pushing gives away my reference ... */
 941   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 942   /* ... and puts a new buffer on the global list */
 943   fail_unless_equals_int (g_list_length (buffers), 1);
 944   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 945
 946   res = (gdouble *) GST_BUFFER_DATA (outbuffer);
 947
 948   rms = 0.0;
 949   for (i = 0; i < 128; i++)
 950     rms += res[i] * res[i];
 951   rms = sqrt (rms / 128.0);
 952   fail_unless (rms >= 0.9);
 953
 954   /* cleanup */
 955   cleanup_audiocheblimit (audiocheblimit);
 956 }
 957
 958 GST_END_TEST;
 959
 960
 961 static Suite *
 962 audiocheblimit_suite (void)
 963 {
 964   Suite *s = suite_create ("audiocheblimit");
 965   TCase *tc_chain = tcase_create ("general");
 966
 967   suite_add_tcase (s, tc_chain);
 968   tcase_add_test (tc_chain, test_type1_32_lp_0hz);
 969   tcase_add_test (tc_chain, test_type1_32_lp_22050hz);
 970   tcase_add_test (tc_chain, test_type1_32_hp_0hz);
 971   tcase_add_test (tc_chain, test_type1_32_hp_22050hz);
 972   tcase_add_test (tc_chain, test_type1_64_lp_0hz);
 973   tcase_add_test (tc_chain, test_type1_64_lp_22050hz);
 974   tcase_add_test (tc_chain, test_type1_64_hp_0hz);
 975   tcase_add_test (tc_chain, test_type1_64_hp_22050hz);
 976   tcase_add_test (tc_chain, test_type2_32_lp_0hz);
 977   tcase_add_test (tc_chain, test_type2_32_lp_22050hz);
 978   tcase_add_test (tc_chain, test_type2_32_hp_0hz);
 979   tcase_add_test (tc_chain, test_type2_32_hp_22050hz);
 980   tcase_add_test (tc_chain, test_type2_64_lp_0hz);
 981   tcase_add_test (tc_chain, test_type2_64_lp_22050hz);
 982   tcase_add_test (tc_chain, test_type2_64_hp_0hz);
 983   tcase_add_test (tc_chain, test_type2_64_hp_22050hz);
 984   return s;
 985 }
 986
 987 int
 988 main (int argc, char **argv)
 989 {
 990   int nf;
 991
 992   Suite *s = audiocheblimit_suite ();
 993   SRunner *sr = srunner_create (s);
 994
 995   gst_check_init (&argc, &argv);
 996
 997   srunner_run_all (sr, CK_NORMAL);
 998   nf = srunner_ntests_failed (sr);
 999   srunner_free (sr);
1000
1001   return nf;
1002 }