├── .gitattributes ├── .github └── workflows │ ├── build_linux.yaml │ ├── build_macos.yaml │ └── build_windows.yaml ├── .gitignore ├── .gitmodules ├── 3rdparty ├── crossfeed │ ├── COPYING │ ├── COPYING.message_queue │ ├── Makefile │ ├── README.md │ ├── cautil.c │ ├── cautil.h │ ├── crossfeed-player.cc │ ├── crossfeed.c │ ├── crossfeed.h │ ├── designer.cc │ ├── message_queue.c │ ├── message_queue.h │ └── sndfile-crossfeed.c ├── dywapitchtrack │ ├── DOCUMENTATION.txt │ ├── README.txt │ ├── iPhone │ │ └── dywapitchtrack.xcodeproj │ │ │ └── project.pbxproj │ └── src │ │ ├── dywapitchtrack.c │ │ └── dywapitchtrack.h ├── libsndfile │ ├── AUTHORS │ ├── Building-for-Android.md │ ├── CMake │ │ ├── autogen.cmake │ │ ├── build.cmake │ │ ├── check.cmake │ │ ├── compiler_is_gcc.c │ │ ├── external_libs.cmake │ │ ├── file.cmake │ │ ├── have_decl_s_irgrp.c │ │ └── libsndfile.cmake │ ├── CMakeLists.txt │ ├── COPYING │ ├── ChangeLog │ ├── INSTALL │ ├── M4 │ │ ├── Makefile.am │ │ ├── add_cflags.m4 │ │ ├── add_cxxflags.m4 │ │ ├── clang.m4 │ │ ├── clip_mode.m4 │ │ ├── endian.m4 │ │ ├── extra_pkg.m4 │ │ ├── flexible_array.m4 │ │ ├── gcc_version.m4 │ │ ├── llrint.m4 │ │ ├── lrint.m4 │ │ ├── lrintf.m4 │ │ ├── mkoctfile_version.m4 │ │ ├── octave.m4 │ │ ├── really_gcc.m4 │ │ └── stack_protect.m4 │ ├── Makefile.am │ ├── NEWS │ ├── Octave │ │ ├── Makefile.am │ │ ├── PKG_ADD │ │ ├── Readme.txt │ │ ├── format.h │ │ ├── octave_test.m │ │ ├── octave_test.sh │ │ ├── sndfile.cc │ │ ├── sndfile_load.m │ │ ├── sndfile_play.m │ │ └── sndfile_save.m │ ├── README │ ├── README.md │ ├── Scripts │ │ ├── android-configure.sh │ │ ├── build-test-tarball.mk.in │ │ ├── clang-sanitize.sh │ │ ├── cmake-build.sh │ │ ├── cstyle.py │ │ ├── git-pre-commit-hook │ │ └── linux-to-win-cross-configure.sh │ ├── Win32 │ │ ├── Makefile.am │ │ ├── README-precompiled-dll.txt │ │ └── testprog.c │ ├── autogen.sh │ ├── configure.ac │ ├── doc │ │ ├── FAQ.html │ │ ├── Makefile.am │ │ ├── api.html │ │ ├── bugs.html │ │ ├── command.html │ │ ├── development.html │ │ ├── dither.html │ │ ├── donate.html │ │ ├── embedded_files.html │ │ ├── index.html │ │ ├── libsndfile.css.in │ │ ├── libsndfile.jpg │ │ ├── linux_games_programming.txt │ │ ├── lists.html │ │ ├── new_file_type.HOWTO │ │ ├── octave.html │ │ ├── print.css │ │ ├── sndfile_info.html │ │ ├── tutorial.html │ │ └── win32.html │ ├── echo-install-dirs.in │ ├── examples │ │ ├── Makefile.am │ │ ├── generate.c │ │ ├── generate.cs │ │ ├── list_formats.c │ │ ├── make_sine.c │ │ ├── sfprocess.c │ │ ├── sndfile-loopify.c │ │ ├── sndfile-to-text.c │ │ └── sndfilehandle.cc │ ├── libsndfile.spec.in │ ├── make_lite.py │ ├── man │ │ ├── Makefile.am │ │ ├── sndfile-cmp.1 │ │ ├── sndfile-concat.1 │ │ ├── sndfile-convert.1 │ │ ├── sndfile-info.1 │ │ ├── sndfile-interleave.1 │ │ ├── sndfile-metadata-get.1 │ │ ├── sndfile-play.1 │ │ └── sndfile-salvage.1 │ ├── programs │ │ ├── Makefile.am │ │ ├── common.c │ │ ├── common.h │ │ ├── sndfile-cmp.c │ │ ├── sndfile-concat.c │ │ ├── sndfile-convert.c │ │ ├── sndfile-deinterleave.c │ │ ├── sndfile-info.c │ │ ├── sndfile-interleave.c │ │ ├── sndfile-metadata-get.c │ │ ├── sndfile-metadata-set.c │ │ ├── sndfile-play-beos.cpp │ │ ├── sndfile-play.c │ │ ├── sndfile-salvage.c │ │ └── test-sndfile-metadata-set.py │ ├── regtest │ │ ├── Makefile.am │ │ ├── Readme.txt │ │ ├── checksum.c │ │ ├── database.c │ │ ├── regtest.h │ │ └── sndfile-regtest.c │ ├── sndfile.pc.in │ ├── src │ │ ├── ALAC │ │ │ ├── ALACAudioTypes.h │ │ │ ├── ALACBitUtilities.c │ │ │ ├── ALACBitUtilities.h │ │ │ ├── ALACDecoder.h │ │ │ ├── ALACEncoder.h │ │ │ ├── EndianPortable.h │ │ │ ├── LICENSE │ │ │ ├── ag_dec.c │ │ │ ├── ag_enc.c │ │ │ ├── aglib.h │ │ │ ├── alac_codec.h │ │ │ ├── alac_decoder.c │ │ │ ├── alac_decoder.h │ │ │ ├── alac_encoder.c │ │ │ ├── dp_dec.c │ │ │ ├── dp_enc.c │ │ │ ├── dplib.h │ │ │ ├── matrix_dec.c │ │ │ ├── matrix_enc.c │ │ │ ├── matrixlib.h │ │ │ └── shift.h │ │ ├── G72x │ │ │ ├── ChangeLog │ │ │ ├── README │ │ │ ├── README.original │ │ │ ├── g721.c │ │ │ ├── g723_16.c │ │ │ ├── g723_24.c │ │ │ ├── g723_40.c │ │ │ ├── g72x.c │ │ │ ├── g72x.h │ │ │ ├── g72x_priv.h │ │ │ └── g72x_test.c │ │ ├── GSM610 │ │ │ ├── COPYRIGHT │ │ │ ├── ChangeLog │ │ │ ├── README │ │ │ ├── add.c │ │ │ ├── code.c │ │ │ ├── config.h │ │ │ ├── decode.c │ │ │ ├── gsm.h │ │ │ ├── gsm610_priv.h │ │ │ ├── gsm_create.c │ │ │ ├── gsm_decode.c │ │ │ ├── gsm_destroy.c │ │ │ ├── gsm_encode.c │ │ │ ├── gsm_option.c │ │ │ ├── long_term.c │ │ │ ├── lpc.c │ │ │ ├── preprocess.c │ │ │ ├── rpe.c │ │ │ ├── short_term.c │ │ │ └── table.c │ │ ├── Makefile.am │ │ ├── aiff.c │ │ ├── alac.c │ │ ├── alaw.c │ │ ├── au.c │ │ ├── audio_detect.c │ │ ├── avr.c │ │ ├── binheader_writef_check.py │ │ ├── broadcast.c │ │ ├── caf.c │ │ ├── cart.c │ │ ├── chanmap.c │ │ ├── chanmap.h │ │ ├── chunk.c │ │ ├── command.c │ │ ├── common.c │ │ ├── common.h │ │ ├── create_symbols_file.py │ │ ├── dither.c │ │ ├── double64.c │ │ ├── dwd.c │ │ ├── dwvw.c │ │ ├── file_io.c │ │ ├── flac.c │ │ ├── float32.c │ │ ├── g72x.c │ │ ├── gsm610.c │ │ ├── htk.c │ │ ├── id3.c │ │ ├── ima_adpcm.c │ │ ├── ima_oki_adpcm.c │ │ ├── ima_oki_adpcm.h │ │ ├── interleave.c │ │ ├── ircam.c │ │ ├── macos.c │ │ ├── make-static-lib-hidden-privates.sh │ │ ├── mat4.c │ │ ├── mat5.c │ │ ├── mpc2k.c │ │ ├── ms_adpcm.c │ │ ├── new.c │ │ ├── nist.c │ │ ├── ogg.c │ │ ├── ogg.h │ │ ├── ogg_opus.c │ │ ├── ogg_pcm.c │ │ ├── ogg_speex.c │ │ ├── ogg_vorbis.c │ │ ├── paf.c │ │ ├── pcm.c │ │ ├── pvf.c │ │ ├── raw.c │ │ ├── rf64.c │ │ ├── rx2.c │ │ ├── sd2.c │ │ ├── sds.c │ │ ├── sf_unistd.h │ │ ├── sfconfig.h │ │ ├── sfendian.h │ │ ├── sndfile.c │ │ ├── sndfile.h.in │ │ ├── sndfile.hh │ │ ├── strings.c │ │ ├── svx.c │ │ ├── test_audio_detect.c │ │ ├── test_binheader_writef.c │ │ ├── test_broadcast_var.c │ │ ├── test_cart_var.c │ │ ├── test_conversions.c │ │ ├── test_endswap.def │ │ ├── test_endswap.tpl │ │ ├── test_file_io.c │ │ ├── test_float.c │ │ ├── test_ima_oki_adpcm.c │ │ ├── test_log_printf.c │ │ ├── test_main.c │ │ ├── test_main.h │ │ ├── test_strncpy_crlf.c │ │ ├── txw.c │ │ ├── ulaw.c │ │ ├── version-metadata.rc.in │ │ ├── voc.c │ │ ├── vox_adpcm.c │ │ ├── w64.c │ │ ├── wav.c │ │ ├── wavlike.c │ │ ├── wavlike.h │ │ ├── windows.c │ │ ├── wve.c │ │ └── xi.c │ └── tests │ │ ├── Makefile.am │ │ ├── aiff_rw_test.c │ │ ├── alaw_test.c │ │ ├── benchmark-0.0.28 │ │ ├── benchmark-1.0.0 │ │ ├── benchmark-1.0.0rc2 │ │ ├── benchmark-1.0.18pre16-hendrix │ │ ├── benchmark-1.0.18pre16-mingus │ │ ├── benchmark-1.0.6pre10-coltrane │ │ ├── benchmark-1.0.6pre10-miles │ │ ├── benchmark-latest-coltrane │ │ ├── benchmark.def │ │ ├── benchmark.tpl │ │ ├── channel_test.c │ │ ├── checksum_test.c │ │ ├── chunk_test.c │ │ ├── command_test.c │ │ ├── compression_size_test.c │ │ ├── cpp_test.cc │ │ ├── dft_cmp.c │ │ ├── dft_cmp.h │ │ ├── dither_test.c │ │ ├── dwvw_test.c │ │ ├── error_test.c │ │ ├── external_libs_test.c │ │ ├── fix_this.c │ │ ├── floating_point_test.def │ │ ├── floating_point_test.tpl │ │ ├── format_check_test.c │ │ ├── generate.c │ │ ├── generate.h │ │ ├── header_test.def │ │ ├── header_test.tpl │ │ ├── headerless_test.c │ │ ├── largefile_test.c │ │ ├── locale_test.c │ │ ├── long_read_write_test.c │ │ ├── lossy_comp_test.c │ │ ├── misc_test.c │ │ ├── multi_file_test.c │ │ ├── ogg_test.c │ │ ├── pcm_test.def │ │ ├── pcm_test.tpl │ │ ├── peak_chunk_test.c │ │ ├── pedantic-header-test.sh.in │ │ ├── pipe_test.def │ │ ├── pipe_test.tpl │ │ ├── raw_test.c │ │ ├── rdwr_test.def │ │ ├── rdwr_test.tpl │ │ ├── scale_clip_test.def │ │ ├── scale_clip_test.tpl │ │ ├── sftest.c │ │ ├── sfversion.c │ │ ├── stdin_test.c │ │ ├── stdio_test.c │ │ ├── stdout_test.c │ │ ├── string_test.c │ │ ├── test_wrapper.sh.in │ │ ├── ulaw_test.c │ │ ├── utils.def │ │ ├── utils.tpl │ │ ├── virtual_io_test.c │ │ ├── win32_ordinal_test.c │ │ ├── win32_test.c │ │ ├── write_read_test.def │ │ └── write_read_test.tpl └── soundpipe │ ├── CHANGELOG.md │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── config.def.mk │ ├── config.mk │ ├── examples │ ├── FMSine111.wav │ ├── Formant04.wav │ ├── Makefile │ ├── brendan_full.wav │ ├── config.def.mk │ ├── ex_adsr.c │ ├── ex_allpass.c │ ├── ex_atone.c │ ├── ex_autowah.c │ ├── ex_bal.c │ ├── ex_bar.c │ ├── ex_biquad.c │ ├── ex_biscale.c │ ├── ex_bitcrush.c │ ├── ex_blsaw.c │ ├── ex_blsquare.c │ ├── ex_bltriangle.c │ ├── ex_butbp.c │ ├── ex_butbr.c │ ├── ex_buthp.c │ ├── ex_butlp.c │ ├── ex_clip.c │ ├── ex_comb.c │ ├── ex_compressor.c │ ├── ex_conv.c │ ├── ex_count.c │ ├── ex_crossfade.c │ ├── ex_delay.c │ ├── ex_diskin.c │ ├── ex_dist.c │ ├── ex_dmetro.c │ ├── ex_drip.c │ ├── ex_dtrig.c │ ├── ex_dust.c │ ├── ex_eqfil.c │ ├── ex_expon.c │ ├── ex_fof.c │ ├── ex_fofilt.c │ ├── ex_fog.c │ ├── ex_fold.c │ ├── ex_foo.c │ ├── ex_fosc.c │ ├── ex_gbuzz.c │ ├── ex_gen_composite.c │ ├── ex_gen_gauss.c │ ├── ex_gen_line.c │ ├── ex_gen_rand.c │ ├── ex_gen_sine.c │ ├── ex_gen_sinesum.c │ ├── ex_gen_vals.c │ ├── ex_gen_xline.c │ ├── ex_hilbert.c │ ├── ex_in.c │ ├── ex_incr.c │ ├── ex_jcrev.c │ ├── ex_jitter.c │ ├── ex_line.c │ ├── ex_lpf18.c │ ├── ex_maygate.c │ ├── ex_metro.c │ ├── ex_mincer.c │ ├── ex_mode.c │ ├── ex_moogladder.c │ ├── ex_multichan.c │ ├── ex_music.c │ ├── ex_music.csd │ ├── ex_music2.c │ ├── ex_music3.c │ ├── ex_music4.c │ ├── ex_music5.c │ ├── ex_noise.c │ ├── ex_nsmp.c │ ├── ex_osc.c │ ├── ex_oscmorph.c │ ├── ex_padsynth.c │ ├── ex_pan2.c │ ├── ex_panst.c │ ├── ex_pareq.c │ ├── ex_paulstretch.c │ ├── ex_pdhalf.c │ ├── ex_peaklim.c │ ├── ex_phaser.c │ ├── ex_phasor.c │ ├── ex_pinknoise.c │ ├── ex_pitchamdf.c │ ├── ex_pluck.c │ ├── ex_port.c │ ├── ex_posc3.c │ ├── ex_progress.c │ ├── ex_prop.c │ ├── ex_pshift.c │ ├── ex_ptrack.c │ ├── ex_randh.c │ ├── ex_randi.c │ ├── ex_random.c │ ├── ex_reson.c │ ├── ex_reverse.c │ ├── ex_revsc.c │ ├── ex_rpt.c │ ├── ex_samphold.c │ ├── ex_scale.c │ ├── ex_scrambler.c │ ├── ex_sdelay.c │ ├── ex_slice.c │ ├── ex_smoothdelay.c │ ├── ex_streson.c │ ├── ex_switch.c │ ├── ex_tabread.c │ ├── ex_tadsr.c │ ├── ex_tblrec.c │ ├── ex_tbvcf.c │ ├── ex_tdiv.c │ ├── ex_tenv.c │ ├── ex_tenv2.c │ ├── ex_tenvx.c │ ├── ex_tevent.c │ ├── ex_tgate.c │ ├── ex_thresh.c │ ├── ex_timer.c │ ├── ex_tin.c │ ├── ex_tone.c │ ├── ex_trand.c │ ├── ex_tseg.c │ ├── ex_tseq.c │ ├── ex_vdelay.c │ ├── ex_vocoder.c │ ├── ex_waveset.c │ ├── ex_wpkorg35.c │ ├── ex_wtosc.c │ ├── ex_zitarev.c │ ├── extra │ │ ├── ex_jack.c │ │ ├── ex_padsynth.c │ │ ├── ex_rpi.c │ │ └── ex_rpi_v2.c │ ├── hh.wav │ ├── imp.wav │ ├── kick.wav │ ├── oneart.ini │ ├── oneart.wav │ ├── snare.wav │ ├── wave.plt │ └── write_plot.sh │ ├── h │ ├── adsr.h │ ├── allpass.h │ ├── atone.h │ ├── autowah.h │ ├── bal.h │ ├── bar.h │ ├── base.h │ ├── biquad.h │ ├── biscale.h │ ├── bitcrush.h │ ├── blsaw.h │ ├── blsquare.h │ ├── bltriangle.h │ ├── butbp.h │ ├── butbr.h │ ├── buthp.h │ ├── butlp.h │ ├── clip.h │ ├── comb.h │ ├── compressor.h │ ├── conv.h │ ├── count.h │ ├── crossfade.h │ ├── dcblock.h │ ├── delay.h │ ├── diskin.h │ ├── dist.h │ ├── dmetro.h │ ├── drip.h │ ├── dtrig.h │ ├── dust.h │ ├── eqfil.h │ ├── expon.h │ ├── fftwrapper.h │ ├── fof.h │ ├── fofilt.h │ ├── fog.h │ ├── fold.h │ ├── foo.h │ ├── fosc.h │ ├── ftbl.h │ ├── gbuzz.h │ ├── hilbert.h │ ├── in.h │ ├── incr.h │ ├── jack.h │ ├── jcrev.h │ ├── jitter.h │ ├── line.h │ ├── lpf18.h │ ├── maygate.h │ ├── metro.h │ ├── mincer.h │ ├── mode.h │ ├── moogladder.h │ ├── noise.h │ ├── nsmp.h │ ├── osc.h │ ├── oscmorph.h │ ├── padsynth.h │ ├── pan2.h │ ├── panst.h │ ├── pareq.h │ ├── paulstretch.h │ ├── pdhalf.h │ ├── peaklim.h │ ├── phaser.h │ ├── phasor.h │ ├── pinknoise.h │ ├── pitchamdf.h │ ├── pluck.h │ ├── port.h │ ├── posc3.h │ ├── progress.h │ ├── prop.h │ ├── pshift.h │ ├── ptrack.h │ ├── randh.h │ ├── randi.h │ ├── randmt.h │ ├── random.h │ ├── reson.h │ ├── reverse.h │ ├── revsc.h │ ├── rms.h │ ├── rpi.h │ ├── rpt.h │ ├── samphold.h │ ├── scale.h │ ├── scrambler.h │ ├── sdelay.h │ ├── slice.h │ ├── smoothdelay.h │ ├── soundpipe.h │ ├── streson.h │ ├── switch.h │ ├── tabread.h │ ├── tadsr.h │ ├── tblrec.h │ ├── tbvcf.h │ ├── tdiv.h │ ├── tenv.h │ ├── tenv2.h │ ├── tenvx.h │ ├── tevent.h │ ├── tgate.h │ ├── thresh.h │ ├── timer.h │ ├── tin.h │ ├── tone.h │ ├── trand.h │ ├── tseg.h │ ├── tseq.h │ ├── vdelay.h │ ├── vocoder.h │ ├── waveset.h │ ├── wpkorg35.h │ └── zitarev.h │ ├── lib │ ├── faust │ │ └── CUI.h │ ├── fft │ │ ├── Makefile │ │ ├── fftlib.c │ │ └── sp_fft.c │ ├── inih │ │ ├── LICENSE.txt │ │ ├── Makefile │ │ ├── ini.c │ │ └── ini.h │ ├── kissfft │ │ ├── COPYING │ │ ├── Makefile │ │ ├── README │ │ ├── _kiss_fft_guts.h │ │ ├── kiss_fft.c │ │ ├── kiss_fft.h │ │ ├── kiss_fftr.c │ │ └── kiss_fftr.h │ └── spa │ │ ├── Makefile │ │ ├── spa.c │ │ └── spa.h │ ├── modules │ ├── adsr.c │ ├── allpass.c │ ├── atone.c │ ├── autowah.c │ ├── bal.c │ ├── bar.c │ ├── base.c │ ├── biquad.c │ ├── biscale.c │ ├── bitcrush.c │ ├── blsaw.c │ ├── blsquare.c │ ├── bltriangle.c │ ├── butbp.c │ ├── butbr.c │ ├── buthp.c │ ├── butlp.c │ ├── clip.c │ ├── comb.c │ ├── compressor.c │ ├── conv.c │ ├── count.c │ ├── crossfade.c │ ├── data │ │ ├── adsr.lua │ │ ├── allpass.lua │ │ ├── atone.lua │ │ ├── autowah.lua │ │ ├── bal.lua │ │ ├── bar.lua │ │ ├── biquad.lua │ │ ├── biscale.lua │ │ ├── bitcrush.lua │ │ ├── blsaw.lua │ │ ├── blsquare.lua │ │ ├── bltriangle.lua │ │ ├── butbp.lua │ │ ├── butbr.lua │ │ ├── buthp.lua │ │ ├── butlp.lua │ │ ├── clip.lua │ │ ├── comb.lua │ │ ├── compressor.lua │ │ ├── conv.lua │ │ ├── count.lua │ │ ├── crossfade.lua │ │ ├── dcblock.lua │ │ ├── delay.lua │ │ ├── diskin.lua │ │ ├── dist.lua │ │ ├── dmetro.lua │ │ ├── drip.lua │ │ ├── dtrig.lua │ │ ├── dust.lua │ │ ├── eqfil.lua │ │ ├── expon.lua │ │ ├── fof.lua │ │ ├── fofilt.lua │ │ ├── fog.lua │ │ ├── fold.lua │ │ ├── foo.lua │ │ ├── fosc.lua │ │ ├── gbuzz.lua │ │ ├── gen_composite.lua │ │ ├── gen_file.lua │ │ ├── gen_gauss.lua │ │ ├── gen_line.lua │ │ ├── gen_rand.lua │ │ ├── gen_scrambler.lua │ │ ├── gen_sinesum.lua │ │ ├── gen_xline.lua │ │ ├── hilbert.lua │ │ ├── in.lua │ │ ├── incr.lua │ │ ├── jcrev.lua │ │ ├── jitter.lua │ │ ├── line.lua │ │ ├── lpf18.lua │ │ ├── maygate.lua │ │ ├── metro.lua │ │ ├── mincer.lua │ │ ├── mode.lua │ │ ├── moogladder.lua │ │ ├── noise.lua │ │ ├── nsmp.lua │ │ ├── osc.lua │ │ ├── oscmorph.lua │ │ ├── padsynth.lua │ │ ├── pan2.lua │ │ ├── panst.lua │ │ ├── pareq.lua │ │ ├── paulstretch.lua │ │ ├── pdhalf.lua │ │ ├── peaklim.lua │ │ ├── phaser.lua │ │ ├── phasor.lua │ │ ├── pinknoise.lua │ │ ├── pitchamdf.lua │ │ ├── pluck.lua │ │ ├── port.lua │ │ ├── posc3.lua │ │ ├── progress.lua │ │ ├── prop.lua │ │ ├── pshift.lua │ │ ├── ptrack.lua │ │ ├── randh.lua │ │ ├── randi.lua │ │ ├── random.lua │ │ ├── reson.lua │ │ ├── reverse.lua │ │ ├── revsc.lua │ │ ├── rms.lua │ │ ├── rpt.lua │ │ ├── samphold.lua │ │ ├── scale.lua │ │ ├── sdelay.lua │ │ ├── slice.lua │ │ ├── smoothdelay.lua │ │ ├── streson.lua │ │ ├── switch.lua │ │ ├── tabread.lua │ │ ├── tadsr.lua │ │ ├── tblrec.lua │ │ ├── tbvcf.lua │ │ ├── tdiv.lua │ │ ├── tenv.lua │ │ ├── tenv2.lua │ │ ├── tenvx.lua │ │ ├── tgate.lua │ │ ├── thresh.lua │ │ ├── timer.lua │ │ ├── tin.lua │ │ ├── tone.lua │ │ ├── trand.lua │ │ ├── tseg.lua │ │ ├── tseq.lua │ │ ├── vdelay.lua │ │ ├── vocoder.lua │ │ ├── waveset.lua │ │ ├── wpkorg35.lua │ │ └── zitarev.lua │ ├── dcblock.c │ ├── delay.c │ ├── diskin.c │ ├── dist.c │ ├── dmetro.c │ ├── drip.c │ ├── dtrig.c │ ├── dust.c │ ├── eqfil.c │ ├── expon.c │ ├── fftwrapper.c │ ├── fof.c │ ├── fofilt.c │ ├── fog.c │ ├── fold.c │ ├── foo.c │ ├── fosc.c │ ├── ftbl.c │ ├── gbuzz.c │ ├── hilbert.c │ ├── in.c │ ├── incr.c │ ├── jack.c │ ├── jcrev.c │ ├── jitter.c │ ├── line.c │ ├── lpf18.c │ ├── maygate.c │ ├── metro.c │ ├── mincer.c │ ├── mode.c │ ├── moogladder.c │ ├── noise.c │ ├── nsmp.c │ ├── osc.c │ ├── oscmorph.c │ ├── padsynth.c │ ├── pan2.c │ ├── panst.c │ ├── pareq.c │ ├── paulstretch.c │ ├── pdhalf.c │ ├── peaklim.c │ ├── phaser.c │ ├── phasor.c │ ├── pinknoise.c │ ├── pitchamdf.c │ ├── pluck.c │ ├── port.c │ ├── posc3.c │ ├── progress.c │ ├── prop.c │ ├── pshift.c │ ├── ptrack.c │ ├── randh.c │ ├── randi.c │ ├── randmt.c │ ├── random.c │ ├── reson.c │ ├── reverse.c │ ├── revsc.c │ ├── rms.c │ ├── rpi.c │ ├── rpt.c │ ├── samphold.c │ ├── scale.c │ ├── scrambler.c │ ├── sdelay.c │ ├── slice.c │ ├── smoothdelay.c │ ├── streson.c │ ├── switch.c │ ├── tabread.c │ ├── tadsr.c │ ├── tblrec.c │ ├── tbvcf.c │ ├── tdiv.c │ ├── tenv.c │ ├── tenv2.c │ ├── tenvx.c │ ├── tevent.c │ ├── tgate.c │ ├── thresh.c │ ├── timer.c │ ├── tin.c │ ├── tone.c │ ├── trand.c │ ├── tseg.c │ ├── tseq.c │ ├── vdelay.c │ ├── vocoder.c │ ├── waveset.c │ ├── wpkorg35.c │ └── zitarev.c │ ├── test │ ├── Makefile │ ├── all_tests.h │ ├── config.h │ ├── find_unused_tests.sh │ ├── libtap.c │ ├── md5.c │ ├── md5.h │ ├── p │ │ ├── gen.lua │ │ ├── p_adsr.c │ │ ├── p_allpass.c │ │ ├── p_atone.c │ │ ├── p_autowah.c │ │ ├── p_bal.c │ │ ├── p_bar.c │ │ ├── p_biquad.c │ │ ├── p_biscale.c │ │ ├── p_bitcrush.c │ │ ├── p_blsaw.c │ │ ├── p_blsquare.c │ │ ├── p_bltriangle.c │ │ ├── p_butbp.c │ │ ├── p_butbr.c │ │ ├── p_buthp.c │ │ ├── p_butlp.c │ │ ├── p_clip.c │ │ ├── p_comb.c │ │ ├── p_compressor.c │ │ ├── p_count.c │ │ ├── p_crossfade.c │ │ ├── p_dcblock.c │ │ ├── p_delay.c │ │ ├── p_dist.c │ │ ├── p_dmetro.c │ │ ├── p_drip.c │ │ ├── p_dust.c │ │ ├── p_eqfil.c │ │ ├── p_expon.c │ │ ├── p_fofilt.c │ │ ├── p_fold.c │ │ ├── p_hilbert.c │ │ ├── p_incr.c │ │ ├── p_jcrev.c │ │ ├── p_jitter.c │ │ ├── p_line.c │ │ ├── p_lpf18.c │ │ ├── p_maygate.c │ │ ├── p_metro.c │ │ ├── p_mode.c │ │ ├── p_moogladder.c │ │ ├── p_noise.c │ │ ├── p_pan2.c │ │ ├── p_panst.c │ │ ├── p_pareq.c │ │ ├── p_pdhalf.c │ │ ├── p_peaklim.c │ │ ├── p_phaser.c │ │ ├── p_phasor.c │ │ ├── p_pinknoise.c │ │ ├── p_pitchamdf.c │ │ ├── p_pluck.c │ │ ├── p_port.c │ │ ├── p_prop.c │ │ ├── p_pshift.c │ │ ├── p_ptrack.c │ │ ├── p_randh.c │ │ ├── p_randi.c │ │ ├── p_random.c │ │ ├── p_reson.c │ │ ├── p_reverse.c │ │ ├── p_revsc.c │ │ ├── p_rms.c │ │ ├── p_rpt.c │ │ ├── p_samphold.c │ │ ├── p_scale.c │ │ ├── p_sdelay.c │ │ ├── p_smoothdelay.c │ │ ├── p_streson.c │ │ ├── p_switch.c │ │ ├── p_tadsr.c │ │ ├── p_tbvcf.c │ │ ├── p_tdiv.c │ │ ├── p_tenv.c │ │ ├── p_tenv2.c │ │ ├── p_tenvx.c │ │ ├── p_tgate.c │ │ ├── p_thresh.c │ │ ├── p_timer.c │ │ ├── p_tin.c │ │ ├── p_tone.c │ │ ├── p_trand.c │ │ ├── p_tseg.c │ │ ├── p_vdelay.c │ │ ├── p_waveset.c │ │ ├── p_wpkorg35.c │ │ └── p_zitarev.c │ ├── perf_test │ ├── plot.plt │ ├── run.c │ ├── t │ │ ├── t_adsr.c │ │ ├── t_allpass.c │ │ ├── t_atone.c │ │ ├── t_autowah.c │ │ ├── t_bal.c │ │ ├── t_bar.c │ │ ├── t_biquad.c │ │ ├── t_biscale.c │ │ ├── t_bitcrush.c │ │ ├── t_blsaw.c │ │ ├── t_blsquare.c │ │ ├── t_bltriangle.c │ │ ├── t_butbp.c │ │ ├── t_butbr.c │ │ ├── t_buthp.c │ │ ├── t_butlp.c │ │ ├── t_clip.c │ │ ├── t_comb.c │ │ ├── t_compressor.c │ │ ├── t_conv.c │ │ ├── t_count.c │ │ ├── t_crossfade.c │ │ ├── t_dcblock.c │ │ ├── t_delay.c │ │ ├── t_diskin.c │ │ ├── t_dist.c │ │ ├── t_dmetro.c │ │ ├── t_drip.c │ │ ├── t_dtrig.c │ │ ├── t_dust.c │ │ ├── t_eqfil.c │ │ ├── t_expon.c │ │ ├── t_fof.c │ │ ├── t_fofilt.c │ │ ├── t_fog.c │ │ ├── t_fold.c │ │ ├── t_foo.c │ │ ├── t_fosc.c │ │ ├── t_gbuzz.c │ │ ├── t_gen_composite.c │ │ ├── t_gen_file.c │ │ ├── t_gen_gauss.c │ │ ├── t_gen_line.c │ │ ├── t_gen_sine.c │ │ ├── t_gen_sinesum.c │ │ ├── t_gen_vals.c │ │ ├── t_gen_xline.c │ │ ├── t_hilbert.c │ │ ├── t_incr.c │ │ ├── t_jcrev.c │ │ ├── t_jitter.c │ │ ├── t_line.c │ │ ├── t_lpf18.c │ │ ├── t_maygate.c │ │ ├── t_metro.c │ │ ├── t_mincer.c │ │ ├── t_mode.c │ │ ├── t_moogladder.c │ │ ├── t_noise.c │ │ ├── t_nsmp.c │ │ ├── t_osc.c │ │ ├── t_oscmorph.c │ │ ├── t_padsynth.c │ │ ├── t_pan2.c │ │ ├── t_panst.c │ │ ├── t_pareq.c │ │ ├── t_paulstretch.c │ │ ├── t_pdhalf.c │ │ ├── t_peaklim.c │ │ ├── t_phaser.c │ │ ├── t_phasor.c │ │ ├── t_pinknoise.c │ │ ├── t_pitchamdf.c │ │ ├── t_pluck.c │ │ ├── t_port.c │ │ ├── t_posc3.c │ │ ├── t_prop.c │ │ ├── t_pshift.c │ │ ├── t_ptrack.c │ │ ├── t_randh.c │ │ ├── t_randi.c │ │ ├── t_random.c │ │ ├── t_reverse.c │ │ ├── t_revsc.c │ │ ├── t_rpt.c │ │ ├── t_samphold.c │ │ ├── t_scale.c │ │ ├── t_sdelay.c │ │ ├── t_slice.c │ │ ├── t_smoothdelay.c │ │ ├── t_streson.c │ │ ├── t_switch.c │ │ ├── t_tabread.c │ │ ├── t_tadsr.c │ │ ├── t_tblrec.c │ │ ├── t_tbvcf.c │ │ ├── t_tdiv.c │ │ ├── t_tenv.c │ │ ├── t_tenv2.c │ │ ├── t_tenvx.c │ │ ├── t_tgate.c │ │ ├── t_thresh.c │ │ ├── t_timer.c │ │ ├── t_tone.c │ │ ├── t_trand.c │ │ ├── t_tseg.c │ │ ├── t_tseq.c │ │ ├── t_vdelay.c │ │ ├── t_vocoder.c │ │ ├── t_waveset.c │ │ ├── t_wpkorg35.c │ │ └── t_zitarev.c │ ├── tap.h │ ├── test.c │ ├── test.h │ └── write_wav.sh │ └── util │ ├── css │ ├── normalize.css │ └── skeleton.css │ ├── data2html.lua │ ├── data2txt.lua │ ├── faust │ ├── autowah.dsp │ ├── compile.sh │ ├── compressor.dsp │ ├── parse.go │ ├── pinknoise.dsp │ ├── saw.dsp │ ├── sp.c │ ├── sp_faust.c.template │ ├── square.dsp │ ├── triangle.dsp │ ├── vocoder.dsp │ └── zitarev.dsp │ ├── gen_index.lua │ ├── gendocs.sh │ ├── module_bootstrap.sh │ ├── module_howto.md │ ├── style_guide.md │ └── wav2smp.c ├── CMakeLists.txt ├── CMakePresets.json ├── LICENSE.md ├── README.md ├── ci ├── build.sh ├── config_cmake.sh └── pluginlist.txt ├── modules └── CMakeLists.txt └── plugins ├── ABTester ├── ABTester.jucer ├── CMakeLists.txt └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── AddInvert ├── AddInvert.jucer ├── CMakeLists.txt └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── CMakeLists.txt ├── ChannelMute ├── CMakeLists.txt ├── ChannelMute.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── CompensatedDelay ├── CMakeLists.txt ├── CompensatedDelay.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Compressor ├── CMakeLists.txt ├── Compressor.jucer ├── Resources │ ├── Acoustic Guitar.xml │ ├── Bass Guitar.xml │ ├── Electric Guitar.xml │ ├── Kick Snare.xml │ ├── Mix.xml │ └── Vocals.xml └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Delay ├── CMakeLists.txt ├── Delay.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── EQ3 ├── CMakeLists.txt ├── Gate.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Expander ├── CMakeLists.txt ├── Expander.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Gate ├── CMakeLists.txt ├── Gate.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── HugeGain ├── CMakeLists.txt ├── HugeGain.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Keyboard ├── CMakeLists.txt ├── Keyboard.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Limiter ├── CMakeLists.txt ├── Limiter.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Maths ├── CMakeLists.txt ├── Maths.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── Oscilloscope ├── CMakeLists.txt ├── Oscilloscope.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── PitchTrack ├── CMakeLists.txt ├── PitchTrack.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── SFX8 ├── CMakeLists.txt ├── Resources │ └── logo.png ├── SFX8.jucer └── Source │ ├── Pad.cpp │ ├── Pad.h │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ ├── PluginProcessor.h │ ├── UIComponents.cpp │ ├── UIComponents.h │ ├── Voice.cpp │ └── Voice.h ├── SampleDelay ├── CMakeLists.txt ├── SampleDelay.jucer └── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h ├── SpectrumAnalyzer ├── CMakeLists.txt ├── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h └── SpectrumAnalyzer.jucer ├── ToneGenerator ├── CMakeLists.txt ├── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h └── ToneGenerator.jucer ├── WaveLooper ├── CMakeLists.txt ├── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h └── WaveLooper.jucer ├── XYScope ├── CMakeLists.txt ├── Source │ ├── PluginEditor.cpp │ ├── PluginEditor.h │ ├── PluginProcessor.cpp │ └── PluginProcessor.h └── XYScope.jucer └── slCrossfeed ├── CMakeLists.txt ├── Source ├── PluginEditor.cpp ├── PluginEditor.h ├── PluginProcessor.cpp └── PluginProcessor.h └── slCrossfeed.jucer /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto 2 | *.jucer text eol=crlf 3 | **/AppConfig.h text eol=crlf -------------------------------------------------------------------------------- /3rdparty/crossfeed/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-O4 2 | CXXFLAGS=-O4 -std=c++11 3 | 4 | crossfeed-player: crossfeed-player.o message_queue.o crossfeed.o cautil.o 5 | $(CXX) -o crossfeed-player crossfeed-player.o message_queue.o crossfeed.o cautil.o \ 6 | -framework CoreFoundation -framework AudioUnit -framework AudioToolbox 7 | designer: designer.o 8 | $(CXX) -o designer designer.o -framework Accelerate 9 | clean: 10 | rm -f crossfeed-player.o message_queue.o crossfeed.o cautil.o crossfeed-player designer.o designer 11 | crossfeed-player.o: crossfeed-player.cc message_queue.h crossfeed.h cautil.h 12 | message_queue.o: message_queue.c message_queue.h 13 | crossfeed.o: crossfeed.c crossfeed.h 14 | cautil.o: cautil.c cautil.h 15 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Building-for-Android.md: -------------------------------------------------------------------------------- 1 | # Building for Android 2 | 3 | Assuming the Android Ndk is installed at location `/path/to/toolchain`, building 4 | libsndfile for Android (arm-linux-androideabi) should be as simple as: 5 | ``` 6 | ./autogen.sh 7 | export ANDROID_TOOLCHAIN_HOME=/path/to/android/toolchain 8 | ./Scripts/android-configure.sh 9 | make 10 | ``` 11 | The `Scripts/android-configure.sh` contains four of variables; `ANDROID_NDK_VER`, 12 | `ANDROID_GCC_VER`, `ANDROID_API_VER` and `ANDROID_TARGET` that can be overridden 13 | by setting them before the script is run. 14 | 15 | Since I (erikd), do almost zero Android development, I am happy accept patches 16 | for this documentation and script to improve its utility for real Android 17 | developers. 18 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/CMake/autogen.cmake: -------------------------------------------------------------------------------- 1 | 2 | function (lsf_autogen dir basefilename) 3 | # Only generate the file if it does not already exist. 4 | if (NOT (EXISTS "${CMAKE_SOURCE_DIR}/${dir}/${basefilename}.c")) 5 | 6 | # If it doesn't exist, but we don't have autogen its an error. 7 | if (NOT AUTOGEN) 8 | message (FATAL_ERROR "Need GNU autogen to generate '${dir}/${basefilename}.c'.") 9 | endif () 10 | 11 | execute_process ( 12 | COMMAND ${AUTOGEN} --writable ${basefilename}.def 13 | WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/${dir} 14 | ) 15 | endif () 16 | 17 | endfunction () 18 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/CMake/compiler_is_gcc.c: -------------------------------------------------------------------------------- 1 | int main (void) 2 | { 3 | #if __GNUC__ 4 | #if __clang__ 5 | This is clang 6 | # endif 7 | #else 8 | This is not GCC. 9 | #endif 10 | return 0 ; 11 | } 12 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/CMake/have_decl_s_irgrp.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main (void) 3 | { 4 | /* This will fail to compile if S_IRGRP doesn't exist. */ 5 | return S_IRGRP ; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/M4/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Process this file with automake to produce Makefile.in 2 | 3 | EXTRA_DIST = add_cflags.m4 clip_mode.m4 endian.m4 \ 4 | flexible_array.m4 llrint.m4 lrint.m4 lrintf.m4 octave.m4 extra_pkg.m4 5 | 6 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/M4/add_cflags.m4: -------------------------------------------------------------------------------- 1 | dnl @synopsis MN_ADD_CFLAGS 2 | dnl 3 | dnl Add the given option to CFLAGS, if it doesn't break the compiler 4 | 5 | AC_DEFUN([MN_ADD_CFLAGS], 6 | [AC_MSG_CHECKING([if $CC accepts $1]) 7 | ac_add_cflags__old_cflags="$CFLAGS" 8 | CFLAGS="$1" 9 | AC_TRY_LINK([ 10 | #include 11 | ], 12 | [puts("Hello, World!"); return 0;], 13 | AC_MSG_RESULT([yes]) 14 | CFLAGS="$ac_add_cflags__old_cflags $1", 15 | AC_MSG_RESULT([no]) 16 | CFLAGS="$ac_add_cflags__old_cflags" 17 | ) 18 | ])# MN_ADD_CFLAGS 19 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/M4/add_cxxflags.m4: -------------------------------------------------------------------------------- 1 | dnl @synopsis MN_ADD_CXXFLAGS 2 | dnl 3 | dnl Add the given option to CXXFLAGS, if it doesn't break the compiler 4 | 5 | AC_DEFUN([MN_ADD_CXXFLAGS], 6 | [AC_MSG_CHECKING([if $CXX accepts $1]) 7 | AC_LANG_ASSERT([C++]) 8 | ac_add_cxxflags__old_cxxflags="$CXXFLAGS" 9 | CXXFLAGS="$1" 10 | AC_TRY_LINK([ 11 | #include 12 | ], 13 | [puts("Hello, World!"); return 0;], 14 | AC_MSG_RESULT([yes]) 15 | CXXFLAGS="$ac_add_cxxflags__old_cxxflags $1", 16 | AC_MSG_RESULT([no]) 17 | CXXFLAGS="$ac_add_cxxflags__old_cxxflags" 18 | ) 19 | ])# MN_ADD_CXXFLAGS 20 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Octave/PKG_ADD: -------------------------------------------------------------------------------- 1 | autoload ("sfread", "sndfile.oct"); 2 | autoload ("sfversion", "sndfile.oct"); 3 | autoload ("sfwrite", "sndfile.oct"); 4 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Scripts/clang-sanitize.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # This is known to work with clang-3.4 from Debian testing/unstable. 4 | # 2013/07/14 5 | 6 | export CC=clang 7 | export CXX=clang++ 8 | export CFLAGS="-O3 -fsanitize=address,integer,undefined" 9 | export CXXFLAGS="-O3 -fsanitize=address,integer,undefined" 10 | 11 | ./configure --enable-gcc-werror 12 | 13 | make clean all check 14 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Scripts/cmake-build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -e 2 | 3 | rm -rf CMakeCache.txt CMakeFiles/ 4 | 5 | cmake -DWerror=on -Werror=dev -Werror=deprecated . 6 | 7 | make clean 8 | make 9 | make check 10 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Scripts/linux-to-win-cross-configure.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | case "$1" in 4 | w32) 5 | compiler_name=i686-w64-mingw32 6 | ;; 7 | w64) 8 | compiler_name=x86_64-w64-mingw32 9 | ;; 10 | *) 11 | echo "$0 (w32|w64) " 12 | exit 0 13 | ;; 14 | esac 15 | 16 | shift 17 | 18 | build_cpu=$(dpkg-architecture -qDEB_BUILD_GNU_CPU) 19 | build_host=$build_cpu-linux 20 | 21 | ./configure --host=$compiler_name --target=$compiler_name --build=$build_host \ 22 | --program-prefix='' --disable-sqlite --disable-static $@ 23 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Win32/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Process this file with automake to produce Makefile.in 2 | 3 | EXTRA_DIST = README-precompiled-dll.txt testprog.c 4 | 5 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/Win32/testprog.c: -------------------------------------------------------------------------------- 1 | /* Simple test program to make sure that Win32 linking to libsndfile is 2 | ** working. 3 | */ 4 | 5 | #include 6 | 7 | #include "sndfile.h" 8 | 9 | int 10 | main (void) 11 | { static char strbuffer [256] ; 12 | sf_command (NULL, SFC_GET_LIB_VERSION, strbuffer, sizeof (strbuffer)) ; 13 | puts (strbuffer) ; 14 | return 0 ; 15 | } 16 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/doc/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Process this file with automake to produce Makefile.in 2 | 3 | html_DATA = index.html libsndfile.jpg libsndfile.css api.html command.html \ 4 | bugs.html sndfile_info.html new_file_type.HOWTO \ 5 | win32.html FAQ.html lists.html embedded_files.html octave.html \ 6 | dither.html tutorial.html 7 | 8 | EXTRA_DIST = $(html_DATA) 9 | 10 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/doc/libsndfile.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/libsndfile/doc/libsndfile.jpg -------------------------------------------------------------------------------- /3rdparty/libsndfile/doc/print.css: -------------------------------------------------------------------------------- 1 | body { 2 | background:white; 3 | color:black; 4 | } 5 | 6 | h1{ 7 | background:white; 8 | color:black; 9 | } 10 | 11 | h2 { 12 | background:white; 13 | color:#666; 14 | } 15 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/echo-install-dirs.in: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # @configure_input@ 3 | 4 | prefix=@prefix@ 5 | exec_prefix=@exec_prefix@ 6 | libdir=@libdir@ 7 | bindir=@bindir@ 8 | pkgconfigdir=@pkgconfigdir@ 9 | datadir=@datadir@ 10 | datarootdir=@datarootdir@ 11 | docdir=@docdir@ 12 | htmldir=@htmldir@ 13 | 14 | echo " 15 | Installation directories : 16 | 17 | Library directory : ................... $libdir 18 | Program directory : ................... $bindir 19 | Pkgconfig directory : ................. $pkgconfigdir 20 | HTML docs directory : ................. $htmldir 21 | " 22 | echo "Compiling some other packages against libsndfile may require" 23 | echo "the addition of '$pkgconfigdir' to the" 24 | echo "PKG_CONFIG_PATH environment variable." 25 | echo 26 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/man/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Process this file with automake to produce Makefile.in 2 | 3 | man_MANS = sndfile-info.1 sndfile-play.1 sndfile-convert.1 sndfile-cmp.1 \ 4 | sndfile-metadata-get.1 sndfile-metadata-set.1 sndfile-concat.1 \ 5 | sndfile-interleave.1 sndfile-deinterleave.1 sndfile-salvage.1 6 | 7 | EXTRA_DIST = sndfile-info.1 sndfile-play.1 sndfile-convert.1 sndfile-cmp.1 \ 8 | sndfile-metadata-get.1 sndfile-concat.1 sndfile-interleave.1 \ 9 | sndfile-salvage.1 10 | 11 | # Same manpage for both programs. 12 | sndfile-metadata-set.1 : sndfile-metadata-get.1 13 | $(LN_S) $(srcdir)/sndfile-metadata-get.1 $@ 14 | 15 | sndfile-deinterleave.1 : sndfile-interleave.1 16 | $(LN_S) $(srcdir)/sndfile-interleave.1 $@ 17 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/man/sndfile-play.1: -------------------------------------------------------------------------------- 1 | .Dd November 2, 2014 2 | .Dt SNDFILE-PLAY 1 3 | .Os 4 | .Sh NAME 5 | .Nm sndfile-play 6 | .Nd play a sound file 7 | .Sh SYNOPSIS 8 | .Nm sndfile-play 9 | .Ar 10 | .Sh DESCRIPTION 11 | .Nm 12 | plays one or more sound files on various operating systems using standard audio 13 | output APIs. The following table summarizes which audio API is used where: 14 | .Pp 15 | .Bl -tag -width MacOSX10XXX -compact 16 | .It Linux 17 | ALSA or OSS 18 | .It OpenBSD 19 | sndio 20 | .It FreeBSD 21 | /dev/dsp (OSS) 22 | .It Solaris 23 | /dev/audio 24 | .It MacOSX 10.6 25 | CoreAudio 26 | .It MacOSX 10.7 27 | AudioToolbox 28 | .It Win32 29 | waveOut 30 | .El 31 | .Sh SEE ALSO 32 | .Lk http://www.mega-nerd.com/libsndfile/ 33 | .Sh AUTHORS 34 | .An Erik de Castro Lopo Aq Mt erikd@mega-nerd.com 35 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/regtest/Makefile.am: -------------------------------------------------------------------------------- 1 | ## Process this file with automake to produce Makefile.in 2 | 3 | bin_PROGRAMS = sndfile-regtest 4 | 5 | noinst_HEADERS = regtest.h 6 | 7 | AM_CPPFLAGS = -I$(top_srcdir)/src $(SQLITE3_CFLAGS) $(OS_SPECIFIC_CFLAGS) 8 | 9 | sndfile_regtest_SOURCES = sndfile-regtest.c database.c checksum.c 10 | sndfile_regtest_LDADD = $(top_builddir)/src/libsndfile.la $(SQLITE3_LIBS) 11 | 12 | CLEANFILES = *~ *.exe 13 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/sndfile.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | libdir=@libdir@ 4 | includedir=@includedir@ 5 | 6 | Name: sndfile 7 | Description: A library for reading and writing audio files 8 | Requires: 9 | Version: @VERSION@ 10 | Libs: -L${libdir} -lsndfile 11 | Libs.private: @EXTERNAL_XIPH_LIBS@ 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/src/G72x/README: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/libsndfile/src/G72x/README -------------------------------------------------------------------------------- /3rdparty/libsndfile/src/GSM610/COPYRIGHT: -------------------------------------------------------------------------------- 1 | Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann, 2 | Technische Universitaet Berlin 3 | 4 | Any use of this software is permitted provided that this notice is not 5 | removed and that neither the authors nor the Technische Universitaet Berlin 6 | are deemed to have made any representations as to the suitability of this 7 | software for any purpose nor are held responsible for any defects of 8 | this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. 9 | 10 | As a matter of courtesy, the authors request to be informed about uses 11 | this software has found, about bugs in this software, and about any 12 | improvements that may be of general interest. 13 | 14 | Berlin, 28.11.1994 15 | Jutta Degener 16 | Carsten Bormann 17 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/src/GSM610/gsm_destroy.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische 3 | * Universitaet Berlin. See the accompanying file "COPYRIGHT" for 4 | * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. 5 | */ 6 | 7 | #include "gsm.h" 8 | #include "config.h" 9 | 10 | #ifdef HAS_STDLIB_H 11 | # include 12 | #else 13 | # ifdef HAS_MALLOC_H 14 | # include 15 | # else 16 | extern void free () ; 17 | # endif 18 | #endif 19 | 20 | void gsm_destroy (gsm S) 21 | { 22 | if (S) 23 | free ((char *) S) ; 24 | } 25 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/src/make-static-lib-hidden-privates.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -e 2 | 3 | # This script takes a static library and removes all non-public symbols. 4 | # Ie, it makes a static lib whose symbols are far less likely to clash with 5 | # the symbols of another shared or static library. 6 | 7 | grep sf_ Symbols.gnu-binutils | sed -e "s/[ ;]//g" > Symbols.static 8 | 9 | ld -r --whole-archive .libs/libsndfile.a -o libsndfile_a.o 10 | 11 | objcopy --keep-global-symbols=Symbols.static libsndfile_a.o libsndfile.o 12 | 13 | rm -f libsndfile.a 14 | ar cru libsndfile.a libsndfile.o 15 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/src/test_endswap.def: -------------------------------------------------------------------------------- 1 | autogen definitions test_endswap.tpl; 2 | 3 | int_type = { 4 | name = short ; 5 | value = '0x3210' ; 6 | format = FMT_SHORT ; 7 | } ; 8 | 9 | int_type = { 10 | name = int ; 11 | value = '0x76543210' ; 12 | format = FMT_INT ; 13 | } ; 14 | 15 | int_type = { 16 | name = int64_t ; 17 | value = '0x0807050540302010LL' ; 18 | format = FMT_INT64 ; 19 | } ; 20 | 21 | int_size = { 22 | name = 16 ; 23 | typename = int16_t ; 24 | value = '0x4142' ; 25 | strval = "AB" ; 26 | } ; 27 | 28 | int_size = { 29 | name = 32 ; 30 | typename = int32_t ; 31 | value = '0x30313233' ; 32 | strval = "0123" ; 33 | } ; 34 | 35 | int_size = { 36 | name = 64 ; 37 | typename = int64_t ; 38 | value = '0x3031323334353637' ; 39 | strval = "01234567" ; 40 | } ; 41 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/tests/benchmark.def: -------------------------------------------------------------------------------- 1 | autogen definitions benchmark.tpl; 2 | 3 | data_type = { 4 | type_name = short ; 5 | multiplier = "32700.0" ; 6 | }; 7 | 8 | data_type = { 9 | type_name = int ; 10 | multiplier = "32700.0 * (1 << 16)" ; 11 | }; 12 | 13 | data_type = { 14 | type_name = float ; 15 | multiplier = "1.0" ; 16 | }; 17 | 18 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/tests/floating_point_test.def: -------------------------------------------------------------------------------- 1 | autogen definitions floating_point_test.tpl; 2 | 3 | endian_type = { 4 | end_name = little ; 5 | end_type = SF_ENDIAN_LITTLE ; 6 | } ; 7 | 8 | endian_type = { 9 | end_name = big ; 10 | end_type = SF_ENDIAN_BIG ; 11 | } ; 12 | 13 | float_type = { 14 | float_name = float ; 15 | minor_type = SF_FORMAT_FLOAT ; 16 | } ; 17 | 18 | float_type = { 19 | float_name = double ; 20 | minor_type = SF_FORMAT_DOUBLE ; 21 | } ; 22 | 23 | int_type = { 24 | int_name = short ; 25 | int_max = "0x7FFF" ; 26 | } ; 27 | 28 | int_type = { 29 | int_name = int ; 30 | int_max = "0x7FFFFFFF" ; 31 | } ; 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/tests/header_test.def: -------------------------------------------------------------------------------- 1 | autogen definitions header_test.tpl; 2 | 3 | data_type = { 4 | name = "short" ; 5 | format = "SF_FORMAT_PCM_16" ; 6 | } ; 7 | 8 | data_type = { 9 | name = "int" ; 10 | format = "SF_FORMAT_PCM_32" ; 11 | } ; 12 | 13 | data_type = { 14 | name = "float" ; 15 | format = "SF_FORMAT_FLOAT" ; 16 | } ; 17 | 18 | data_type = { 19 | name = "double" ; 20 | format = "SF_FORMAT_DOUBLE" ; 21 | } ; 22 | 23 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/tests/pipe_test.def: -------------------------------------------------------------------------------- 1 | autogen definitions pipe_test.tpl; 2 | 3 | data_type = { 4 | type_name = short ; 5 | }; 6 | 7 | data_type = { 8 | type_name = float ; 9 | }; 10 | 11 | data_type = { 12 | type_name = double ; 13 | }; 14 | 15 | -------------------------------------------------------------------------------- /3rdparty/libsndfile/tests/rdwr_test.def: -------------------------------------------------------------------------------- 1 | autogen definitions rdwr_test.tpl; 2 | 3 | data_type = { 4 | name = "short" ; 5 | type = "short" ; 6 | format = "SF_FORMAT_PCM_16" ; 7 | } ; 8 | 9 | data_type = { 10 | name = "int" ; 11 | type = "int" ; 12 | format = "SF_FORMAT_PCM_32" ; 13 | } ; 14 | 15 | data_type = { 16 | name = "float" ; 17 | type = "float" ; 18 | format = "SF_FORMAT_FLOAT" ; 19 | } ; 20 | 21 | data_type = { 22 | name = "double" ; 23 | type = "double" ; 24 | format = "SF_FORMAT_DOUBLE" ; 25 | } ; 26 | 27 | data_type = { 28 | name = "raw" ; 29 | type = "unsigned char" ; 30 | format = "SF_FORMAT_PCM_U8" ; 31 | } ; 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/FMSine111.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/FMSine111.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/Formant04.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/Formant04.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: default clean all 2 | 3 | default: all 4 | 5 | config.mk: config.def.mk 6 | cp config.def.mk config.mk 7 | 8 | include config.mk 9 | 10 | 11 | all: config.mk $(addsuffix .bin, $(files)) 12 | 13 | %.bin : %.c 14 | gcc -g --std=c99 -I ../h -L /usr/local/lib -I /usr/local/include $< ../libsoundpipe.a -lsndfile -o $@ -lm 15 | 16 | clean: 17 | rm -rf $(addsuffix .bin, $(files)) $(addsuffix .bin.dSYM, $(files)) test.wav plot.dat plot.png 18 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/brendan_full.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/brendan_full.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_count.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe" 2 | 3 | int main() { 4 | /* TODO */ 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_diskin.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_diskin *diskin; 8 | sp_osc *osc; 9 | sp_ftbl *ft; 10 | } UserData; 11 | 12 | void process(sp_data *sp, void *udata) { 13 | UserData *ud = udata; 14 | SPFLOAT diskin = 0; 15 | sp_diskin_compute(sp, ud->diskin, NULL, &diskin); 16 | sp->out[0] = diskin; 17 | } 18 | 19 | int main() { 20 | srand(1234567); 21 | UserData ud; 22 | sp_data *sp; 23 | sp_create(&sp); 24 | 25 | sp_diskin_create(&ud.diskin); 26 | 27 | sp_diskin_init(sp, ud.diskin, "oneart.wav"); 28 | 29 | sp->len = 44100 * 5; 30 | sp_process(sp, &ud, process); 31 | 32 | sp_diskin_destroy(&ud.diskin); 33 | 34 | sp_destroy(&sp); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_dust.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_dust *dst; 8 | } UserData; 9 | 10 | void write_dust(sp_data *sp, void *udata) { 11 | UserData *ud = udata; 12 | SPFLOAT in = 0; 13 | sp_dust_compute(sp, ud->dst, NULL, &sp->out[0]); 14 | } 15 | int main() { 16 | srand(time(NULL)); 17 | UserData ud; 18 | sp_data *sp; 19 | sp_create(&sp); 20 | sp_dust_create(&ud.dst); 21 | sp_dust_init(sp, ud.dst); 22 | ud.dst->amp = 0.3; 23 | ud.dst->density = 30; 24 | sp->len = 44100 * 5; 25 | ud.dst->bipolar = 1.0; 26 | sp_process(sp, &ud, write_dust); 27 | sp_dust_destroy(&ud.dst); 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gbuzz.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_gbuzz *buzz; 8 | sp_ftbl *ft; 9 | int counter; 10 | } UserData; 11 | 12 | void process(sp_data *sp, void *udata) { 13 | UserData *ud = udata; 14 | sp_gbuzz_compute(sp, ud->buzz, NULL, &sp->out[0]); 15 | } 16 | 17 | int main() { 18 | srand(time(NULL)); 19 | UserData ud; 20 | sp_data *sp; 21 | sp_create(&sp); 22 | sp_ftbl_create(sp, &ud.ft, 2048); 23 | sp_gbuzz_create(&ud.buzz); 24 | 25 | sp_gen_sine(sp, ud.ft); 26 | sp_gbuzz_init(sp, ud.buzz, ud.ft, 0); 27 | sp->len = 44100 * 5; 28 | sp_process(sp, &ud, process); 29 | 30 | sp_ftbl_destroy(&ud.ft); 31 | sp_gbuzz_destroy(&ud.buzz); 32 | sp_destroy(&sp); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_composite.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 1024); 9 | sp_gen_composite(sp, ft, "0.5 0.5 270 0.5"); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_gauss.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 4096); 9 | sp_gen_gauss(sp, ft, 1, 123456); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_line.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 4096); 9 | sp_gen_line(sp, ft, "0 -1 2048 1 4096 -1"); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_rand.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 16); 9 | sp_gen_rand(sp, ft, "1 0.25 2 0.25 3 0.5"); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. " 16 | "Run write_plot.sh to see the result.\n", ft->size); 17 | fclose(fp); 18 | sp_ftbl_destroy(&ft); 19 | sp_destroy(&sp); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_sine.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 4096); 9 | sp_gen_sine(sp, ft); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_sinesum.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 4096); 9 | sp_gen_sinesum(sp, ft, "1 0.5 0.25"); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_vals.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 1); 9 | 10 | /* table will automatically resize */ 11 | sp_gen_vals(sp, ft, "1 1.5 -3 5 "); 12 | int i; 13 | FILE *fp= fopen("plot.dat", "w"); 14 | for(i = 0; i < ft->size; i++) { 15 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 16 | } 17 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 18 | fclose(fp); 19 | sp_ftbl_destroy(&ft); 20 | sp_destroy(&sp); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_gen_xline.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int main() { 5 | sp_data *sp; 6 | sp_create(&sp); 7 | sp_ftbl *ft; 8 | sp_ftbl_create(sp, &ft, 4096); 9 | sp_gen_xline(sp, ft, "0 0.0001 4096 1.0"); 10 | int i; 11 | FILE *fp= fopen("plot.dat", "w"); 12 | for(i = 0; i < ft->size; i++) { 13 | fprintf(fp, "%d %g\n", i, ft->tbl[i]); 14 | } 15 | printf("%d plot points written to plot.dat. Run write_plot.sh to see the result.\n", ft->size); 16 | fclose(fp); 17 | sp_ftbl_destroy(&ft); 18 | sp_destroy(&sp); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_noise.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_noise *ns; 8 | } UserData; 9 | 10 | void write_noise(sp_data *sp, void *udata) { 11 | UserData *ud = udata; 12 | SPFLOAT in = 0; 13 | sp_noise_compute(sp, ud->ns, NULL, &sp->out[0]); 14 | } 15 | int main() { 16 | srand(time(NULL)); 17 | UserData ud; 18 | sp_data *sp; 19 | sp_create(&sp); 20 | sp_noise_create(&ud.ns); 21 | sp_noise_init(sp, ud.ns); 22 | ud.ns->amp = 0.5; 23 | sp->len = 44100 * 5; 24 | sp_process(sp, &ud, write_noise); 25 | sp_noise_destroy(&ud.ns); 26 | sp_destroy(&sp); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_phasor.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_phasor *phs; 8 | } UserData; 9 | 10 | void process(sp_data *sp, void *udata) { 11 | UserData *ud = udata; 12 | sp_phasor_compute(sp, ud->phs, NULL, &sp->out[0]); 13 | } 14 | 15 | int main() { 16 | UserData ud; 17 | sp_data *sp; 18 | sp_create(&sp); 19 | sp_phasor_create(&ud.phs); 20 | 21 | sp_phasor_init(sp, ud.phs, 0); 22 | sp->len = 44100 * 5; 23 | sp_process(sp, &ud, process); 24 | 25 | sp_phasor_destroy(&ud.phs); 26 | sp_destroy(&sp); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_pinknoise.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_pinknoise *ns; 8 | } UserData; 9 | 10 | void write_pinknoise(sp_data *sp, void *udata) { 11 | UserData *ud = udata; 12 | SPFLOAT out = 0; 13 | sp_pinknoise_compute(sp, ud->ns, NULL, &out); 14 | sp_out(sp, 0, out); 15 | } 16 | 17 | int main() { 18 | srand(time(NULL)); 19 | UserData ud; 20 | sp_data *sp; 21 | sp_create(&sp); 22 | sp_pinknoise_create(&ud.ns); 23 | sp_pinknoise_init(sp, ud.ns); 24 | sp->len = 44100 * 5; 25 | sp_process(sp, &ud, write_pinknoise); 26 | sp_pinknoise_destroy(&ud.ns); 27 | sp_destroy(&sp); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_random.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "soundpipe.h" 5 | 6 | typedef struct { 7 | sp_random *random; 8 | } UserData; 9 | 10 | void process(sp_data *sp, void *udata) { 11 | UserData *ud = udata; 12 | SPFLOAT random = 0; 13 | sp_random_compute(sp, ud->random, NULL, &random); 14 | sp->out[0] = random; 15 | } 16 | 17 | int main() { 18 | srand(1234567); 19 | UserData ud; 20 | sp_data *sp; 21 | sp_create(&sp); 22 | 23 | sp_random_create(&ud.random); 24 | 25 | sp_random_init(sp, ud.random); 26 | ud.random->min = -0.2; 27 | ud.random->max = 0.2; 28 | 29 | sp->len = 44100 * 5; 30 | sp_process(sp, &ud, process); 31 | 32 | sp_random_destroy(&ud.random); 33 | 34 | sp_destroy(&sp); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/ex_scrambler.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | 3 | typedef struct { 4 | sp_ftbl *src; 5 | sp_ftbl *dest; 6 | } UserData; 7 | 8 | static void process(sp_data *sp, void *userdata) 9 | { 10 | UserData *ud = userdata; 11 | sp_out(sp, 0, ud->dest->tbl[sp->pos]); 12 | } 13 | 14 | int main() 15 | { 16 | sp_data *sp; 17 | UserData ud; 18 | sp_create(&sp); 19 | sp_srand(sp, 12345); 20 | sp_ftbl_loadfile(sp, &ud.src, "oneart.wav"); 21 | sp_gen_scrambler(sp, ud.src, &ud.dest); 22 | sp->len = ud.src->size; 23 | sp_process(sp, &ud, process); 24 | sp_ftbl_destroy(&ud.src); 25 | sp_ftbl_destroy(&ud.dest); 26 | sp_destroy(&sp); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/hh.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/hh.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/imp.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/imp.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/kick.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/kick.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/oneart.ini: -------------------------------------------------------------------------------- 1 | ; SimpleSamp config file 2 | 3 | [allthings] 4 | pos = 5.5 5 | size = 1 6 | speed = 2 7 | 8 | [there] 9 | pos=0 10 | size=3 11 | speed =0.6 12 | 13 | [no] 14 | pos=2.2 15 | size=1 16 | 17 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/oneart.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/oneart.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/snare.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/3rdparty/soundpipe/examples/snare.wav -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/wave.plt: -------------------------------------------------------------------------------- 1 | set terminal png 2 | unset key 3 | set output "plot.png" 4 | plot "plot.dat" with lines 5 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/examples/write_plot.sh: -------------------------------------------------------------------------------- 1 | if [ ! -f "plot.dat" ] 2 | then 3 | echo 4 | echo "plot.dat does not exist!" 5 | echo "run one of the ex_gen files to produce a plot" 6 | echo 7 | exit 1 8 | fi 9 | 10 | gnuplot wave.plt 11 | 12 | echo "plot.png created!" -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/adsr.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT atk; 3 | SPFLOAT dec; 4 | SPFLOAT sus; 5 | SPFLOAT rel; 6 | uint32_t timer; 7 | uint32_t atk_time; 8 | SPFLOAT a; 9 | SPFLOAT b; 10 | SPFLOAT y; 11 | SPFLOAT x; 12 | SPFLOAT prev; 13 | int mode; 14 | } sp_adsr; 15 | 16 | int sp_adsr_create(sp_adsr **p); 17 | int sp_adsr_destroy(sp_adsr **p); 18 | int sp_adsr_init(sp_data *sp, sp_adsr *p); 19 | int sp_adsr_compute(sp_data *sp, sp_adsr *p, SPFLOAT *in, SPFLOAT *out); 20 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/allpass.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT revtime, looptime; 3 | SPFLOAT coef, prvt; 4 | sp_auxdata aux; 5 | uint32_t bufpos; 6 | uint32_t bufsize; 7 | } sp_allpass; 8 | 9 | int sp_allpass_create(sp_allpass **p); 10 | int sp_allpass_destroy(sp_allpass **p); 11 | int sp_allpass_init(sp_data *sp, sp_allpass *p, SPFLOAT looptime); 12 | int sp_allpass_compute(sp_data *sp, sp_allpass *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/atone.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT hp; 3 | SPFLOAT c1, c2, yt1, prvhp; 4 | SPFLOAT tpidsr; 5 | } sp_atone; 6 | 7 | int sp_atone_create(sp_atone **p); 8 | int sp_atone_destroy(sp_atone **p); 9 | int sp_atone_init(sp_data *sp, sp_atone *p); 10 | int sp_atone_compute(sp_data *sp, sp_atone *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/autowah.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[3]; 5 | SPFLOAT *level; 6 | SPFLOAT *wah; 7 | SPFLOAT *mix; 8 | } sp_autowah; 9 | 10 | int sp_autowah_create(sp_autowah **p); 11 | int sp_autowah_destroy(sp_autowah **p); 12 | int sp_autowah_init(sp_data *sp, sp_autowah *p); 13 | int sp_autowah_compute(sp_data *sp, sp_autowah *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/bal.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_bal{ 2 | SPFLOAT asig, csig, ihp; 3 | SPFLOAT c1, c2, prvq, prvr, prva; 4 | } sp_bal; 5 | 6 | int sp_bal_create(sp_bal **p); 7 | int sp_bal_destroy(sp_bal **p); 8 | int sp_bal_init(sp_data *sp, sp_bal *p); 9 | int sp_bal_compute(sp_data *sp, sp_bal *p, SPFLOAT *sig, SPFLOAT *comp, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/bar.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT bcL, bcR, iK, ib, scan, T30; 3 | SPFLOAT pos, vel, wid; 4 | 5 | SPFLOAT *w, *w1, *w2; 6 | int step, first; 7 | SPFLOAT s0, s1, s2, t0, t1; 8 | int i_bcL, i_bcR, N; 9 | sp_auxdata w_aux; 10 | } sp_bar; 11 | 12 | int sp_bar_create(sp_bar **p); 13 | int sp_bar_destroy(sp_bar **p); 14 | int sp_bar_init(sp_data *sp, sp_bar *p, SPFLOAT iK, SPFLOAT ib); 15 | int sp_bar_compute(sp_data *sp, sp_bar *p, SPFLOAT *in, SPFLOAT *out); 16 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/biquad.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT b0, b1, b2, a0, a1, a2, reinit, xnm1, xnm2, ynm1, ynm2, cutoff, res; 3 | SPFLOAT sr; 4 | SPFLOAT tpidsr; 5 | }sp_biquad; 6 | 7 | int sp_biquad_create(sp_biquad **p); 8 | int sp_biquad_destroy(sp_biquad **p); 9 | int sp_biquad_init(sp_data *sp, sp_biquad *p); 10 | int sp_biquad_compute(sp_data *sp, sp_biquad *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/biscale.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT min, max; 3 | } sp_biscale; 4 | 5 | int sp_biscale_create(sp_biscale **p); 6 | int sp_biscale_destroy(sp_biscale **p); 7 | int sp_biscale_init(sp_data *sp, sp_biscale *p); 8 | int sp_biscale_compute(sp_data *sp, sp_biscale *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/bitcrush.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT bitdepth; 3 | SPFLOAT srate; 4 | sp_fold *fold; 5 | } sp_bitcrush; 6 | 7 | int sp_bitcrush_create(sp_bitcrush **p); 8 | int sp_bitcrush_destroy(sp_bitcrush **p); 9 | int sp_bitcrush_init(sp_data *sp, sp_bitcrush *p); 10 | int sp_bitcrush_compute(sp_data *sp, sp_bitcrush *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/blsaw.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *ud; 3 | int argpos; 4 | SPFLOAT *args[2]; 5 | SPFLOAT *freq; 6 | SPFLOAT *amp; 7 | } sp_blsaw; 8 | 9 | int sp_blsaw_create(sp_blsaw **p); 10 | int sp_blsaw_destroy(sp_blsaw **p); 11 | int sp_blsaw_init(sp_data *sp, sp_blsaw *p); 12 | int sp_blsaw_compute(sp_data *sp, sp_blsaw *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/blsquare.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *ud; 3 | int argpos; 4 | SPFLOAT *args[3]; 5 | SPFLOAT *freq; 6 | SPFLOAT *amp; 7 | SPFLOAT *width; 8 | } sp_blsquare; 9 | 10 | int sp_blsquare_create(sp_blsquare **p); 11 | int sp_blsquare_destroy(sp_blsquare **p); 12 | int sp_blsquare_init(sp_data *sp, sp_blsquare *p); 13 | int sp_blsquare_compute(sp_data *sp, sp_blsquare *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/bltriangle.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *ud; 3 | int argpos; 4 | SPFLOAT *args[2]; 5 | SPFLOAT *freq; 6 | SPFLOAT *amp; 7 | } sp_bltriangle; 8 | 9 | int sp_bltriangle_create(sp_bltriangle **p); 10 | int sp_bltriangle_destroy(sp_bltriangle **p); 11 | int sp_bltriangle_init(sp_data *sp, sp_bltriangle *p); 12 | int sp_bltriangle_compute(sp_data *sp, sp_bltriangle *p, SPFLOAT *in, SPFLOAT *out); 13 | 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/butbp.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT sr, freq, bw, istor; 3 | SPFLOAT lkf, lkb; 4 | SPFLOAT a[8]; 5 | SPFLOAT pidsr, tpidsr; 6 | } sp_butbp; 7 | 8 | int sp_butbp_create(sp_butbp **p); 9 | int sp_butbp_destroy(sp_butbp **p); 10 | int sp_butbp_init(sp_data *sp, sp_butbp *p); 11 | int sp_butbp_compute(sp_data *sp, sp_butbp *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/butbr.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT sr, freq, bw, istor; 3 | SPFLOAT lkf, lkb; 4 | SPFLOAT a[8]; 5 | SPFLOAT pidsr, tpidsr; 6 | } sp_butbr; 7 | 8 | int sp_butbr_create(sp_butbr **p); 9 | int sp_butbr_destroy(sp_butbr **p); 10 | int sp_butbr_init(sp_data *sp, sp_butbr *p); 11 | int sp_butbr_compute(sp_data *sp, sp_butbr *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/buthp.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT sr, freq, istor; 3 | SPFLOAT lkf; 4 | SPFLOAT a[8]; 5 | SPFLOAT pidsr; 6 | } sp_buthp; 7 | 8 | int sp_buthp_create(sp_buthp **p); 9 | int sp_buthp_destroy(sp_buthp **p); 10 | int sp_buthp_init(sp_data *sp, sp_buthp *p); 11 | int sp_buthp_compute(sp_data *sp, sp_buthp *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/butlp.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT sr, freq, istor; 3 | SPFLOAT lkf; 4 | SPFLOAT a[8]; 5 | SPFLOAT pidsr; 6 | } sp_butlp; 7 | 8 | int sp_butlp_create(sp_butlp **p); 9 | int sp_butlp_destroy(sp_butlp **p); 10 | int sp_butlp_init(sp_data *sp, sp_butlp *p); 11 | int sp_butlp_compute(sp_data *sp, sp_butlp *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/clip.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT lim, k1; 3 | }sp_clip; 4 | 5 | int sp_clip_create(sp_clip **p); 6 | int sp_clip_destroy(sp_clip **p); 7 | int sp_clip_init(sp_data *sp, sp_clip *p); 8 | int sp_clip_compute(sp_data *sp, sp_clip *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/comb.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_comb{ 2 | SPFLOAT revtime, looptime; 3 | SPFLOAT coef, prvt; 4 | sp_auxdata aux; 5 | uint32_t bufpos; 6 | uint32_t bufsize; 7 | } sp_comb; 8 | 9 | int sp_comb_create(sp_comb **p); 10 | int sp_comb_destroy(sp_comb **p); 11 | int sp_comb_init(sp_data *sp, sp_comb *p, SPFLOAT looptime); 12 | int sp_comb_compute(sp_data *sp, sp_comb *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/compressor.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[4]; 5 | SPFLOAT *ratio; 6 | SPFLOAT *thresh; 7 | SPFLOAT *atk; 8 | SPFLOAT *rel; 9 | } sp_compressor; 10 | 11 | int sp_compressor_create(sp_compressor **p); 12 | int sp_compressor_destroy(sp_compressor **p); 13 | int sp_compressor_init(sp_data *sp, sp_compressor *p); 14 | int sp_compressor_compute(sp_data *sp, sp_compressor *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/conv.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT aOut[1]; 3 | SPFLOAT aIn; 4 | SPFLOAT iPartLen; 5 | SPFLOAT iSkipSamples; 6 | SPFLOAT iTotLen; 7 | int initDone; 8 | int nChannels; 9 | int cnt; 10 | int nPartitions; 11 | int partSize; 12 | int rbCnt; 13 | SPFLOAT *tmpBuf; 14 | SPFLOAT *ringBuf; 15 | SPFLOAT *IR_Data[1]; 16 | SPFLOAT *outBuffers[1]; 17 | sp_auxdata auxData; 18 | sp_ftbl *ftbl; 19 | sp_fft fft; 20 | } sp_conv; 21 | 22 | int sp_conv_create(sp_conv **p); 23 | int sp_conv_destroy(sp_conv **p); 24 | int sp_conv_init(sp_data *sp, sp_conv *p, sp_ftbl *ft, SPFLOAT iPartLen); 25 | int sp_conv_compute(sp_data *sp, sp_conv *p, SPFLOAT *in, SPFLOAT *out); 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/count.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_count{ 2 | int32_t count, curcount; 3 | int mode; 4 | } sp_count; 5 | 6 | int sp_count_create(sp_count **p); 7 | int sp_count_destroy(sp_count **p); 8 | int sp_count_init(sp_data *sp, sp_count *p); 9 | int sp_count_compute(sp_data *sp, sp_count *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/crossfade.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT pos; 3 | } sp_crossfade; 4 | 5 | int sp_crossfade_create(sp_crossfade **p); 6 | int sp_crossfade_destroy(sp_crossfade **p); 7 | int sp_crossfade_init(sp_data *sp, sp_crossfade *p); 8 | int sp_crossfade_compute(sp_data *sp, sp_crossfade *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/dcblock.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT gg; 3 | SPFLOAT outputs; 4 | SPFLOAT inputs; 5 | SPFLOAT gain; 6 | } sp_dcblock; 7 | 8 | int sp_dcblock_create(sp_dcblock **p); 9 | int sp_dcblock_destroy(sp_dcblock **p); 10 | int sp_dcblock_init(sp_data *sp, sp_dcblock *p); 11 | int sp_dcblock_compute(sp_data *sp, sp_dcblock *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/delay.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT time; 3 | SPFLOAT feedback; 4 | SPFLOAT last; 5 | sp_auxdata buf; 6 | uint32_t bufsize; 7 | uint32_t bufpos; 8 | } sp_delay; 9 | 10 | int sp_delay_create(sp_delay **p); 11 | int sp_delay_destroy(sp_delay **p); 12 | int sp_delay_init(sp_data *sp, sp_delay *p, SPFLOAT time); 13 | int sp_delay_compute(sp_data *sp, sp_delay *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/diskin.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SNDFILE *file; 3 | SF_INFO info; 4 | SPFLOAT buffer[1024]; 5 | int bufpos; 6 | int loaded; 7 | int count; 8 | } sp_diskin; 9 | 10 | int sp_diskin_create(sp_diskin **p); 11 | int sp_diskin_destroy(sp_diskin **p); 12 | int sp_diskin_init(sp_data *sp, sp_diskin *p, const char *filename); 13 | int sp_diskin_compute(sp_data *sp, sp_diskin *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/dist.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_dist{ 2 | SPFLOAT pregain, postgain, shape1, shape2, mode; 3 | } sp_dist; 4 | 5 | int sp_dist_create(sp_dist **p); 6 | int sp_dist_destroy(sp_dist **p); 7 | int sp_dist_init(sp_data *sp, sp_dist *p); 8 | int sp_dist_compute(sp_data *sp, sp_dist *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/dmetro.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT time; 3 | uint32_t counter; 4 | } sp_dmetro; 5 | 6 | int sp_dmetro_create(sp_dmetro **p); 7 | int sp_dmetro_destroy(sp_dmetro **p); 8 | int sp_dmetro_init(sp_data *sp, sp_dmetro *p); 9 | int sp_dmetro_compute(sp_data *sp, sp_dmetro *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/dtrig.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_dtrig{ 2 | sp_ftbl *ft; 3 | uint32_t counter; 4 | uint32_t pos; 5 | int running; 6 | int loop; 7 | SPFLOAT delay; 8 | SPFLOAT scale; 9 | } sp_dtrig; 10 | 11 | int sp_dtrig_create(sp_dtrig **p); 12 | int sp_dtrig_destroy(sp_dtrig **p); 13 | int sp_dtrig_init(sp_data *sp, sp_dtrig *p, sp_ftbl *ft); 14 | int sp_dtrig_compute(sp_data *sp, sp_dtrig *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/dust.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_dust{ 2 | SPFLOAT amp, density; 3 | SPFLOAT density0, thresh, scale; 4 | SPFLOAT onedsr; 5 | int bipolar; /* 1 = bipolar 0 = unipolar */ 6 | uint32_t rand; 7 | } sp_dust; 8 | 9 | int sp_dust_create(sp_dust **p); 10 | int sp_dust_destroy(sp_dust **p); 11 | int sp_dust_init(sp_data *sp, sp_dust *p); 12 | int sp_dust_compute(sp_data *sp, sp_dust *p, SPFLOAT *in, SPFLOAT *out); 13 | 14 | 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/eqfil.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, bw, gain; 3 | SPFLOAT z1,z2, sr; 4 | SPFLOAT frv, bwv; 5 | SPFLOAT c,d; 6 | } sp_eqfil; 7 | 8 | int sp_eqfil_create(sp_eqfil **p); 9 | int sp_eqfil_destroy(sp_eqfil **p); 10 | int sp_eqfil_init(sp_data *sp, sp_eqfil *p); 11 | int sp_eqfil_compute(sp_data *sp, sp_eqfil *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/expon.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT a, dur, b; 3 | SPFLOAT val, incr; 4 | uint32_t sdur, stime; 5 | int init; 6 | } sp_expon; 7 | 8 | int sp_expon_create(sp_expon **p); 9 | int sp_expon_destroy(sp_expon **p); 10 | int sp_expon_init(sp_data *sp, sp_expon *p); 11 | int sp_expon_compute(sp_data *sp, sp_expon *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/fftwrapper.h: -------------------------------------------------------------------------------- 1 | #ifdef USE_FFTW3 2 | #include 3 | #endif 4 | 5 | #define fftw_real double 6 | #define rfftw_plan fftw_plan 7 | 8 | typedef struct FFTFREQS { 9 | int size; 10 | SPFLOAT *s,*c; 11 | } FFTFREQS; 12 | 13 | typedef struct { 14 | int fftsize; 15 | #ifdef USE_FFTW3 16 | fftw_real *tmpfftdata1, *tmpfftdata2; 17 | rfftw_plan planfftw,planfftw_inv; 18 | #else 19 | kiss_fftr_cfg fft, ifft; 20 | kiss_fft_cpx *tmp1, *tmp2; 21 | #endif 22 | } FFTwrapper; 23 | 24 | void FFTwrapper_create(FFTwrapper **fw, int fftsize); 25 | void FFTwrapper_destroy(FFTwrapper **fw); 26 | 27 | void newFFTFREQS(FFTFREQS *f, int size); 28 | void deleteFFTFREQS(FFTFREQS *f); 29 | 30 | void smps2freqs(FFTwrapper *ft, SPFLOAT *smps, FFTFREQS *freqs); 31 | void freqs2smps(FFTwrapper *ft, FFTFREQS *freqs, SPFLOAT *smps); 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/fofilt.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT freq, atk, dec, istor; 3 | SPFLOAT tpidsr; 4 | SPFLOAT sr; 5 | SPFLOAT delay[4]; 6 | }sp_fofilt; 7 | 8 | int sp_fofilt_create(sp_fofilt **t); 9 | int sp_fofilt_destroy(sp_fofilt **t); 10 | int sp_fofilt_init(sp_data *sp, sp_fofilt *p); 11 | int sp_fofilt_compute(sp_data *sp, sp_fofilt *p, SPFLOAT *in, SPFLOAT *out); 12 | 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/fold.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT incr; 3 | SPFLOAT index; 4 | int32_t sample_index; 5 | SPFLOAT value; 6 | } sp_fold; 7 | 8 | int sp_fold_create(sp_fold **p); 9 | int sp_fold_destroy(sp_fold **p); 10 | int sp_fold_init(sp_data *sp, sp_fold *p); 11 | int sp_fold_compute(sp_data *sp, sp_fold *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/foo.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT bar; 3 | } sp_foo; 4 | 5 | int sp_foo_create(sp_foo **p); 6 | int sp_foo_destroy(sp_foo **p); 7 | int sp_foo_init(sp_data *sp, sp_foo *p); 8 | int sp_foo_compute(sp_data *sp, sp_foo *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/fosc.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_fosc{ 2 | SPFLOAT amp, freq, car, mod, indx, iphs; 3 | int32_t mphs, cphs; 4 | sp_ftbl *ft; 5 | } sp_fosc; 6 | 7 | int sp_fosc_create(sp_fosc **p); 8 | int sp_fosc_destroy(sp_fosc **p); 9 | int sp_fosc_init(sp_data *sp, sp_fosc *p, sp_ftbl *ft); 10 | int sp_fosc_compute(sp_data *sp, sp_fosc *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/gbuzz.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT amp, freq, nharm, lharm, mul, iphs; 3 | int16_t ampcod, cpscod, prvn; 4 | SPFLOAT prvr, twor, rsqp1, rtn, rtnp1, rsumr; 5 | int32_t lphs; 6 | int reported; 7 | SPFLOAT last; 8 | sp_ftbl *ft; 9 | } sp_gbuzz; 10 | 11 | int sp_gbuzz_create(sp_gbuzz **p); 12 | int sp_gbuzz_destroy(sp_gbuzz **p); 13 | int sp_gbuzz_init(sp_data *sp, sp_gbuzz *p, sp_ftbl *ft, SPFLOAT iphs); 14 | int sp_gbuzz_compute(sp_data *sp, sp_gbuzz *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/hilbert.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT xnm1[12], ynm1[12], coef[12]; 3 | } sp_hilbert; 4 | 5 | int sp_hilbert_create(sp_hilbert **p); 6 | int sp_hilbert_destroy(sp_hilbert **p); 7 | int sp_hilbert_init(sp_data *sp, sp_hilbert *p); 8 | int sp_hilbert_compute(sp_data *sp, sp_hilbert *p, SPFLOAT *in, SPFLOAT *out1, SPFLOAT *out2); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/in.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | FILE *fp; 3 | } sp_in; 4 | 5 | int sp_in_create(sp_in **p); 6 | int sp_in_destroy(sp_in **p); 7 | int sp_in_init(sp_data *sp, sp_in *p); 8 | int sp_in_compute(sp_data *sp, sp_in *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/incr.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT step; 3 | SPFLOAT min; 4 | SPFLOAT max; 5 | SPFLOAT val; 6 | } sp_incr; 7 | 8 | int sp_incr_create(sp_incr **p); 9 | int sp_incr_destroy(sp_incr **p); 10 | int sp_incr_init(sp_data *sp, sp_incr *p, SPFLOAT val); 11 | int sp_incr_compute(sp_data *sp, sp_incr *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/jack.h: -------------------------------------------------------------------------------- 1 | int sp_jack_process(sp_data *sp, void *ud, void (*callback)(sp_data *, void *)); 2 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/jcrev.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *ud; 3 | } sp_jcrev; 4 | 5 | int sp_jcrev_create(sp_jcrev **p); 6 | int sp_jcrev_destroy(sp_jcrev **p); 7 | int sp_jcrev_init(sp_data *sp, sp_jcrev *p); 8 | int sp_jcrev_compute(sp_data *sp, sp_jcrev *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/jitter.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_jitter{ 2 | SPFLOAT amp, cpsMin, cpsMax; 3 | SPFLOAT cps; 4 | int32_t phs; 5 | int initflag; 6 | SPFLOAT num1, num2, dfdmax; 7 | } sp_jitter; 8 | 9 | int sp_jitter_create(sp_jitter **p); 10 | int sp_jitter_destroy(sp_jitter **p); 11 | int sp_jitter_init(sp_data *sp, sp_jitter *p); 12 | int sp_jitter_compute(sp_data *sp, sp_jitter *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/line.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT a, dur, b; 3 | SPFLOAT val, incr; 4 | uint32_t sdur, stime; 5 | int init; 6 | } sp_line; 7 | 8 | int sp_line_create(sp_line **p); 9 | int sp_line_destroy(sp_line **p); 10 | int sp_line_init(sp_data *sp, sp_line *p); 11 | int sp_line_compute(sp_data *sp, sp_line *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/lpf18.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_lpf18{ 2 | SPFLOAT cutoff, res, dist; 3 | SPFLOAT ay1, ay2, aout, lastin, onedsr; 4 | } sp_lpf18; 5 | 6 | int sp_lpf18_create(sp_lpf18 **p); 7 | int sp_lpf18_destroy(sp_lpf18 **p); 8 | int sp_lpf18_init(sp_data *sp, sp_lpf18 *p); 9 | int sp_lpf18_compute(sp_data *sp, sp_lpf18 *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/maygate.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_maygate{ 2 | SPFLOAT prob; 3 | SPFLOAT gate; 4 | int mode; 5 | } sp_maygate; 6 | 7 | int sp_maygate_create(sp_maygate **p); 8 | int sp_maygate_destroy(sp_maygate **p); 9 | int sp_maygate_init(sp_data *sp, sp_maygate *p); 10 | int sp_maygate_compute(sp_data *sp, sp_maygate *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/metro.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_metro{ 2 | SPFLOAT sr, freq, iphs; 3 | SPFLOAT curphs; 4 | int flag; 5 | SPFLOAT onedsr; 6 | } sp_metro; 7 | 8 | int sp_metro_create(sp_metro **p); 9 | int sp_metro_destroy(sp_metro **p); 10 | int sp_metro_init(sp_data *sp, sp_metro *p); 11 | int sp_metro_compute(sp_data *sp, sp_metro *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/mincer.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT time, amp, pitch, lock, iN, 3 | idecim, onset, offset, dbthresh; 4 | int cnt, hsize, curframe, N, decim,tscale; 5 | SPFLOAT pos; 6 | SPFLOAT accum; 7 | sp_auxdata outframe, win, bwin, fwin, 8 | nwin, prev, framecount, indata[2]; 9 | SPFLOAT *tab; 10 | int curbuf; 11 | SPFLOAT resamp; 12 | sp_ftbl *ft; 13 | sp_fft fft; 14 | } sp_mincer; 15 | 16 | int sp_mincer_create(sp_mincer **p); 17 | int sp_mincer_destroy(sp_mincer **p); 18 | int sp_mincer_init(sp_data *sp, sp_mincer *p, sp_ftbl *ft); 19 | int sp_mincer_compute(sp_data *sp, sp_mincer *p, SPFLOAT *in, SPFLOAT *out); 20 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/mode.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT freq, q, xnm1, ynm1, ynm2, a0, a1, a2, d, lfq, lq; 3 | SPFLOAT sr; 4 | }sp_mode; 5 | 6 | int sp_mode_create(sp_mode **p); 7 | int sp_mode_destroy(sp_mode **p); 8 | int sp_mode_init(sp_data *sp, sp_mode *p); 9 | int sp_mode_compute(sp_data *sp, sp_mode *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/moogladder.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq; 3 | SPFLOAT res; 4 | SPFLOAT istor; 5 | 6 | SPFLOAT delay[6]; 7 | SPFLOAT tanhstg[3]; 8 | SPFLOAT oldfreq; 9 | SPFLOAT oldres; 10 | SPFLOAT oldacr; 11 | SPFLOAT oldtune; 12 | } sp_moogladder; 13 | 14 | int sp_moogladder_create(sp_moogladder **t); 15 | int sp_moogladder_destroy(sp_moogladder **t); 16 | int sp_moogladder_init(sp_data *sp, sp_moogladder *p); 17 | int sp_moogladder_compute(sp_data *sp, sp_moogladder *p, SPFLOAT *in, SPFLOAT *out); 18 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/noise.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT amp; 3 | }sp_noise; 4 | 5 | int sp_noise_create(sp_noise **ns); 6 | int sp_noise_init(sp_data *sp, sp_noise *ns); 7 | int sp_noise_compute(sp_data *sp, sp_noise *ns, SPFLOAT *in, SPFLOAT *out); 8 | int sp_noise_destroy(sp_noise **ns); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/osc.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, amp, iphs; 3 | int32_t lphs; 4 | sp_ftbl *tbl; 5 | int inc; 6 | } sp_osc; 7 | 8 | int sp_osc_create(sp_osc **osc); 9 | int sp_osc_destroy(sp_osc **osc); 10 | int sp_osc_init(sp_data *sp, sp_osc *osc, sp_ftbl *ft, SPFLOAT iphs); 11 | int sp_osc_compute(sp_data *sp, sp_osc *osc, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/oscmorph.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, amp, iphs; 3 | int32_t lphs; 4 | sp_ftbl **tbl; 5 | int inc; 6 | SPFLOAT wtpos; 7 | int nft; 8 | } sp_oscmorph; 9 | 10 | int sp_oscmorph_create(sp_oscmorph **p); 11 | int sp_oscmorph_destroy(sp_oscmorph **p); 12 | int sp_oscmorph_init(sp_data *sp, sp_oscmorph *osc, sp_ftbl **ft, int nft, SPFLOAT iphs); 13 | int sp_oscmorph_compute(sp_data *sp, sp_oscmorph *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/padsynth.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_padsynth { 2 | SPFLOAT cps; 3 | SPFLOAT bw; 4 | sp_ftbl *amps; 5 | } sp_padsynth; 6 | 7 | int sp_gen_padsynth(sp_data *sp, sp_ftbl *ps, sp_ftbl *amps, SPFLOAT f, SPFLOAT bw); 8 | 9 | SPFLOAT sp_padsynth_profile(SPFLOAT fi, SPFLOAT bwi); 10 | 11 | int sp_padsynth_ifft(int N, SPFLOAT *freq_amp, 12 | SPFLOAT *freq_phase, SPFLOAT *smp); 13 | 14 | int sp_padsynth_normalize(int N, SPFLOAT *smp); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pan2.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT pan; 3 | uint32_t type; 4 | } sp_pan2; 5 | 6 | int sp_pan2_create(sp_pan2 **p); 7 | int sp_pan2_destroy(sp_pan2 **p); 8 | int sp_pan2_init(sp_data *sp, sp_pan2 *p); 9 | int sp_pan2_compute(sp_data *sp, sp_pan2 *p, SPFLOAT *in, SPFLOAT *out1, SPFLOAT *out2); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/panst.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT pan; 3 | uint32_t type; 4 | } sp_panst; 5 | 6 | int sp_panst_create(sp_panst **p); 7 | int sp_panst_destroy(sp_panst **p); 8 | int sp_panst_init(sp_data *sp, sp_panst *p); 9 | int sp_panst_compute(sp_data *sp, sp_panst *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pareq.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT fc, v, q, mode; 3 | 4 | SPFLOAT xnm1, xnm2, ynm1, ynm2; 5 | SPFLOAT prv_fc, prv_v, prv_q; 6 | SPFLOAT b0, b1, b2, a1, a2; 7 | SPFLOAT tpidsr; 8 | int imode; 9 | } sp_pareq; 10 | 11 | int sp_pareq_create(sp_pareq **p); 12 | int sp_pareq_destroy(sp_pareq **p); 13 | int sp_pareq_init(sp_data *sp, sp_pareq *p); 14 | int sp_pareq_compute(sp_data *sp, sp_pareq *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pdhalf.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT amount, ibipolar, ifullscale; 3 | } sp_pdhalf; 4 | 5 | int sp_pdhalf_create(sp_pdhalf **p); 6 | int sp_pdhalf_destroy(sp_pdhalf **p); 7 | int sp_pdhalf_init(sp_data *sp, sp_pdhalf *p); 8 | int sp_pdhalf_compute(sp_data *sp, sp_pdhalf *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/peaklim.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT atk, rel, thresh; 3 | SPFLOAT patk, prel; 4 | SPFLOAT b0_r, a1_r, b0_a, a1_a, level; 5 | } sp_peaklim; 6 | 7 | int sp_peaklim_create(sp_peaklim **p); 8 | int sp_peaklim_destroy(sp_peaklim **p); 9 | int sp_peaklim_init(sp_data *sp, sp_peaklim *p); 10 | int sp_peaklim_compute(sp_data *sp, sp_peaklim *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/phaser.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[10]; 5 | SPFLOAT *MaxNotch1Freq; 6 | SPFLOAT *MinNotch1Freq; 7 | SPFLOAT *Notch_width; 8 | SPFLOAT *NotchFreq; 9 | SPFLOAT *VibratoMode; 10 | SPFLOAT *depth; 11 | SPFLOAT *feedback_gain; 12 | SPFLOAT *invert; 13 | SPFLOAT *level; 14 | SPFLOAT *lfobpm; 15 | } sp_phaser; 16 | 17 | int sp_phaser_create(sp_phaser **p); 18 | int sp_phaser_destroy(sp_phaser **p); 19 | int sp_phaser_init(sp_data *sp, sp_phaser *p); 20 | int sp_phaser_compute(sp_data *sp, sp_phaser *p, 21 | SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2); 22 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/phasor.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_phasor{ 2 | SPFLOAT freq, phs; 3 | SPFLOAT curphs, onedsr; 4 | } sp_phasor; 5 | 6 | int sp_phasor_create(sp_phasor **p); 7 | int sp_phasor_destroy(sp_phasor **p); 8 | int sp_phasor_init(sp_data *sp, sp_phasor *p, SPFLOAT iphs); 9 | int sp_phasor_compute(sp_data *sp, sp_phasor *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pinknoise.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT amp; 3 | unsigned int newrand; 4 | unsigned int prevrand; 5 | unsigned int k; 6 | unsigned int seed; 7 | unsigned int total; 8 | uint32_t counter; 9 | unsigned int dice[7]; 10 | } sp_pinknoise; 11 | 12 | int sp_pinknoise_create(sp_pinknoise **p); 13 | int sp_pinknoise_destroy(sp_pinknoise **p); 14 | int sp_pinknoise_init(sp_data *sp, sp_pinknoise *p); 15 | int sp_pinknoise_compute(sp_data *sp, sp_pinknoise *p, SPFLOAT *in, SPFLOAT *out); 16 | 17 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pluck.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT amp, freq, ifreq; 3 | SPFLOAT sicps; 4 | int32_t phs256, npts, maxpts; 5 | sp_auxdata auxch; 6 | char init; 7 | } sp_pluck; 8 | 9 | int sp_pluck_create(sp_pluck **p); 10 | int sp_pluck_destroy(sp_pluck **p); 11 | int sp_pluck_init(sp_data *sp, sp_pluck *p, SPFLOAT ifreq); 12 | int sp_pluck_compute(sp_data *sp, sp_pluck *p, SPFLOAT *trig, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/port.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT htime; 3 | SPFLOAT c1, c2, yt1, prvhtim; 4 | SPFLOAT sr, onedsr; 5 | }sp_port; 6 | 7 | int sp_port_create(sp_port **p); 8 | int sp_port_destroy(sp_port **p); 9 | int sp_port_init(sp_data *sp, sp_port *p, SPFLOAT htime); 10 | int sp_port_compute(sp_data *sp, sp_port *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/posc3.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, amp, iphs; 3 | sp_ftbl *tbl; 4 | int32_t tablen; 5 | SPFLOAT tablenUPsr; 6 | SPFLOAT phs; 7 | SPFLOAT onedsr; 8 | } sp_posc3; 9 | 10 | int sp_posc3_create(sp_posc3 **posc3); 11 | int sp_posc3_destroy(sp_posc3 **posc3); 12 | int sp_posc3_init(sp_data *sp, sp_posc3 *posc3, sp_ftbl *ft); 13 | int sp_posc3_compute(sp_data *sp, sp_posc3 *posc3, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/progress.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int nbars, skip; 3 | int counter; 4 | uint32_t len; 5 | } sp_progress; 6 | 7 | int sp_progress_create(sp_progress **p); 8 | int sp_progress_destroy(sp_progress **p); 9 | int sp_progress_init(sp_data *sp, sp_progress *p); 10 | int sp_progress_compute(sp_data *sp, sp_progress *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/pshift.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[3]; 5 | SPFLOAT *shift; 6 | SPFLOAT *window; 7 | SPFLOAT *xfade; 8 | } sp_pshift; 9 | 10 | int sp_pshift_create(sp_pshift **p); 11 | int sp_pshift_destroy(sp_pshift **p); 12 | int sp_pshift_init(sp_data *sp, sp_pshift *p); 13 | int sp_pshift_compute(sp_data *sp, sp_pshift *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/ptrack.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, amp; 3 | SPFLOAT asig,size,peak; 4 | sp_auxdata signal, prev, sin, spec1, spec2, peakarray; 5 | int numpks; 6 | int cnt; 7 | int histcnt; 8 | int hopsize; 9 | SPFLOAT sr; 10 | SPFLOAT cps; 11 | SPFLOAT dbs[20]; 12 | SPFLOAT amplo; 13 | SPFLOAT amphi; 14 | SPFLOAT npartial; 15 | SPFLOAT dbfs; 16 | SPFLOAT prevf; 17 | sp_fft fft; 18 | } sp_ptrack; 19 | 20 | int sp_ptrack_create(sp_ptrack **p); 21 | int sp_ptrack_destroy(sp_ptrack **p); 22 | int sp_ptrack_init(sp_data *sp, sp_ptrack *p, int ihopsize, int ipeaks); 23 | int sp_ptrack_compute(sp_data *sp, sp_ptrack *p, SPFLOAT *in, SPFLOAT *freq, SPFLOAT *amp); 24 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/randh.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq; 3 | SPFLOAT min, max; 4 | SPFLOAT val; 5 | uint32_t counter, dur; 6 | } sp_randh; 7 | 8 | int sp_randh_create(sp_randh **p); 9 | int sp_randh_destroy(sp_randh **p); 10 | int sp_randh_init(sp_data *sp, sp_randh *p); 11 | int sp_randh_compute(sp_data *sp, sp_randh *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/randi.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT min, max, cps, mode, fstval; 3 | int16_t cpscod; 4 | int32_t phs; 5 | SPFLOAT num1, num2, dfdmax; 6 | int holdrand; 7 | SPFLOAT sicvt; 8 | } sp_randi; 9 | 10 | int sp_randi_create(sp_randi **p); 11 | int sp_randi_destroy(sp_randi **p); 12 | int sp_randi_init(sp_data *sp, sp_randi *p); 13 | int sp_randi_compute(sp_data *sp, sp_randi *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/randmt.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int mti; 3 | /* do not change value 624 */ 4 | uint32_t mt[624]; 5 | } sp_randmt; 6 | 7 | void sp_randmt_seed(sp_randmt *p, 8 | const uint32_t *initKey, uint32_t keyLength); 9 | 10 | uint32_t sp_randmt_compute(sp_randmt *p); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/random.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT min; 3 | SPFLOAT max; 4 | } sp_random; 5 | 6 | int sp_random_create(sp_random **p); 7 | int sp_random_destroy(sp_random **p); 8 | int sp_random_init(sp_data *sp, sp_random *p); 9 | int sp_random_compute(sp_data *sp, sp_random *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/reson.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT freq, bw; 3 | int scale; 4 | SPFLOAT c1, c2, c3, yt1, yt2, cosf, prvfreq, prvbw; 5 | SPFLOAT tpidsr; 6 | } sp_reson; 7 | 8 | int sp_reson_create(sp_reson **p); 9 | int sp_reson_destroy(sp_reson **p); 10 | int sp_reson_init(sp_data *sp, sp_reson *p); 11 | int sp_reson_compute(sp_data *sp, sp_reson *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/reverse.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT delay; 3 | uint32_t bufpos; 4 | uint32_t bufsize; 5 | sp_auxdata buf; 6 | } sp_reverse; 7 | 8 | int sp_reverse_create(sp_reverse **p); 9 | int sp_reverse_destroy(sp_reverse **p); 10 | int sp_reverse_init(sp_data *sp, sp_reverse *p, SPFLOAT delay); 11 | int sp_reverse_compute(sp_data *sp, sp_reverse *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/rms.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_rms{ 2 | SPFLOAT ihp, istor; 3 | SPFLOAT c1, c2, prvq; 4 | } sp_rms; 5 | 6 | int sp_rms_create(sp_rms **p); 7 | int sp_rms_destroy(sp_rms **p); 8 | int sp_rms_init(sp_data *sp, sp_rms *p); 9 | int sp_rms_compute(sp_data *sp, sp_rms *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/rpi.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_rpi{ 2 | sp_data *sp; 3 | void *ud; 4 | void (*callback)(sp_data *, void *); 5 | }sp_rpi; 6 | int sp_rpi_process(sp_data *sp, void *ud, void (*callback)(sp_data *, void *)); 7 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/rpt.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_rpt{ 2 | uint32_t playpos; 3 | uint32_t bufpos; 4 | int running; 5 | int count, reps; 6 | SPFLOAT sr; 7 | uint32_t size; 8 | SPFLOAT bpm; 9 | int div, rep; 10 | sp_auxdata aux; 11 | int rc; 12 | } sp_rpt; 13 | 14 | int sp_rpt_create(sp_rpt **p); 15 | int sp_rpt_destroy(sp_rpt **p); 16 | int sp_rpt_init(sp_data *sp, sp_rpt *p, SPFLOAT maxdur); 17 | int sp_rpt_compute(sp_data *sp, sp_rpt *p, SPFLOAT *trig, 18 | SPFLOAT *in, SPFLOAT *out); 19 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/samphold.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT val; 3 | } sp_samphold; 4 | 5 | int sp_samphold_create(sp_samphold **p); 6 | int sp_samphold_destroy(sp_samphold **p); 7 | int sp_samphold_init(sp_data *sp, sp_samphold *p); 8 | int sp_samphold_compute(sp_data *sp, sp_samphold *p, SPFLOAT *trig, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/scale.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT min, max; 3 | } sp_scale; 4 | 5 | int sp_scale_create(sp_scale **p); 6 | int sp_scale_destroy(sp_scale **p); 7 | int sp_scale_init(sp_data *sp, sp_scale *p); 8 | int sp_scale_compute(sp_data *sp, sp_scale *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/scrambler.h: -------------------------------------------------------------------------------- 1 | int sp_gen_scrambler(sp_data *sp, sp_ftbl *src, sp_ftbl **dest); 2 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/sdelay.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int size, pos; 3 | SPFLOAT *buf; 4 | } sp_sdelay; 5 | 6 | int sp_sdelay_create(sp_sdelay **p); 7 | int sp_sdelay_destroy(sp_sdelay **p); 8 | int sp_sdelay_init(sp_data *sp, sp_sdelay *p, int size); 9 | int sp_sdelay_compute(sp_data *sp, sp_sdelay *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/slice.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | sp_ftbl *vals; 3 | sp_ftbl *buf; 4 | uint32_t id; 5 | uint32_t pos; 6 | uint32_t nextpos; 7 | } sp_slice; 8 | 9 | int sp_slice_create(sp_slice **p); 10 | int sp_slice_destroy(sp_slice **p); 11 | int sp_slice_init(sp_data *sp, sp_slice *p, sp_ftbl *vals, sp_ftbl *buf); 12 | int sp_slice_compute(sp_data *sp, sp_slice *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/smoothdelay.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT del, maxdel, pdel; 3 | SPFLOAT sr; 4 | SPFLOAT feedback; 5 | 6 | int counter; 7 | int maxcount; 8 | 9 | uint32_t maxbuf; 10 | 11 | sp_auxdata buf1; 12 | uint32_t bufpos1; 13 | uint32_t deltime1; 14 | 15 | sp_auxdata buf2; 16 | uint32_t bufpos2; 17 | uint32_t deltime2; 18 | int curbuf; 19 | } sp_smoothdelay; 20 | 21 | int sp_smoothdelay_create(sp_smoothdelay **p); 22 | int sp_smoothdelay_destroy(sp_smoothdelay **p); 23 | int sp_smoothdelay_init(sp_data *sp, sp_smoothdelay *p, 24 | SPFLOAT maxdel, uint32_t interp); 25 | int sp_smoothdelay_compute(sp_data *sp, sp_smoothdelay *p, SPFLOAT *in, SPFLOAT *out); 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/streson.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT freq, fdbgain; 3 | SPFLOAT LPdelay, APdelay; 4 | SPFLOAT *Cdelay; 5 | sp_auxdata buf; 6 | int wpointer, rpointer, size; 7 | }sp_streson; 8 | 9 | int sp_streson_create(sp_streson **p); 10 | int sp_streson_destroy(sp_streson **p); 11 | int sp_streson_init(sp_data *sp, sp_streson *p); 12 | int sp_streson_compute(sp_data *sp, sp_streson *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/switch.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT mode; 3 | } sp_switch; 4 | 5 | int sp_switch_create(sp_switch **p); 6 | int sp_switch_destroy(sp_switch **p); 7 | int sp_switch_init(sp_data *sp, sp_switch *p); 8 | int sp_switch_compute(sp_data *sp, sp_switch *p, SPFLOAT *trig, 9 | SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tabread.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT sig; 3 | SPFLOAT index, mode, offset, wrap; 4 | SPFLOAT mul; 5 | sp_ftbl *ft; 6 | } sp_tabread; 7 | 8 | int sp_tabread_create(sp_tabread **p); 9 | int sp_tabread_destroy(sp_tabread **p); 10 | int sp_tabread_init(sp_data *sp, sp_tabread *p, sp_ftbl *ft, int mode); 11 | int sp_tabread_compute(sp_data *sp, sp_tabread *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tadsr.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT value; 3 | SPFLOAT target; 4 | SPFLOAT rate; 5 | int state; 6 | SPFLOAT attackRate; 7 | SPFLOAT decayRate; 8 | SPFLOAT sustainLevel; 9 | SPFLOAT releaseRate; 10 | SPFLOAT atk; 11 | SPFLOAT rel; 12 | SPFLOAT sus; 13 | SPFLOAT dec; 14 | int mode; 15 | } sp_tadsr; 16 | 17 | int sp_tadsr_create(sp_tadsr **p); 18 | int sp_tadsr_destroy(sp_tadsr **p); 19 | int sp_tadsr_init(sp_data *sp, sp_tadsr *p); 20 | int sp_tadsr_compute(sp_data *sp, sp_tadsr *p, SPFLOAT *trig, SPFLOAT *out); 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tblrec.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | sp_ftbl *ft; 3 | uint32_t index; 4 | int record; 5 | } sp_tblrec; 6 | 7 | int sp_tblrec_create(sp_tblrec **p); 8 | int sp_tblrec_destroy(sp_tblrec **p); 9 | int sp_tblrec_init(sp_data *sp, sp_tblrec *p, sp_ftbl *ft); 10 | int sp_tblrec_compute(sp_data *sp, sp_tblrec *p, SPFLOAT *in, SPFLOAT *trig, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tbvcf.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | SPFLOAT fco, res, dist, asym, iskip, y, y1, y2; 3 | int fcocod, rezcod; 4 | SPFLOAT sr; 5 | SPFLOAT onedsr; 6 | 7 | }sp_tbvcf; 8 | 9 | int sp_tbvcf_create(sp_tbvcf **p); 10 | int sp_tbvcf_destroy(sp_tbvcf **p); 11 | int sp_tbvcf_init(sp_data *sp, sp_tbvcf *p); 12 | int sp_tbvcf_compute(sp_data *sp, sp_tbvcf *p, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tdiv.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | uint32_t num, counter, offset; 3 | } sp_tdiv; 4 | 5 | int sp_tdiv_create(sp_tdiv **p); 6 | int sp_tdiv_destroy(sp_tdiv **p); 7 | int sp_tdiv_init(sp_data *sp, sp_tdiv *p); 8 | int sp_tdiv_compute(sp_data *sp, sp_tdiv *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tenv.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_tenv{ 2 | sp_tevent *te; 3 | uint32_t pos, atk_end, rel_start, sr, totaldur; 4 | SPFLOAT atk, rel, hold; 5 | SPFLOAT atk_slp, rel_slp; 6 | SPFLOAT last; 7 | int sigmode; 8 | SPFLOAT input; 9 | } sp_tenv; 10 | 11 | int sp_tenv_create(sp_tenv **p); 12 | int sp_tenv_destroy(sp_tenv **p); 13 | int sp_tenv_init(sp_data *sp, sp_tenv *p); 14 | int sp_tenv_compute(sp_data *sp, sp_tenv *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tenv2.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int state; 3 | SPFLOAT atk, rel; 4 | uint32_t totaltime; 5 | uint32_t timer; 6 | SPFLOAT slope; 7 | SPFLOAT last; 8 | } sp_tenv2; 9 | 10 | int sp_tenv2_create(sp_tenv2 **p); 11 | int sp_tenv2_destroy(sp_tenv2 **p); 12 | int sp_tenv2_init(sp_data *sp, sp_tenv2 *p); 13 | int sp_tenv2_compute(sp_data *sp, sp_tenv2 *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tenvx.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_tenvx{ 2 | SPFLOAT atk, rel, hold; 3 | SPFLOAT patk, prel; 4 | uint32_t count; 5 | SPFLOAT a_a, b_a; 6 | SPFLOAT a_r, b_r; 7 | SPFLOAT y; 8 | } sp_tenvx; 9 | 10 | int sp_tenvx_create(sp_tenvx **p); 11 | int sp_tenvx_destroy(sp_tenvx **p); 12 | int sp_tenvx_init(sp_data *sp, sp_tenvx *p); 13 | int sp_tenvx_compute(sp_data *sp, sp_tenvx *p, SPFLOAT *in, SPFLOAT *out); 14 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tevent.h: -------------------------------------------------------------------------------- 1 | typedef struct{ 2 | void (*reinit)(void *); 3 | void (*compute)(void *, SPFLOAT *out); 4 | void *ud; 5 | int started; 6 | }sp_tevent; 7 | 8 | int sp_tevent_create(sp_tevent **te); 9 | int sp_tevent_destroy(sp_tevent **te); 10 | int sp_tevent_init(sp_data *sp, sp_tevent *te, 11 | void (*reinit)(void*), void (*compute)(void *, SPFLOAT *out), void *ud); 12 | int sp_tevent_compute(sp_data *sp, sp_tevent *te, SPFLOAT *in, SPFLOAT *out); 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tgate.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT time; 3 | uint32_t timer; 4 | } sp_tgate; 5 | 6 | int sp_tgate_create(sp_tgate **p); 7 | int sp_tgate_destroy(sp_tgate **p); 8 | int sp_tgate_init(sp_data *sp, sp_tgate *p); 9 | int sp_tgate_compute(sp_data *sp, sp_tgate *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/thresh.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int mode, init; 3 | SPFLOAT prev, thresh; 4 | } sp_thresh; 5 | 6 | int sp_thresh_create(sp_thresh **p); 7 | int sp_thresh_destroy(sp_thresh **p); 8 | int sp_thresh_init(sp_data *sp, sp_thresh *p); 9 | int sp_thresh_compute(sp_data *sp, sp_thresh *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/timer.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int mode; 3 | uint32_t pos; 4 | SPFLOAT time; 5 | } sp_timer; 6 | 7 | int sp_timer_create(sp_timer **p); 8 | int sp_timer_destroy(sp_timer **p); 9 | int sp_timer_init(sp_data *sp, sp_timer *p); 10 | int sp_timer_compute(sp_data *sp, sp_timer *p, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tin.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | FILE *fp; 3 | SPFLOAT val; 4 | } sp_tin; 5 | 6 | int sp_tin_create(sp_tin **p); 7 | int sp_tin_destroy(sp_tin **p); 8 | int sp_tin_init(sp_data *sp, sp_tin *p); 9 | int sp_tin_compute(sp_data *sp, sp_tin *p, SPFLOAT *in, SPFLOAT *out); 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tone.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT hp; 3 | SPFLOAT c1, c2, yt1, prvhp; 4 | SPFLOAT tpidsr; 5 | } sp_tone; 6 | 7 | int sp_tone_create(sp_tone **t); 8 | int sp_tone_destroy(sp_tone **t); 9 | int sp_tone_init(sp_data *sp, sp_tone *t); 10 | int sp_tone_compute(sp_data *sp, sp_tone *t, SPFLOAT *in, SPFLOAT *out); 11 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/trand.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT min, max, val; 3 | } sp_trand; 4 | 5 | int sp_trand_create(sp_trand **p); 6 | int sp_trand_destroy(sp_trand **p); 7 | int sp_trand_init(sp_data *sp, sp_trand *p); 8 | int sp_trand_compute(sp_data *sp, sp_trand *p, SPFLOAT *in, SPFLOAT *out); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tseg.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT beg,dur,end; 3 | uint32_t steps; 4 | uint32_t count; 5 | SPFLOAT val; 6 | SPFLOAT type; 7 | SPFLOAT slope; 8 | SPFLOAT tdivnsteps; 9 | } sp_tseg; 10 | 11 | int sp_tseg_create(sp_tseg **p); 12 | int sp_tseg_destroy(sp_tseg **p); 13 | int sp_tseg_init(sp_data *sp, sp_tseg *p, SPFLOAT ibeg); 14 | int sp_tseg_compute(sp_data *sp, sp_tseg *p, SPFLOAT *in, SPFLOAT *out); 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/tseq.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_tseq { 2 | sp_ftbl *ft; 3 | SPFLOAT val; 4 | int32_t pos; 5 | int shuf; 6 | } sp_tseq; 7 | 8 | int sp_tseq_create(sp_tseq **p); 9 | int sp_tseq_destroy(sp_tseq **p); 10 | int sp_tseq_init(sp_data *sp, sp_tseq *p, sp_ftbl *ft); 11 | int sp_tseq_compute(sp_data *sp, sp_tseq *p, SPFLOAT *trig, SPFLOAT *val); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/vdelay.h: -------------------------------------------------------------------------------- 1 | typedef struct sp_vdelay{ 2 | SPFLOAT del, maxdel; 3 | SPFLOAT sr; 4 | sp_auxdata buf; 5 | int32_t left; 6 | } sp_vdelay; 7 | 8 | int sp_vdelay_create(sp_vdelay **p); 9 | int sp_vdelay_destroy(sp_vdelay **p); 10 | int sp_vdelay_init(sp_data *sp, sp_vdelay *p, SPFLOAT maxdel); 11 | int sp_vdelay_compute(sp_data *sp, sp_vdelay *p, SPFLOAT *in, SPFLOAT *out); 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/vocoder.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[3]; 5 | SPFLOAT *atk; 6 | SPFLOAT *rel; 7 | SPFLOAT *bwratio; 8 | } sp_vocoder; 9 | 10 | int sp_vocoder_create(sp_vocoder **p); 11 | int sp_vocoder_destroy(sp_vocoder **p); 12 | int sp_vocoder_init(sp_data *sp, sp_vocoder *p); 13 | int sp_vocoder_compute(sp_data *sp, sp_vocoder *p, SPFLOAT *source, SPFLOAT *excite, SPFLOAT *out); 14 | 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/waveset.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | SPFLOAT rep, len; 3 | sp_auxdata auxch; 4 | int32_t length; 5 | int32_t cnt; 6 | int32_t start; 7 | int32_t current; 8 | int32_t direction; 9 | int32_t end; 10 | SPFLOAT lastsamp; 11 | int32_t noinsert; 12 | } sp_waveset; 13 | 14 | int sp_waveset_create(sp_waveset **p); 15 | int sp_waveset_destroy(sp_waveset **p); 16 | int sp_waveset_init(sp_data *sp, sp_waveset *p, SPFLOAT ilen); 17 | int sp_waveset_compute(sp_data *sp, sp_waveset *p, SPFLOAT *in, SPFLOAT *out); 18 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/wpkorg35.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | /* LPF1 */ 3 | SPFLOAT lpf1_a; 4 | SPFLOAT lpf1_z; 5 | 6 | /* LPF2 */ 7 | SPFLOAT lpf2_a; 8 | SPFLOAT lpf2_b; 9 | SPFLOAT lpf2_z; 10 | 11 | /* HPF */ 12 | SPFLOAT hpf_a; 13 | SPFLOAT hpf_b; 14 | SPFLOAT hpf_z; 15 | 16 | SPFLOAT alpha; 17 | 18 | SPFLOAT cutoff; 19 | SPFLOAT res; 20 | SPFLOAT saturation; 21 | 22 | SPFLOAT pcutoff; 23 | SPFLOAT pres; 24 | 25 | uint32_t nonlinear; 26 | } sp_wpkorg35; 27 | 28 | int sp_wpkorg35_create(sp_wpkorg35 **p); 29 | int sp_wpkorg35_destroy(sp_wpkorg35 **p); 30 | int sp_wpkorg35_init(sp_data *sp, sp_wpkorg35 *p); 31 | int sp_wpkorg35_compute(sp_data *sp, sp_wpkorg35 *p, SPFLOAT *in, SPFLOAT *out); 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/h/zitarev.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | void *faust; 3 | int argpos; 4 | SPFLOAT *args[11]; 5 | SPFLOAT *in_delay; 6 | SPFLOAT *lf_x; 7 | SPFLOAT *rt60_low; 8 | SPFLOAT *rt60_mid; 9 | SPFLOAT *hf_damping; 10 | SPFLOAT *eq1_freq; 11 | SPFLOAT *eq1_level; 12 | SPFLOAT *eq2_freq; 13 | SPFLOAT *eq2_level; 14 | SPFLOAT *mix; 15 | SPFLOAT *level; 16 | } sp_zitarev; 17 | 18 | int sp_zitarev_create(sp_zitarev **p); 19 | int sp_zitarev_destroy(sp_zitarev **p); 20 | int sp_zitarev_init(sp_data *sp, sp_zitarev *p); 21 | int sp_zitarev_compute(sp_data *sp, sp_zitarev *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out1, SPFLOAT *out2); 22 | 23 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/faust/CUI.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifndef FAUSTFLOAT 4 | #define FAUSTFLOAT SPFLOAT 5 | #endif 6 | 7 | typedef void (* addHorizontalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step); 8 | typedef void (* addVerticalSliderFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step); 9 | typedef void (* addCheckButtonFun) (void* ui_interface, const char* label, FAUSTFLOAT* zone); 10 | 11 | typedef struct { 12 | void* uiInterface; 13 | addHorizontalSliderFun addHorizontalSlider; 14 | addVerticalSliderFun addVerticalSlider; 15 | addCheckButtonFun addCheckButton; 16 | } UIGlue; 17 | 18 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/fft/Makefile: -------------------------------------------------------------------------------- 1 | LPATHS += $(LIBDIR)/fft/fft.o 2 | UTIL += $(LIBDIR)/fft/fft.c 3 | 4 | $(LIBDIR)/fft: 5 | mkdir -p $@ 6 | 7 | $(LIBDIR)/fft/fft.c: lib/fft/fftlib.c lib/fft/sp_fft.c | $(LIBDIR)/fft 8 | echo "/* THIS IS A GENERATED FILE. DO NOT EDIT BY HAND */" > $@ 9 | cat $^ >> $@ 10 | 11 | $(LIBDIR)/fft/fft.o: $(LIBDIR)/fft/fft.c | $(LIBDIR)/fft 12 | $(CC) $< -c $(CFLAGS) -o $@ 13 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/inih/Makefile: -------------------------------------------------------------------------------- 1 | LPATHS += $(LIBDIR)/inih/ini.o 2 | CFLAGS += -Ilib/inih/ 3 | 4 | $(LIBDIR)/inih: 5 | mkdir -p $@ 6 | 7 | $(LIBDIR)/inih/ini.o: lib/inih/ini.c | $(LIBDIR)/inih 8 | $(CC) $(CFLAGS) $< -c -o $@ 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/kissfft/Makefile: -------------------------------------------------------------------------------- 1 | LPATHS += $(LIBDIR)/kissfft/kiss_fft.o $(LIBDIR)/kissfft/kiss_fftr.o 2 | CFLAGS += -Ilib/kissfft/ -Dkiss_fft_scalar=float 3 | 4 | $(LIBDIR)/kissfft: 5 | mkdir -p $@ 6 | 7 | $(LIBDIR)/kissfft/kiss_fft.o: lib/kissfft/kiss_fft.c | $(LIBDIR)/kissfft 8 | $(CC) $< -c $(CFLAGS) -o $@ 9 | 10 | $(LIBDIR)/kissfft/kiss_fftr.o: lib/kissfft/kiss_fftr.c | $(LIBDIR)/kissfft 11 | $(CC) $< -c $(CFLAGS) -o $@ 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/spa/Makefile: -------------------------------------------------------------------------------- 1 | LPATHS += $(LIBDIR)/spa/spa.o 2 | CFLAGS += -Ilib/spa/ 3 | HPATHS += lib/spa/spa.h 4 | 5 | $(LIBDIR)/spa: 6 | mkdir -p $@ 7 | 8 | $(LIBDIR)/spa/spa.o: lib/spa/spa.c | $(LIBDIR)/spa 9 | gcc $(CFLAGS) $< -c -o $@ 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/lib/spa/spa.h: -------------------------------------------------------------------------------- 1 | enum { SPA_READ, SPA_WRITE, SPA_NULL }; 2 | 3 | typedef struct { 4 | char magic; 5 | char nchan; 6 | uint16_t sr; 7 | uint32_t len; 8 | } spa_header; 9 | 10 | typedef struct { 11 | spa_header header; 12 | size_t offset; 13 | int mode; 14 | FILE *fp; 15 | uint32_t pos; 16 | } sp_audio; 17 | int spa_open(sp_data *sp, sp_audio *spa, const char *name, int mode); 18 | int spa_write_buf(sp_data *sp, sp_audio *spa, SPFLOAT *buf, uint32_t size); 19 | int spa_read_buf(sp_data *sp, sp_audio *spa, SPFLOAT *buf, uint32_t size); 20 | int spa_close(sp_audio *spa); 21 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/biscale.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_biscale_create(sp_biscale **p) 5 | { 6 | *p = malloc(sizeof(sp_biscale)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_biscale_destroy(sp_biscale **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_biscale_init(sp_data *sp, sp_biscale *p) 17 | { 18 | p->min = 0; 19 | p->max = 1; 20 | return SP_OK; 21 | } 22 | 23 | int sp_biscale_compute(sp_data *sp, sp_biscale *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | *out = p->min + (*in + 1.0) / 2.0 * (p->max - p->min); 26 | return SP_OK; 27 | } 28 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/crossfade.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_crossfade_create(sp_crossfade **p) 5 | { 6 | *p = malloc(sizeof(sp_crossfade)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_crossfade_destroy(sp_crossfade **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_crossfade_init(sp_data *sp, sp_crossfade *p) 17 | { 18 | p->pos = 0.5; 19 | return SP_OK; 20 | } 21 | 22 | int sp_crossfade_compute(sp_data *sp, sp_crossfade *p, SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out) 23 | { 24 | *out = *in2 * p->pos + *in1 * (1 - p->pos); 25 | return SP_OK; 26 | } 27 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/dcblock.lua: -------------------------------------------------------------------------------- 1 | sptbl["dcblock"] = { 2 | 3 | files = { 4 | module = "dcblock.c", 5 | header = "dcblock.h", 6 | }, 7 | 8 | func = { 9 | create = "sp_dcblock_create", 10 | destroy = "sp_dcblock_destroy", 11 | init = "sp_dcblock_init", 12 | compute = "sp_dcblock_compute", 13 | }, 14 | 15 | params = { 16 | }, 17 | 18 | modtype = "module", 19 | 20 | description = [[A simple DC block filter]], 21 | 22 | ninputs = 1, 23 | noutputs = 1, 24 | 25 | inputs = { 26 | { 27 | name = "in", 28 | description = "Signal input" 29 | }, 30 | }, 31 | 32 | outputs = { 33 | { 34 | name = "out", 35 | description = "Signal output" 36 | }, 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_file.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_file"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | --example = "ex_gen_file.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_file", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "filename", 16 | type = "const char *", 17 | description = [[filename]], 18 | default = "file.wav" 19 | }, 20 | }, 21 | 22 | modtype = "gen", 23 | 24 | description = [[Reads from a wav file 25 | 26 | This will only load as many samples as the length of the ftable.]], 27 | 28 | } 29 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_gauss.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_gauss"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | example = "ex_gen_gauss.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_gauss", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "scale", 16 | type = "SPFLOAT", 17 | description = [[The scale of the distribution, in the range of -/+scale]], 18 | default = 123456 19 | }, 20 | { 21 | name = "seed", 22 | type = "uint32_t", 23 | description = [[Random seed.]], 24 | default = 123456 25 | }, 26 | }, 27 | 28 | modtype = "gen", 29 | 30 | description = [[Gaussian distribution]], 31 | 32 | } 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_line.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_line"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | example = "ex_gen_line.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_line", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "argstring", 16 | type = "char *", 17 | description = [[A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.]], 18 | default = "0 0 4096 1" 19 | }, 20 | }, 21 | 22 | modtype = "gen", 23 | 24 | description = [[A series of line segments]], 25 | 26 | } 27 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_rand.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_rand"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | example = "ex_gen_rand.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_rand", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "argstring", 16 | type = "char *", 17 | description = [[A string of value pairs. The first value is the value, then the probability.]], 18 | default = "1 0.5 2 0.5" 19 | }, 20 | }, 21 | 22 | modtype = "gen", 23 | 24 | description = [[Generates a user defined random number distribution.]], 25 | 26 | } 27 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_sinesum.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_sinesum"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | example = "ex_gen_sinesum.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_sinesum", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "argstring", 16 | type = "char *", 17 | description = [[A list of amplitudes, in the range 0-1, separated by spaces.Each position coordinates to their partial number. Position 1 is the fundamental amplitude (1 * freq). Position 2 is the first overtone (2 * freq), 3 is the second (3 * freq), etc...]], 18 | default = "1 0.5 0.25" 19 | }, 20 | }, 21 | 22 | modtype = "gen", 23 | 24 | description = [[Waveform as a sum of harmonically related sine waves ]], 25 | 26 | } 27 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/data/gen_xline.lua: -------------------------------------------------------------------------------- 1 | sptbl["gen_xline"] = { 2 | 3 | files = { 4 | module = "ftbl.c", 5 | header = "ftbl.h", 6 | example = "ex_gen_xline.c", 7 | }, 8 | 9 | func = { 10 | name = "sp_gen_xline", 11 | }, 12 | 13 | params = { 14 | { 15 | name = "argstring", 16 | type = "char *", 17 | description = [[A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.]], 18 | default = "0 0 4096 1" 19 | }, 20 | }, 21 | 22 | modtype = "gen", 23 | 24 | description = [[A series of exponential segments]], 25 | 26 | } 27 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/dmetro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_dmetro_create(sp_dmetro **p) 5 | { 6 | *p = malloc(sizeof(sp_dmetro)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_dmetro_destroy(sp_dmetro **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_dmetro_init(sp_data *sp, sp_dmetro *p) 17 | { 18 | p->counter = 0; 19 | p->time = 1.0; 20 | return SP_OK; 21 | } 22 | 23 | int sp_dmetro_compute(sp_data *sp, sp_dmetro *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | *out = 0; 26 | 27 | if(p->counter == 0) { 28 | *out = 1.0; 29 | p->counter = (int)(sp->sr * p->time) + 1; 30 | } 31 | 32 | p->counter--; 33 | 34 | return SP_OK; 35 | } 36 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/foo.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Foo 3 | * 4 | * This is a dummy module. It doesn't do much. 5 | * Feel free to use this as a boilerplate template. 6 | * 7 | */ 8 | 9 | #include 10 | #include "soundpipe.h" 11 | 12 | int sp_foo_create(sp_foo **p) 13 | { 14 | *p = malloc(sizeof(sp_foo)); 15 | return SP_OK; 16 | } 17 | 18 | int sp_foo_destroy(sp_foo **p) 19 | { 20 | free(*p); 21 | return SP_OK; 22 | } 23 | 24 | int sp_foo_init(sp_data *sp, sp_foo *p) 25 | { 26 | /* Initalize variables here. */ 27 | p->bar = 123; 28 | return SP_OK; 29 | } 30 | 31 | int sp_foo_compute(sp_data *sp, sp_foo *p, SPFLOAT *in, SPFLOAT *out) 32 | { 33 | /* Send the signal's input to the output */ 34 | *out = *in; 35 | return SP_OK; 36 | } 37 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/in.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_in_create(sp_in **p) 5 | { 6 | *p = malloc(sizeof(sp_in)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_in_destroy(sp_in **p) 11 | { 12 | sp_in *pp = *p; 13 | fclose(pp->fp); 14 | free(*p); 15 | return SP_OK; 16 | } 17 | 18 | int sp_in_init(sp_data *sp, sp_in *p) 19 | { 20 | p->fp = stdin; 21 | return SP_OK; 22 | } 23 | 24 | int sp_in_compute(sp_data *sp, sp_in *p, SPFLOAT *in, SPFLOAT *out) 25 | { 26 | *out = 0; 27 | fread(out, sizeof(SPFLOAT), 1, p->fp); 28 | return SP_OK; 29 | } 30 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/noise.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | 5 | int sp_noise_create(sp_noise **ns) 6 | { 7 | *ns = malloc(sizeof(sp_noise)); 8 | return SP_OK; 9 | } 10 | 11 | int sp_noise_init(sp_data *sp, sp_noise *ns) 12 | { 13 | ns->amp = 1.0; 14 | return SP_OK; 15 | } 16 | 17 | int sp_noise_compute(sp_data *sp, sp_noise *ns, SPFLOAT *in, SPFLOAT *out) 18 | { 19 | *out = ((sp_rand(sp) % RAND_MAX) / (SP_RANDMAX * 1.0)); 20 | *out = (*out * 2) - 1; 21 | *out *= ns->amp; 22 | return SP_OK; 23 | } 24 | 25 | int sp_noise_destroy(sp_noise **ns) 26 | { 27 | free(*ns); 28 | return SP_OK; 29 | } 30 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/random.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_random_create(sp_random **p) 5 | { 6 | *p = malloc(sizeof(sp_random)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_random_destroy(sp_random **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_random_init(sp_data *sp, sp_random *p) 17 | { 18 | p->min = -1; 19 | p->max = 1; 20 | return SP_OK; 21 | } 22 | 23 | int sp_random_compute(sp_data *sp, sp_random *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | /* Send the signal's input to the output */ 26 | SPFLOAT rnd = ((sp_rand(sp) % RAND_MAX) / (RAND_MAX * 1.0)); 27 | rnd *= (p->max - p->min); 28 | rnd += p->min; 29 | *out = rnd; 30 | return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/samphold.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_samphold_create(sp_samphold **p) 5 | { 6 | *p = malloc(sizeof(sp_samphold)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_samphold_destroy(sp_samphold **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_samphold_init(sp_data *sp, sp_samphold *p) 17 | { 18 | p->val = 0; 19 | return SP_OK; 20 | } 21 | 22 | int sp_samphold_compute(sp_data *sp, sp_samphold *p, SPFLOAT *trig, SPFLOAT *in, SPFLOAT *out) 23 | { 24 | if(*trig != 0) { 25 | p->val = *in; 26 | } 27 | *out = p->val; 28 | return SP_OK; 29 | } 30 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/scale.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_scale_create(sp_scale **p) 5 | { 6 | *p = malloc(sizeof(sp_scale)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_scale_destroy(sp_scale **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_scale_init(sp_data *sp, sp_scale *p) 17 | { 18 | p->min = -1; 19 | p->max = 1; 20 | return SP_OK; 21 | } 22 | 23 | int sp_scale_compute(sp_data *sp, sp_scale *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | *out = *in * (p->max - p->min) + p->min; 26 | return SP_OK; 27 | } 28 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/switch.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_switch_create(sp_switch **p) 5 | { 6 | *p = malloc(sizeof(sp_switch)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_switch_destroy(sp_switch **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_switch_init(sp_data *sp, sp_switch *p) 17 | { 18 | p->mode = 0; 19 | return SP_OK; 20 | } 21 | 22 | int sp_switch_compute(sp_data *sp, sp_switch *p, SPFLOAT *trig, 23 | SPFLOAT *in1, SPFLOAT *in2, SPFLOAT *out) 24 | { 25 | if (*trig) { 26 | p->mode = p->mode == 0 ? 1 : 0; 27 | } 28 | 29 | if(p->mode == 0) { 30 | *out = *in1; 31 | } else { 32 | *out = *in2; 33 | } 34 | 35 | return SP_OK; 36 | } 37 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/tdiv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_tdiv_create(sp_tdiv **p) 5 | { 6 | *p = malloc(sizeof(sp_tdiv)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_tdiv_destroy(sp_tdiv **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_tdiv_init(sp_data *sp, sp_tdiv *p) 17 | { 18 | p->num = 2; 19 | p->counter = 0; 20 | p->offset = 0; 21 | return SP_OK; 22 | } 23 | 24 | int sp_tdiv_compute(sp_data *sp, sp_tdiv *p, SPFLOAT *in, SPFLOAT *out) 25 | { 26 | *out = 0.0; 27 | if(*in != 0) { 28 | if(p->counter == p->offset) *out = 1.0; 29 | else *out = 0.0; 30 | p->counter = (p->counter + 1) % p->num; 31 | } 32 | return SP_OK; 33 | } 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/tgate.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_tgate_create(sp_tgate **p) 5 | { 6 | *p = malloc(sizeof(sp_tgate)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_tgate_destroy(sp_tgate **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_tgate_init(sp_data *sp, sp_tgate *p) 17 | { 18 | p->time = 0; 19 | p->timer = 0; 20 | return SP_OK; 21 | } 22 | 23 | int sp_tgate_compute(sp_data *sp, sp_tgate *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | *out = 0; 26 | if(*in != 0) { 27 | p->timer = p->time * sp->sr; 28 | } 29 | if(p->timer != 0) { 30 | *out = 1; 31 | p->timer--; 32 | } 33 | return SP_OK; 34 | } 35 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/tin.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_tin_create(sp_tin **p) 5 | { 6 | *p = malloc(sizeof(sp_tin)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_tin_destroy(sp_tin **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_tin_init(sp_data *sp, sp_tin *p) 17 | { 18 | p->fp = stdin; 19 | p->val = 0; 20 | return SP_OK; 21 | } 22 | 23 | int sp_tin_compute(sp_data *sp, sp_tin *p, SPFLOAT *in, SPFLOAT *out) 24 | { 25 | if(*in) { 26 | fread(&p->val, sizeof(SPFLOAT), 1, p->fp); 27 | } 28 | 29 | *out = p->val; 30 | return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/modules/trand.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "soundpipe.h" 3 | 4 | int sp_trand_create(sp_trand **p) 5 | { 6 | *p = malloc(sizeof(sp_trand)); 7 | return SP_OK; 8 | } 9 | 10 | int sp_trand_destroy(sp_trand **p) 11 | { 12 | free(*p); 13 | return SP_OK; 14 | } 15 | 16 | int sp_trand_init(sp_data *sp, sp_trand *p) 17 | { 18 | p->min = 0; 19 | p->max = 1; 20 | p->val = 0; 21 | return SP_OK; 22 | } 23 | 24 | int sp_trand_compute(sp_data *sp, sp_trand *p, SPFLOAT *in, SPFLOAT *out) 25 | { 26 | if(*in != 0) { 27 | p->val = p->min + ((SPFLOAT) sp_rand(sp) / SP_RANDMAX) * (p->max - p->min); 28 | *out = p->val; 29 | } else { 30 | *out = p->val; 31 | } 32 | return SP_OK; 33 | } 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/config.h: -------------------------------------------------------------------------------- 1 | #define LEN 10 2 | #define SR 44100 3 | #define NUM 4 4 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/find_unused_tests.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # this program figures out which tests haven't been implemented yet. 4 | 5 | ls t/*.c > files 6 | cat all_tests.h | sed "s/TEST(\(.*\),.*,.*)/t\/\1.c/" >> files 7 | cat files | sort | uniq -u 8 | 9 | rm files 10 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/libtap.c: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2013, 2014, Louis P. Santillan 3 | All rights reserved. 4 | 5 | */ 6 | #include 7 | #include "tap.h" 8 | 9 | void plan( unsigned int num ) 10 | { 11 | printf( "1..%d\n", 12 | num ); 13 | } 14 | 15 | void ok( unsigned int ok, const char* msg ) 16 | { 17 | static int testnum = 0; 18 | printf( "%s %d - %s\n", 19 | ( ok ? "ok" : "not ok" ), 20 | ++testnum, 21 | msg ); 22 | } 23 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_adsr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_adsr *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_adsr_create(&unit[u]); 19 | sp_adsr_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_adsr_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_adsr_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_allpass.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_allpass *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_allpass_create(&unit[u]); 19 | sp_allpass_init(sp, unit[u], 1.5); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_allpass_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_allpass_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_atone.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_atone *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_atone_create(&unit[u]); 19 | sp_atone_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_atone_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_atone_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_autowah.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_autowah *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_autowah_create(&unit[u]); 19 | sp_autowah_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_autowah_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_autowah_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_bal.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0, comp = 0; 14 | 15 | sp_bal *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_bal_create(&unit[u]); 19 | sp_bal_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_bal_compute(sp, unit[u], &in, &comp, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_bal_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_bar.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_bar *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_bar_create(&unit[u]); 19 | sp_bar_init(sp, unit[u], 3, 0.0001); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_bar_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_bar_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_biquad.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_biquad *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_biquad_create(&unit[u]); 19 | sp_biquad_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_biquad_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_biquad_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_biscale.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_biscale *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_biscale_create(&unit[u]); 19 | sp_biscale_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_biscale_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_biscale_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_bitcrush.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_bitcrush *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_bitcrush_create(&unit[u]); 19 | sp_bitcrush_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_bitcrush_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_bitcrush_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_blsaw.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_blsaw *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_blsaw_create(&unit[u]); 19 | sp_blsaw_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_blsaw_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_blsaw_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_blsquare.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_blsquare *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_blsquare_create(&unit[u]); 19 | sp_blsquare_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_blsquare_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_blsquare_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_bltriangle.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_bltriangle *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_bltriangle_create(&unit[u]); 19 | sp_bltriangle_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_bltriangle_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_bltriangle_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_butbp.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_butbp *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_butbp_create(&unit[u]); 19 | sp_butbp_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_butbp_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_butbp_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_butbr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_butbr *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_butbr_create(&unit[u]); 19 | sp_butbr_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_butbr_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_butbr_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_buthp.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_buthp *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_buthp_create(&unit[u]); 19 | sp_buthp_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_buthp_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_buthp_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_butlp.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_butlp *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_butlp_create(&unit[u]); 19 | sp_butlp_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_butlp_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_butlp_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_clip.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_clip *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_clip_create(&unit[u]); 19 | sp_clip_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_clip_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_clip_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_comb.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_comb *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_comb_create(&unit[u]); 19 | sp_comb_init(sp, unit[u], 1.1); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_comb_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_comb_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_compressor.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_compressor *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_compressor_create(&unit[u]); 19 | sp_compressor_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_compressor_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_compressor_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_count.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_count *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_count_create(&unit[u]); 19 | sp_count_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_count_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_count_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_crossfade.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in1 = 0, out = 0, in2 = 0; 14 | 15 | sp_crossfade *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_crossfade_create(&unit[u]); 19 | sp_crossfade_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_crossfade_compute(sp, unit[u], 24 | &in1, &in2, &out); 25 | } 26 | 27 | for(u = 0; u < NUM; u++) sp_crossfade_destroy(&unit[u]); 28 | 29 | sp_destroy(&sp); 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_dcblock.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_dcblock *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_dcblock_create(&unit[u]); 19 | sp_dcblock_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_dcblock_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_dcblock_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_delay.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_delay *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_delay_create(&unit[u]); 19 | sp_delay_init(sp, unit[u], 1.0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_delay_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_delay_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_dist.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_dist *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_dist_create(&unit[u]); 19 | sp_dist_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_dist_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_dist_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_dmetro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_dmetro *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_dmetro_create(&unit[u]); 19 | sp_dmetro_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_dmetro_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_dmetro_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_drip.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_drip *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_drip_create(&unit[u]); 19 | sp_drip_init(sp, unit[u], 0.09); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_drip_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_drip_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_dust.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_dust *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_dust_create(&unit[u]); 19 | sp_dust_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_dust_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_dust_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_eqfil.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_eqfil *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_eqfil_create(&unit[u]); 19 | sp_eqfil_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_eqfil_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_eqfil_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_expon.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_expon *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_expon_create(&unit[u]); 19 | sp_expon_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_expon_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_expon_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_fofilt.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_fofilt *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_fofilt_create(&unit[u]); 19 | sp_fofilt_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_fofilt_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_fofilt_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_fold.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_fold *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_fold_create(&unit[u]); 19 | sp_fold_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_fold_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_fold_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_hilbert.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out1 = 0, out2 = 0; 14 | 15 | sp_hilbert *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_hilbert_create(&unit[u]); 19 | sp_hilbert_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_hilbert_compute(sp, unit[u], &in, 24 | &out1, &out2); 25 | } 26 | 27 | for(u = 0; u < NUM; u++) sp_hilbert_destroy(&unit[u]); 28 | 29 | sp_destroy(&sp); 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_incr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_incr *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_incr_create(&unit[u]); 19 | sp_incr_init(sp, unit[u], 0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_incr_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_incr_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_jcrev.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_jcrev *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_jcrev_create(&unit[u]); 19 | sp_jcrev_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_jcrev_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_jcrev_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_jitter.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_jitter *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_jitter_create(&unit[u]); 19 | sp_jitter_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_jitter_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_jitter_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_line.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_line *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_line_create(&unit[u]); 19 | sp_line_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_line_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_line_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_lpf18.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_lpf18 *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_lpf18_create(&unit[u]); 19 | sp_lpf18_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_lpf18_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_lpf18_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_maygate.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_maygate *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_maygate_create(&unit[u]); 19 | sp_maygate_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_maygate_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_maygate_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_metro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_metro *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_metro_create(&unit[u]); 19 | sp_metro_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_metro_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_metro_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_mode.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_mode *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_mode_create(&unit[u]); 19 | sp_mode_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_mode_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_mode_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_moogladder.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_moogladder *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_moogladder_create(&unit[u]); 19 | sp_moogladder_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_moogladder_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_moogladder_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_noise.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_noise *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_noise_create(&unit[u]); 19 | sp_noise_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_noise_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_noise_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pan2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out1 = 0, out2 = 0; 14 | 15 | sp_pan2 *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pan2_create(&unit[u]); 19 | sp_pan2_init(sp, unit[u]); 20 | unit[u]->type = 1; 21 | } 22 | 23 | for(t = 0; t < sp->len; t++) { 24 | for(u = 0; u < NUM; u++) sp_pan2_compute(sp, unit[u], &in, 25 | &out1, &out2); 26 | } 27 | 28 | for(u = 0; u < NUM; u++) sp_pan2_destroy(&unit[u]); 29 | 30 | sp_destroy(&sp); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_panst.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in1 = 0, out1 = 0; 14 | SPFLOAT in2 = 0, out2 = 0; 15 | 16 | sp_panst *unit[NUM]; 17 | 18 | for(u = 0; u < NUM; u++) { 19 | sp_panst_create(&unit[u]); 20 | sp_panst_init(sp, unit[u]); 21 | } 22 | 23 | for(t = 0; t < sp->len; t++) { 24 | for(u = 0; u < NUM; u++) sp_panst_compute(sp, unit[u], 25 | &in1, &in2, &out1, &out2); 26 | } 27 | 28 | for(u = 0; u < NUM; u++) sp_panst_destroy(&unit[u]); 29 | 30 | sp_destroy(&sp); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pareq.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_pareq *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pareq_create(&unit[u]); 19 | sp_pareq_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pareq_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pareq_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pdhalf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_pdhalf *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pdhalf_create(&unit[u]); 19 | sp_pdhalf_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pdhalf_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pdhalf_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_peaklim.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_peaklim *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_peaklim_create(&unit[u]); 19 | sp_peaklim_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_peaklim_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_peaklim_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_phaser.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in1 = 0, out1 = 0; 14 | SPFLOAT in2 = 0, out2 = 0; 15 | 16 | sp_phaser *unit[NUM]; 17 | 18 | for(u = 0; u < NUM; u++) { 19 | sp_phaser_create(&unit[u]); 20 | sp_phaser_init(sp, unit[u]); 21 | } 22 | 23 | for(t = 0; t < sp->len; t++) { 24 | for(u = 0; u < NUM; u++) sp_phaser_compute(sp, unit[u], 25 | &in1, &in2, &out1, &out2); 26 | } 27 | 28 | for(u = 0; u < NUM; u++) sp_phaser_destroy(&unit[u]); 29 | 30 | sp_destroy(&sp); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_phasor.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_phasor *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_phasor_create(&unit[u]); 19 | sp_phasor_init(sp, unit[u], 0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_phasor_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_phasor_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pinknoise.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_pinknoise *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pinknoise_create(&unit[u]); 19 | sp_pinknoise_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pinknoise_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pinknoise_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pitchamdf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, rms = 0, cps = 0; 14 | 15 | sp_pitchamdf *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pitchamdf_create(&unit[u]); 19 | sp_pitchamdf_init(sp, unit[u], 100, 400); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pitchamdf_compute(sp, unit[u], &in, &cps, &rms); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pitchamdf_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pluck.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_pluck *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pluck_create(&unit[u]); 19 | sp_pluck_init(sp, unit[u], 400); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pluck_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pluck_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_port.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_port *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_port_create(&unit[u]); 19 | sp_port_init(sp, unit[u], 0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_port_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_port_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_prop.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_prop *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_prop_create(&unit[u]); 19 | sp_prop_init(sp, unit[u], "+"); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_prop_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_prop_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_pshift.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_pshift *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_pshift_create(&unit[u]); 19 | sp_pshift_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_pshift_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_pshift_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_ptrack.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, freq = 0, amp = 0; 14 | 15 | sp_ptrack *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_ptrack_create(&unit[u]); 19 | sp_ptrack_init(sp, unit[u], 512, 20); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_ptrack_compute(sp, unit[u], &in, 24 | &freq, &); 25 | } 26 | 27 | for(u = 0; u < NUM; u++) sp_ptrack_destroy(&unit[u]); 28 | 29 | sp_destroy(&sp); 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_randh.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_randh *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_randh_create(&unit[u]); 19 | sp_randh_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_randh_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_randh_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_randi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_randi *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_randi_create(&unit[u]); 19 | sp_randi_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_randi_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_randi_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_random.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_random *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_random_create(&unit[u]); 19 | sp_random_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_random_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_random_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_reson.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_reson *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_reson_create(&unit[u]); 19 | sp_reson_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_reson_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_reson_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_reverse.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_reverse *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_reverse_create(&unit[u]); 19 | sp_reverse_init(sp, unit[u], 1.0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_reverse_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_reverse_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_revsc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in1 = 0, out1 = 0; 14 | SPFLOAT in2 = 0, out2 = 0; 15 | 16 | sp_revsc *unit[NUM]; 17 | 18 | for(u = 0; u < NUM; u++) { 19 | sp_revsc_create(&unit[u]); 20 | sp_revsc_init(sp, unit[u]); 21 | } 22 | 23 | for(t = 0; t < sp->len; t++) { 24 | for(u = 0; u < NUM; u++) sp_revsc_compute(sp, unit[u], 25 | &in1, &in2, &out1, &out2); 26 | } 27 | 28 | for(u = 0; u < NUM; u++) sp_revsc_destroy(&unit[u]); 29 | 30 | sp_destroy(&sp); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_rms.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_rms *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_rms_create(&unit[u]); 19 | sp_rms_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_rms_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_rms_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_rpt.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0, trig = 0; 14 | 15 | sp_rpt *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_rpt_create(&unit[u]); 19 | sp_rpt_init(sp, unit[u], 2.0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_rpt_compute(sp, unit[u], &trig, &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_rpt_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_samphold.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0, trig = 0; 14 | 15 | sp_samphold *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_samphold_create(&unit[u]); 19 | sp_samphold_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_samphold_compute(sp, unit[u], 24 | &trig, &in, &out); 25 | } 26 | 27 | for(u = 0; u < NUM; u++) sp_samphold_destroy(&unit[u]); 28 | 29 | sp_destroy(&sp); 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_scale.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_scale *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_scale_create(&unit[u]); 19 | sp_scale_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_scale_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_scale_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_sdelay.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_sdelay *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_sdelay_create(&unit[u]); 19 | sp_sdelay_init(sp, unit[u], 1024); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_sdelay_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_sdelay_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_smoothdelay.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_smoothdelay *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_smoothdelay_create(&unit[u]); 19 | sp_smoothdelay_init(sp, unit[u], 1.0, 1024); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_smoothdelay_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_smoothdelay_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_streson.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_streson *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_streson_create(&unit[u]); 19 | sp_streson_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_streson_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_streson_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_switch.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT trig = 0, in1 = 0, in2 = 0, out = 0; 14 | 15 | sp_switch *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_switch_create(&unit[u]); 19 | sp_switch_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_switch_compute(sp, unit[u], 24 | &trig, &in1, &in2, &out); 25 | } 26 | 27 | for(u = 0; u < NUM; u++) sp_switch_destroy(&unit[u]); 28 | 29 | sp_destroy(&sp); 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tadsr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tadsr *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tadsr_create(&unit[u]); 19 | sp_tadsr_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tadsr_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tadsr_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tbvcf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tbvcf *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tbvcf_create(&unit[u]); 19 | sp_tbvcf_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tbvcf_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tbvcf_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tdiv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tdiv *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tdiv_create(&unit[u]); 19 | sp_tdiv_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tdiv_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tdiv_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tenv.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tenv *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tenv_create(&unit[u]); 19 | sp_tenv_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tenv_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tenv_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tenv2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tenv2 *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tenv2_create(&unit[u]); 19 | sp_tenv2_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tenv2_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tenv2_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tenvx.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tenvx *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tenvx_create(&unit[u]); 19 | sp_tenvx_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tenvx_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tenvx_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tgate.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tgate *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tgate_create(&unit[u]); 19 | sp_tgate_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tgate_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tgate_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_thresh.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_thresh *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_thresh_create(&unit[u]); 19 | sp_thresh_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_thresh_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_thresh_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_timer.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_timer *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_timer_create(&unit[u]); 19 | sp_timer_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_timer_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_timer_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tin.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tin *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tin_create(&unit[u]); 19 | sp_tin_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tin_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tin_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tone.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tone *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tone_create(&unit[u]); 19 | sp_tone_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tone_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tone_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_trand.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_trand *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_trand_create(&unit[u]); 19 | sp_trand_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_trand_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_trand_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_tseg.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_tseg *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_tseg_create(&unit[u]); 19 | sp_tseg_init(sp, unit[u], 0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_tseg_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_tseg_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_vdelay.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_vdelay *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_vdelay_create(&unit[u]); 19 | sp_vdelay_init(sp, unit[u], 1.0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_vdelay_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_vdelay_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_waveset.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_waveset *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_waveset_create(&unit[u]); 19 | sp_waveset_init(sp, unit[u], 5.0); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_waveset_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_waveset_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_wpkorg35.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in = 0, out = 0; 14 | 15 | sp_wpkorg35 *unit[NUM]; 16 | 17 | for(u = 0; u < NUM; u++) { 18 | sp_wpkorg35_create(&unit[u]); 19 | sp_wpkorg35_init(sp, unit[u]); 20 | } 21 | 22 | for(t = 0; t < sp->len; t++) { 23 | for(u = 0; u < NUM; u++) sp_wpkorg35_compute(sp, unit[u], &in, &out); 24 | } 25 | 26 | for(u = 0; u < NUM; u++) sp_wpkorg35_destroy(&unit[u]); 27 | 28 | sp_destroy(&sp); 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/p/p_zitarev.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "soundpipe.h" 4 | #include "config.h" 5 | 6 | int main() { 7 | sp_data *sp; 8 | sp_create(&sp); 9 | sp_srand(sp, 12345); 10 | sp->sr = SR; 11 | sp->len = sp->sr * LEN; 12 | uint32_t t, u; 13 | SPFLOAT in1 = 0, out1 = 0; 14 | SPFLOAT in2 = 0, out2 = 0; 15 | 16 | sp_zitarev *unit[NUM]; 17 | 18 | for(u = 0; u < NUM; u++) { 19 | sp_zitarev_create(&unit[u]); 20 | sp_zitarev_init(sp, unit[u]); 21 | } 22 | 23 | for(t = 0; t < sp->len; t++) { 24 | for(u = 0; u < NUM; u++) sp_zitarev_compute(sp, unit[u], 25 | &in1, &in2, &out1, &out2); 26 | } 27 | 28 | for(u = 0; u < NUM; u++) sp_zitarev_destroy(&unit[u]); 29 | 30 | sp_destroy(&sp); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/perf_test: -------------------------------------------------------------------------------- 1 | #/bin/sh 2 | > time.log 3 | for p in $* 4 | do 5 | echo "testing $p" 6 | printf "$p " | sed "s/^p\/p_//" >> time.log 7 | /usr/bin/time -p ./$p 2>&1 | grep real | cut -d ' ' -f 2 >> time.log 8 | done 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/plot.plt: -------------------------------------------------------------------------------- 1 | set terminal png size 900,400 font ',10' 2 | set bmargin 10 3 | set output "demo.png" 4 | set nokey 5 | set style data histogram 6 | unset border 7 | set xtics rotate 8 | set xtics axis 9 | 10 | plot 'time.log' using 2:xtic(1) with boxes 11 | 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_count.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_count(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_dcblock.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_dcblock(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_dust.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | typedef struct { 7 | sp_dust *dst; 8 | } UserData; 9 | 10 | int t_dust(sp_test *tst, sp_data *sp, const char *hash) 11 | { 12 | uint32_t n; 13 | int fail = 0; 14 | SPFLOAT out = 0; 15 | UserData ud; 16 | 17 | sp_dust_create(&ud.dst); 18 | sp_dust_init(sp, ud.dst); 19 | sp->len = 44100 * 5; 20 | ud.dst->bipolar = 1.0; 21 | 22 | for(n = 0; n < tst->size; n++) { 23 | out = 0; 24 | sp_dust_compute(sp, ud.dst, NULL, &out); 25 | sp_test_add_sample(tst, out); 26 | } 27 | 28 | fail = sp_test_verify(tst, hash); 29 | 30 | sp_dust_destroy(&ud.dst); 31 | 32 | if(fail) return SP_NOT_OK; 33 | else return SP_OK; 34 | } 35 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_foo.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_foo(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_composite.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_composite(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_composite(sp, ft, "0.5 0.5 270 0.5"); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_file.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_file(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_file(sp, ft, SAMPDIR "oneart.wav"); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_gauss.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_gauss(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_gauss(sp, ft, 1, 123456); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_line.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_line(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_line(sp, ft, "0 -1 2048 1 4096 -1"); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_sine.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_sine(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_sine(sp, ft); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_sinesum.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_sinesum(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_sinesum(sp, ft, "1 0.5 0.25"); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_vals.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_vals(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_sinesum(sp, ft, "1 1.5 -3 5 "); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_gen_xline.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_gen_xline(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | SPFLOAT out = 0; 11 | 12 | sp_ftbl *ft; 13 | sp_ftbl_create(sp, &ft, 4096); 14 | sp_gen_xline(sp, ft, "0 0.0001 4096 1.0"); 15 | 16 | for(n = 0; n < tst->size; n++) { 17 | if(n < ft->size) { 18 | out = ft->tbl[n]; 19 | } else { 20 | out = 0; 21 | } 22 | sp_test_add_sample(tst, out); 23 | } 24 | 25 | fail = sp_test_verify(tst, hash); 26 | 27 | sp_ftbl_destroy(&ft); 28 | 29 | if(fail) return SP_NOT_OK; 30 | else return SP_OK; 31 | } 32 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_incr.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_incr(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_noise.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | typedef struct { 7 | sp_noise *ns; 8 | } UserData; 9 | 10 | int t_noise(sp_test *tst, sp_data *sp, const char *hash) 11 | { 12 | sp_srand(sp, 0); 13 | uint32_t n; 14 | int fail = 0; 15 | 16 | UserData ud; 17 | sp_noise_create(&ud.ns); 18 | sp_noise_init(sp, ud.ns); 19 | 20 | SPFLOAT in; 21 | 22 | for(n = 0; n < tst->size; n++) { 23 | sp_noise_compute(sp, ud.ns, &in, &sp->out[0]); 24 | sp_test_add_sample(tst, sp->out[0]); 25 | } 26 | 27 | fail = sp_test_verify(tst, hash); 28 | 29 | sp_noise_destroy(&ud.ns); 30 | 31 | if(fail) return SP_NOT_OK; 32 | else return SP_OK; 33 | } 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_phasor.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | typedef struct { 7 | sp_phasor *phs; 8 | } UserData; 9 | 10 | int t_phasor(sp_test *tst, sp_data *sp, const char *hash) 11 | { 12 | uint32_t n; 13 | int fail = 0; 14 | 15 | UserData ud; 16 | sp_phasor_create(&ud.phs); 17 | sp_phasor_init(sp, ud.phs, 0); 18 | 19 | for(n = 0; n < tst->size; n++) { 20 | sp_phasor_compute(sp, ud.phs, NULL, &sp->out[0]); 21 | sp_test_add_sample(tst, sp->out[0]); 22 | } 23 | 24 | fail = sp_test_verify(tst, hash); 25 | 26 | sp_phasor_destroy(&ud.phs); 27 | 28 | if(fail) return SP_NOT_OK; 29 | else return SP_OK; 30 | } 31 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_pinknoise.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | typedef struct { 7 | sp_pinknoise *ns; 8 | } UserData; 9 | 10 | int t_pinknoise(sp_test *tst, sp_data *sp, const char *hash) 11 | { 12 | uint32_t n; 13 | int fail = 0; 14 | SPFLOAT out = 0; 15 | 16 | UserData ud; 17 | sp_srand(sp, 12345); 18 | sp_pinknoise_create(&ud.ns); 19 | sp_pinknoise_init(sp, ud.ns); 20 | 21 | for(n = 0; n < tst->size; n++) { 22 | out = 0; 23 | sp_pinknoise_compute(sp, ud.ns, NULL, &out); 24 | sp_test_add_sample(tst, out); 25 | } 26 | 27 | fail = sp_test_verify(tst, hash); 28 | 29 | sp_pinknoise_destroy(&ud.ns); 30 | 31 | if(fail) return SP_NOT_OK; 32 | else return SP_OK; 33 | } 34 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_slice.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_slice(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_smoothdelay.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_smoothdelay(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/t/t_tgate.c: -------------------------------------------------------------------------------- 1 | #include "soundpipe.h" 2 | #include "md5.h" 3 | #include "tap.h" 4 | #include "test.h" 5 | 6 | int t_tgate(sp_test *tst, sp_data *sp, const char *hash) 7 | { 8 | uint32_t n; 9 | int fail = 0; 10 | 11 | /* allocate / initialize modules here */ 12 | 13 | for(n = 0; n < tst->size; n++) { 14 | /* compute samples and add to test buffer */ 15 | sp_test_add_sample(tst, 0); 16 | } 17 | 18 | fail = sp_test_verify(tst, hash); 19 | 20 | /* destroy functions here */ 21 | 22 | if(fail) return SP_NOT_OK; 23 | /* fail by default */ 24 | else return SP_NOT_OK; 25 | } 26 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/tap.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013, 2014, Louis P. Santillan 3 | * All rights reserved. 4 | */ 5 | #ifndef TAP_H 6 | #define TAP_H 7 | 8 | void plan( unsigned int num ); 9 | 10 | void ok( unsigned int ok, const char* msg ); 11 | 12 | #endif 13 | 14 | 15 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/test/write_wav.sh: -------------------------------------------------------------------------------- 1 | #/bin/sh 2 | 3 | # This utility is a wrapper around sox which converts 32-bit LE raw data into a 4 | # mono 44.1 kHz wav. 5 | 6 | if [ "$#" -eq 0 ] 7 | then 8 | echo "./write_wave.sh filename.raw" 9 | exit 10 | fi 11 | 12 | sox -t raw -c 1 -r 44100 -e floating-point -b 32 $1 out.wav 13 | 14 | echo "converted $1 to out.wav" 15 | 16 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/autowah.dsp: -------------------------------------------------------------------------------- 1 | declare id "auto"; // selector crybaby / autowah 2 | declare name "auto"; 3 | 4 | //----------------------------------------------- 5 | // Auto-Wah 6 | //----------------------------------------------- 7 | 8 | import("effect.lib"); //for crybaby definition 9 | import("guitarix.lib"); 10 | 11 | l = crybaby_ctrl.level; 12 | a = crybaby_ctrl.wah; 13 | w = crybaby_ctrl.wet_dry; 14 | 15 | d = 1-w; 16 | Sum(n,x) = +(x - (x @ n)) ~_ ; 17 | 18 | Average(n,x) = x * (1<<22) : int : abs : Sum(n) : float : /(1<<22) 19 | : /(n); 20 | 21 | Map(x) = x * a : max(0) : min(1) ; 22 | process(x) = x : _<:*(d),(*(w):*(l) :a * crybaby(x : amp_follower_ud(0.01,0.1) : min(1)) + (1.0-a) * x):>_ ; 23 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/compile.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | if [ "$#" -eq 0 ] 4 | then 5 | echo "Please specify the name of the DSP module" 6 | exit 1 7 | fi 8 | 9 | NAME=$1 10 | faust -cn $NAME -json -lang c -a sp.c $NAME.dsp -o $NAME.c 11 | go run parse.go $NAME $NAME.dsp.json >> $NAME.c 12 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/compressor.dsp: -------------------------------------------------------------------------------- 1 | import("effect.lib"); 2 | 3 | ratio = hslider("[0] ratio", 1, 1, 40, 0.001); 4 | thresh = hslider("[1] thresh", 0, -80, 0, 0.001); 5 | atk = hslider("[2] atk", 0.1, 0, 10, 0.001); 6 | rel = hslider("[3] rel", 0.1, 0, 10, 0.001); 7 | 8 | process = compressor_mono(ratio, thresh, atk, rel); 9 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/pinknoise.dsp: -------------------------------------------------------------------------------- 1 | import("oscillator.lib"); 2 | amp = hslider("amp", 1, 0, 1, 0.0001); 3 | process = pink_noise * amp; 4 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/saw.dsp: -------------------------------------------------------------------------------- 1 | import("oscillator.lib"); 2 | freq = hslider("[0]freq", 440, 0, 20000, 0.0001); 3 | amp = hslider("[1]amp", 1, 0, 1, 0.0001); 4 | process = sawtooth(freq) * amp; 5 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/square.dsp: -------------------------------------------------------------------------------- 1 | import("oscillator.lib"); 2 | 3 | freq = hslider("[1]frequency", 440, 0, 20000, 0.0001); 4 | amp = hslider("[2]amp", 1, 0, 1, 0.00001); 5 | width = hslider("[3]width", 0.5, 0, 1, 0.0000); 6 | 7 | process = pulsetrainN(2, freq, width) * amp; 8 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/triangle.dsp: -------------------------------------------------------------------------------- 1 | import("oscillator.lib"); 2 | 3 | freq = hslider("[0]freq", 440, 0, 20000, 0.0001); 4 | amp = hslider("[1]amp", 1, 0, 1, 0.00001); 5 | 6 | process = triangle(freq) * amp; 7 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/faust/vocoder.dsp: -------------------------------------------------------------------------------- 1 | import("effect.lib"); 2 | 3 | atk = hslider("[0] atk", 0.01, 0.0001, 0.5, 0.00001); 4 | rel = hslider("[1] rel", 0.01, 0.0001, 0.5, 0.00001); 5 | bwratio = hslider("[2] bwratio", 0.5, 0.1, 2, 0.001); 6 | process = vocoder(16, atk, rel, bwratio); 7 | -------------------------------------------------------------------------------- /3rdparty/soundpipe/util/gendocs.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | mkdir -p $INTERMEDIATES_PREFIX/docs 4 | cp -r util/css $INTERMEDIATES_PREFIX/docs 5 | 6 | > $INTERMEDIATES_PREFIX/docs/modules.txt 7 | 8 | for d in modules/data/*.lua 9 | do 10 | module=$(basename ${d%.*}) 11 | echo "writing $module" 12 | util/data2html.lua $module > $INTERMEDIATES_PREFIX/docs/$module.html 13 | echo $module >> $INTERMEDIATES_PREFIX/docs/modules.txt 14 | done 15 | 16 | util/gen_index.lua $INTERMEDIATES_PREFIX/docs/modules.txt > $INTERMEDIATES_PREFIX/docs/index.html 17 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.15) 2 | 3 | project(slPlugins VERSION 1.1.0) 4 | 5 | set (CMAKE_OSX_DEPLOYMENT_TARGET 10.11) 6 | set (CMAKE_OSX_ARCHITECTURES arm64 x86_64) 7 | set (CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>") 8 | set_property(GLOBAL PROPERTY XCODE_ATTRIBUTE_CLANG_LINK_OBJC_RUNTIME NO) 9 | 10 | add_subdirectory(modules) 11 | add_subdirectory(plugins) 12 | -------------------------------------------------------------------------------- /CMakePresets.json: -------------------------------------------------------------------------------- 1 | { 2 | "cmakeMinimumRequired": { 3 | "major": 3, 4 | "minor": 24, 5 | "patch": 0 6 | }, 7 | "version": 5, 8 | "include": [ 9 | "modules/gin/ci/toolchains/xcode.json", 10 | "modules/gin/ci/toolchains/vs.json", 11 | "modules/gin/ci/toolchains/gcc.json", 12 | "modules/gin/ci/toolchains/clang.json" 13 | ] 14 | } 15 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # slPlugins 2 | Various VST/AU Plugins from SocaLabs.com 3 | 4 | Here are some plugins I wrote. Mostly effects. The synths like PAPU, SID, etc. have their own repos. 5 | 6 | ![Build macOS](https://github.com/FigBug/slPlugins/workflows/Build%20macOS/badge.svg) 7 | ![Build Windows](https://github.com/FigBug/slPlugins/workflows/Build%20Windows/badge.svg) 8 | ![Build Linux](https://github.com/FigBug/slPlugins/workflows/Build%20Linux/badge.svg) 9 | -------------------------------------------------------------------------------- /ci/config_cmake.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -e 2 | 3 | ROOT=$(cd "$(dirname "$0")/.."; pwd) 4 | cd "$ROOT" 5 | 6 | export PATH=$PATH:"/c/Program Files/CMake/bin" 7 | 8 | if [ "$(uname)" == "Darwin" ]; then 9 | TOOLCHAIN="xcode" 10 | elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then 11 | TOOLCHAIN="ninja-gcc" 12 | elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then 13 | TOOLCHAIN="vs" 14 | fi 15 | 16 | cmake --preset $TOOLCHAIN -D BUILD_EXTRAS=OFF -D JUCE_COPY_PLUGIN_AFTER_BUILD=ON 17 | -------------------------------------------------------------------------------- /ci/pluginlist.txt: -------------------------------------------------------------------------------- 1 | ABTester 2 | AddInvert 3 | ChannelMute 4 | CompensatedDelay 5 | Compressor 6 | Delay 7 | Expander 8 | Gate 9 | HugeGain 10 | Limiter 11 | Maths 12 | Oscilloscope 13 | PitchTrack 14 | SFX8 15 | SampleDelay 16 | SpectrumAnalyzer 17 | ToneGenerator 18 | -------------------------------------------------------------------------------- /modules/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.15) 2 | 3 | add_subdirectory(juce) 4 | juce_set_vst2_sdk_path(plugin_sdk/vstsdk2.4) 5 | 6 | juce_add_module(dRowAudio/module/dRowAudio) 7 | juce_add_module(gin/modules/gin) 8 | juce_add_module(gin/modules/gin_dsp) 9 | juce_add_module(gin/modules/gin_simd) 10 | juce_add_module(gin/modules/gin_gui) 11 | juce_add_module(gin/modules/gin_metadata) 12 | juce_add_module(gin/modules/gin_network) 13 | juce_add_module(gin/modules/gin_plugin) 14 | juce_add_module(gin/modules/gin_graphics) 15 | juce_add_module(pitch_detector) 16 | juce_add_module(audio_fft) 17 | -------------------------------------------------------------------------------- /plugins/AddInvert/Source/PluginEditor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "PluginProcessor.h" 5 | 6 | //============================================================================== 7 | /** 8 | */ 9 | class AddInvertAudioProcessorEditor : public gin::ProcessorEditor 10 | { 11 | public: 12 | AddInvertAudioProcessorEditor (AddInvertAudioProcessor&); 13 | ~AddInvertAudioProcessorEditor() override; 14 | 15 | //============================================================================== 16 | void resized() override; 17 | 18 | drow::TriggeredScope scope; 19 | 20 | private: 21 | AddInvertAudioProcessor& aiProcessor; 22 | 23 | JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AddInvertAudioProcessorEditor) 24 | }; 25 | -------------------------------------------------------------------------------- /plugins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(ABTester) 2 | add_subdirectory(AddInvert) 3 | add_subdirectory(ChannelMute) 4 | add_subdirectory(CompensatedDelay) 5 | add_subdirectory(Compressor) 6 | add_subdirectory(Delay) 7 | add_subdirectory(Expander) 8 | add_subdirectory(Gate) 9 | add_subdirectory(HugeGain) 10 | add_subdirectory(Limiter) 11 | add_subdirectory(Maths) 12 | add_subdirectory(Oscilloscope) 13 | add_subdirectory(PitchTrack) 14 | add_subdirectory(SFX8) 15 | add_subdirectory(SampleDelay) 16 | add_subdirectory(SpectrumAnalyzer) 17 | add_subdirectory(ToneGenerator) 18 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Acoustic Guitar.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Bass Guitar.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Electric Guitar.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Kick Snare.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Mix.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/Compressor/Resources/Vocals.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /plugins/SFX8/Resources/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FigBug/slPlugins/fcaec26cdd8391e19bcf1d9b21ab1e2c31d587ed/plugins/SFX8/Resources/logo.png -------------------------------------------------------------------------------- /plugins/SFX8/Source/Pad.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ============================================================================== 3 | 4 | Pad.cpp 5 | Created: 4 Jul 2019 8:25:11pm 6 | Author: Roland Rabien 7 | 8 | ============================================================================== 9 | */ 10 | 11 | #include "Pad.h" 12 | -------------------------------------------------------------------------------- /plugins/SFX8/Source/UIComponents.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ============================================================================== 3 | 4 | UIComponents.cpp 5 | Created: 5 Jul 2019 11:45:25am 6 | Author: Roland Rabien 7 | 8 | ============================================================================== 9 | */ 10 | 11 | #include "UIComponents.h" 12 | --------------------------------------------------------------------------------