src/benchmark.cpp

   1 /* Calf DSP Library
   2  * Benchmark for selected parts of the library.
   3  * Copyright (C) 2007 Krzysztof Foltman
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  */
  20
  21 #define BENCHMARK_PLUGINS
  22
  23 #ifdef BENCHMARK_PLUGINS
  24 #include <calf/giface.h>
  25 #include <calf/modules_tools.h>
  26 #include <calf/modules_delay.h>
  27 #include <calf/modules_comp.h>
  28 #include <calf/modules_dev.h>
  29 #include <calf/modules_filter.h>
  30 #include <calf/modules_mod.h>
  31 #else
  32 #include <config.h>
  33 #endif
  34
  35 #include <calf/audio_fx.h>
  36 #include <calf/fft.h>
  37 #include <calf/loudness.h>
  38 #include <calf/benchmark.h>
  39 #include <getopt.h>
  40
  41 // #define TEST_OSC
  42
  43 using namespace std;
  44 using namespace dsp;
  45
  46 #ifdef TEST_OSC
  47 #include <calf/osctl.h>
  48 #include <calf/osctlnet.h>
  49 #include <calf/osctl_glib.h>
  50 using namespace osctl;
  51 #endif
  52
  53 bool benchmark_globals::warned = false;
  54
  55 template<int BUF_SIZE>
  56 struct empty_benchmark
  57 {
  58     void prepare()
  59     {
  60     }
  61     void cleanup()
  62     {
  63     }
  64     double scaler() { return BUF_SIZE; }
  65 };
  66
  67 template<class filter_class>
  68 struct filter_lp24dB_benchmark
  69 {
  70     enum { BUF_SIZE = 256 };
  71     float buffer[BUF_SIZE];
  72     float result;
  73     filter_class biquad, biquad2;
  74     void prepare()
  75     {
  76         for (int i = 0; i < BUF_SIZE; i++)
  77             buffer[i] = i;
  78         biquad.set_lp_rbj(2000, 0.7, 44100);
  79         biquad2.set_lp_rbj(2000, 0.7, 44100);
  80         result = 0;
  81     }
  82     void cleanup() { result = buffer[BUF_SIZE - 1]; }
  83     double scaler() { return BUF_SIZE; }
  84 };
  85
  86 struct filter_24dB_lp_twopass_d1: public filter_lp24dB_benchmark<biquad_d1>
  87 {
  88     void run()
  89     {
  90         for (int i = 0; i < BUF_SIZE; i++)
  91             buffer[i] = biquad.process(buffer[i]);
  92         for (int i = 0; i < BUF_SIZE; i++)
  93             buffer[i] = biquad2.process(buffer[i]);
  94     }
  95 };
  96
  97 struct filter_24dB_lp_onepass_d1: public filter_lp24dB_benchmark<biquad_d1>
  98 {
  99     void run()
 100     {
 101         for (int i = 0; i < BUF_SIZE; i++)
 102             buffer[i] = biquad2.process(biquad.process(buffer[i]));
 103     }
 104 };
 105
 106 struct filter_12dB_lp_d1: public filter_lp24dB_benchmark<biquad_d1>
 107 {
 108     void run()
 109     {
 110         for (int i = 0; i < BUF_SIZE; i++)
 111             buffer[i] = biquad.process(buffer[i]);
 112     }
 113 };
 114
 115 struct filter_24dB_lp_twopass_d2: public filter_lp24dB_benchmark<biquad_d2 >
 116 {
 117     void run()
 118     {
 119         for (int i = 0; i < BUF_SIZE; i++)
 120             buffer[i] = biquad.process(buffer[i]);
 121         for (int i = 0; i < BUF_SIZE; i++)
 122             buffer[i] = biquad2.process(buffer[i]);
 123     }
 124 };
 125
 126 struct filter_24dB_lp_onepass_d2: public filter_lp24dB_benchmark<biquad_d2 >
 127 {
 128     void run()
 129     {
 130         for (int i = 0; i < BUF_SIZE; i++)
 131             buffer[i] = biquad2.process(biquad.process(buffer[i]));
 132     }
 133 };
 134
 135 struct filter_24dB_lp_onepass_d2_lp: public filter_lp24dB_benchmark<biquad_d2 >
 136 {
 137     void run()
 138     {
 139         for (int i = 0; i < BUF_SIZE; i++)
 140             buffer[i] = biquad2.process_lp(biquad.process_lp(buffer[i]));
 141     }
 142 };
 143
 144 struct filter_12dB_lp_d2: public filter_lp24dB_benchmark<biquad_d2 >
 145 {
 146     void run()
 147     {
 148         for (int i = 0; i < BUF_SIZE; i++)
 149             buffer[i] = biquad.process(buffer[i]);
 150     }
 151 };
 152
 153 template<int N>
 154 struct fft_test_class
 155 {
 156     typedef fft<float, N> fft_class;
 157     fft_class ffter;
 158     float result;
 159     complex<float> data[1 << N], output[1 << N];
 160     void prepare() {
 161         for (int i = 0; i < (1 << N); i++)
 162             data[i] = sin(i);
 163         result = 0;
 164     }
 165     void cleanup()
 166     {
 167     }
 168     void run()
 169     {
 170         ffter.calculate(data, output, false);
 171     }
 172     double scaler() { return 1 << N; }
 173 };
 174
 175 #define ALIGN_TEST_RUN 1024
 176
 177 struct __attribute__((aligned(8))) alignment_test: public empty_benchmark<ALIGN_TEST_RUN>
 178 {
 179     char __attribute__((aligned(8))) data[ALIGN_TEST_RUN * sizeof(double) + sizeof(double)];
 180     float result;
 181
 182     virtual double *get_ptr()=0;
 183     virtual ~alignment_test() {}
 184     void prepare()
 185     {
 186         memset(data, 0, sizeof(data));
 187         result = 0;
 188     }
 189     void cleanup()
 190     {
 191         result = 0;
 192         double *p = get_ptr();
 193         for (int i=0; i < ALIGN_TEST_RUN; i++)
 194             result += p[i];
 195     }
 196 };
 197
 198 struct aligned_double: public alignment_test
 199 {
 200     virtual double *get_ptr() { return (double *)data; }
 201     void run()
 202     {
 203         double *ptr = (double *)data;
 204         for (int i=0; i < ALIGN_TEST_RUN; i++)
 205             ptr[i] += 1 + i;
 206     }
 207 };
 208
 209 struct __attribute__((aligned(8))) misaligned_double: public alignment_test
 210 {
 211     virtual double *get_ptr() { return (double *)(data+4); }
 212     void run()
 213     {
 214         double *ptr = (double *)(data + 4);
 215         for (int i=0; i < ALIGN_TEST_RUN; i++)
 216             ptr[i] += 1 + i;
 217     }
 218 };
 219
 220 const char *unit = NULL;
 221
 222 static struct option long_options[] = {
 223     {"help", 0, 0, 'h'},
 224     {"version", 0, 0, 'v'},
 225     {"unit", 1, 0, 'u'},
 226     {0,0,0,0},
 227 };
 228
 229 void biquad_test()
 230 {
 231         do_simple_benchmark<filter_24dB_lp_twopass_d1>();
 232         do_simple_benchmark<filter_24dB_lp_onepass_d1>();
 233         do_simple_benchmark<filter_12dB_lp_d1>();
 234         do_simple_benchmark<filter_24dB_lp_twopass_d2>();
 235         do_simple_benchmark<filter_24dB_lp_onepass_d2>();
 236         do_simple_benchmark<filter_24dB_lp_onepass_d2_lp>();
 237         do_simple_benchmark<filter_12dB_lp_d2>();
 238 }
 239
 240 void fft_test()
 241 {
 242         do_simple_benchmark<fft_test_class<17> >(5, 10);
 243 }
 244
 245 void alignment_test()
 246 {
 247         do_simple_benchmark<misaligned_double>();
 248         do_simple_benchmark<aligned_double>();
 249 }
 250
 251 #ifdef BENCHMARK_PLUGINS
 252 template<class Effect>
 253 void get_default_effect_params(float params[Effect::param_count], uint32_t &sr);
 254
 255 template<>
 256 void get_default_effect_params<calf_plugins::reverb_audio_module>(float params[3], uint32_t &sr)
 257 {
 258     typedef calf_plugins::reverb_audio_module mod;
 259     params[mod::par_decay] = 4;
 260     params[mod::par_hfdamp] = 2000;
 261     params[mod::par_amount] = 2;
 262     sr = 4000;
 263 }
 264
 265 template<>
 266 void get_default_effect_params<calf_plugins::filter_audio_module>(float params[4], uint32_t &sr)
 267 {
 268     typedef calf_plugins::filter_audio_module mod;
 269     params[mod::par_cutoff] = 500;
 270     params[mod::par_resonance] = 3;
 271     params[mod::par_mode] = 2;
 272     params[mod::par_inertia] = 16;
 273     sr = 4000;
 274 }
 275
 276 template<>
 277 void get_default_effect_params<calf_plugins::flanger_audio_module>(float params[5], uint32_t &sr)
 278 {
 279     typedef calf_plugins::flanger_audio_module mod;
 280     params[mod::par_delay] = 1;
 281     params[mod::par_depth] = 2;
 282     params[mod::par_rate] = 1;
 283     params[mod::par_fb] = 0.9;
 284     params[mod::par_amount] = 0.9;
 285     sr = 44100;
 286 }
 287
 288 template<>
 289 void get_default_effect_params<calf_plugins::compressor_audio_module>(float params[], uint32_t &sr)
 290 {
 291     typedef calf_plugins::compressor_audio_module mod;
 292     params[mod::param_threshold] = 10;
 293     params[mod::param_ratio] = 2;
 294     params[mod::param_attack] = 0.1;
 295     params[mod::param_release] = 100;
 296     params[mod::param_makeup] = 1;
 297     params[mod::param_stereo_link] = 1;
 298     params[mod::param_detection] = 0;
 299     params[mod::param_knee] = 40000;
 300     params[mod::param_bypass] = 0;
 301     sr = 44100;
 302 }
 303
 304 template<>
 305 void get_default_effect_params<calf_plugins::multichorus_audio_module>(float params[], uint32_t &sr)
 306 {
 307     typedef calf_plugins::multichorus_audio_module mod;
 308     params[mod::par_delay] = 10;
 309     params[mod::par_depth] = 10;
 310     params[mod::par_rate] = 1;
 311     params[mod::par_voices] = 6;
 312     params[mod::par_stereo] = 180;
 313     params[mod::par_vphase] = 20;
 314     params[mod::par_amount] = 0.9;
 315     sr = 44100;
 316 }
 317
 318 template<class Effect, unsigned int bufsize = 256>
 319 class effect_benchmark: public empty_benchmark<bufsize>
 320 {
 321 public:
 322     Effect effect;
 323     float inputs[Effect::in_count][bufsize];
 324     float outputs[Effect::out_count][bufsize];
 325     float result;
 326     float params[Effect::param_count];
 327
 328     void prepare()
 329     {
 330         for (int b = 0; b < Effect::out_count; b++)
 331         {
 332             effect.outs[b] = outputs[b];
 333             dsp::zero(outputs[b], bufsize);
 334         }
 335         for (int b = 0; b < Effect::in_count; b++)
 336         {
 337             effect.ins[b] = inputs[b];
 338             for (unsigned int i = 0; i < bufsize; i++)
 339                 inputs[b][i] = (float)(10 + i*0.3f*(b+1));
 340         }
 341         for (int i = 0; i < Effect::param_count; i++)
 342             effect.params[i] = &params[i];
 343         ::get_default_effect_params<Effect>(params, effect.srate);
 344         result = 0.f;
 345         effect.activate();
 346     }
 347     void run()
 348     {
 349         effect.params_changed();
 350         effect.process(0, bufsize, 3, 3);
 351     }
 352     void cleanup()
 353     {
 354         for (int b = 0; b < Effect::out_count; b++)
 355         {
 356             for (unsigned int i = 0; i < bufsize; i++)
 357                 result += outputs[b][i];
 358         }
 359     }
 360 };
 361
 362 void effect_test()
 363 {
 364     dsp::do_simple_benchmark<effect_benchmark<calf_plugins::flanger_audio_module> >(5, 10000);
 365     dsp::do_simple_benchmark<effect_benchmark<calf_plugins::reverb_audio_module> >(5, 1000);
 366     dsp::do_simple_benchmark<effect_benchmark<calf_plugins::filter_audio_module> >(5, 10000);
 367     dsp::do_simple_benchmark<effect_benchmark<calf_plugins::compressor_audio_module> >(5, 10000);
 368     dsp::do_simple_benchmark<effect_benchmark<calf_plugins::multichorus_audio_module> >(5, 10000);
 369 }
 370
 371 #else
 372 void effect_test()
 373 {
 374     printf("Test temporarily removed due to refactoring\n");
 375 }
 376 #endif
 377 void reverbir_calc()
 378 {
 379     enum { LEN = 1048576 };
 380     static float data[2][LEN];
 381
 382     for (int t = 1; t < 38; t++)
 383     {
 384         dsp::reverb rvb;
 385
 386         memset(data, 0, sizeof(data));
 387         data[0][0] = 1;
 388         data[1][0] = 0;
 389
 390         rvb.set_cutoff(22000);
 391         rvb.setup(44100);
 392         rvb.reset();
 393         rvb.set_fb(t < 19 ? t * 0.05 : 0.905 + (t - 19) * 0.005);
 394
 395         for (int i = 0; i < LEN; i++)
 396             rvb.process(data[0][i], data[1][i]);
 397
 398         int i;
 399         for (i = LEN - 1; i > 0; i--)
 400         {
 401             // printf("[%d]=%f\n", i, data[0][i]);
 402             if (fabs(data[0][i]) < 0.001 && fabs(data[1][i]) < 0.001)
 403                 continue;
 404             break;
 405         }
 406         if (i < LEN - 1)
 407             printf("%f\t%f\n", rvb.get_fb(), i / 44100.0);
 408     }
 409 }
 410
 411 void eq_calc()
 412 {
 413     biquad_coeffs bqc;
 414     bqc.set_lowshelf_rbj(2000, 2.0, 4.0, 10000);
 415     for (int i = 0; i <= 5000; i += 100)
 416     {
 417         printf("%d %f\n", i, bqc.freq_gain(i * 1.0, 10000));
 418     }
 419 }
 420
 421 void aweighting_calc()
 422 {
 423     aweighter aw;
 424     float fs = 44100;
 425     aw.set(fs);
 426     for (int i = 10; i < 20000; i += 10)
 427     {
 428         printf("%d %f\n", i, 20*log10(aw.freq_gain(i * 1.0, fs)));
 429     }
 430 }
 431
 432 #ifdef TEST_OSC
 433
 434 struct my_sink: public osc_message_sink<osc_strstream>
 435 {
 436     GMainLoop *loop;
 437     osc_message_dump<osc_strstream, ostream> dump;
 438     my_sink() : dump(cout) {}
 439     virtual void receive_osc_message(std::string address, std::string type_tag, osc_strstream &buffer)
 440     {
 441         dump.receive_osc_message(address, type_tag, buffer);
 442         assert(address == "/blah");
 443         assert(type_tag == "bsii");
 444
 445         string_buffer blob;
 446         string str;
 447         uint32_t val1, val2;
 448         buffer >> blob >> str >> val1 >> val2;
 449         assert(blob.data == "123");
 450         assert(str == "test");
 451         assert(val1 == 1);
 452         assert(val2 == 2);
 453         g_main_loop_quit(loop);
 454     }
 455
 456 };
 457
 458 void osctl_test()
 459 {
 460     string sdata = string("\000\000\000\003123\000test\000\000\000\000\000\000\000\001\000\000\000\002", 24);
 461     string_buffer sb(sdata);
 462     osc_strstream is(sb);
 463     osc_inline_typed_strstream os;
 464
 465     string_buffer blob;
 466     string str;
 467     uint32_t val1, val2;
 468     is >> blob >> str >> val1 >> val2;
 469     assert(blob.data == "123");
 470     assert(str == "test");
 471     assert(val1 == 1);
 472     assert(val2 == 2);
 473
 474     os << blob << str << val1 << val2;
 475     assert(os.buf_data.data == sdata);
 476     assert(os.buf_types.data == "bsii");
 477
 478     GMainLoop *main_loop = g_main_loop_new(NULL, FALSE);
 479     my_sink sink;
 480     sink.loop = main_loop;
 481     osc_server srv;
 482     srv.sink = &sink;
 483     srv.bind("0.0.0.0", 4541);
 484
 485     osc_client cli;
 486     cli.bind("0.0.0.0", 0);
 487     cli.set_addr("0.0.0.0", 4541);
 488     if (!cli.send("/blah", os))
 489     {
 490         g_error("Could not send the OSC message");
 491     }
 492
 493     g_main_loop_run(main_loop);
 494 }
 495 #endif
 496
 497 int main(int argc, char *argv[])
 498 {
 499     while(1) {
 500         int option_index;
 501         int c = getopt_long(argc, argv, "u:hv", long_options, &option_index);
 502         if (c == -1)
 503             break;
 504         switch(c) {
 505             case 'h':
 506             case '?':
 507                 printf("Benchmark suite Calf plugin pack\nSyntax: %s [--help] [--version] [--unit biquad|alignment|effects]\n", argv[0]);
 508                 return 0;
 509             case 'v':
 510                 printf("%s\n", PACKAGE_STRING);
 511                 return 0;
 512             case 'u':
 513                 unit = optarg;
 514                 break;
 515         }
 516     }
 517
 518 #ifdef TEST_OSC
 519     if (unit && !strcmp(unit, "osc"))
 520         osctl_test();
 521 #endif
 522
 523     if (!unit || !strcmp(unit, "biquad"))
 524         biquad_test();
 525
 526     if (!unit || !strcmp(unit, "alignment"))
 527         alignment_test();
 528
 529     if (!unit || !strcmp(unit, "effects"))
 530         effect_test();
 531
 532     if (unit && !strcmp(unit, "reverbir"))
 533         reverbir_calc();
 534
 535     if (unit && !strcmp(unit, "eq"))
 536         eq_calc();
 537
 538     if (unit && !strcmp(unit, "aweighting"))
 539         aweighting_calc();
 540
 541     if (!unit || !strcmp(unit, "fft"))
 542         fft_test();
 543
 544     return 0;
 545 }