├── beat.wav ├── count.wav ├── guitar.wav ├── sample.wav ├── renderer ├── woodz │ ├── a.wav │ ├── b.wav │ ├── t.wav │ ├── st.wav │ ├── st1.wav │ ├── t1.wav │ └── glass.wav ├── print_text.py ├── 07_simple_fft.py ├── 01_generate_sin.py ├── 03_mix_signals.py ├── 04_amplitude_range.py ├── 02_binural_beats.py ├── 05_clusters.py ├── 06_log_amplitude.py ├── wavetables.py ├── introText └── physical_renderer.py ├── polymetrix ├── sound01.wav ├── sound02.wav ├── composer.py └── polymetrix.py ├── AmenSynth ├── Amen_Break_CD.wav ├── Amen_Break_Vinyl.wav └── amen_synth.py ├── SamplePatternPlayer ├── pack01 │ ├── 01.wav │ ├── 02.wav │ ├── 03.wav │ ├── bd1.wav │ ├── bd2.wav │ ├── bd3.wav │ ├── bd4.wav │ ├── hh1.wav │ └── sd1.wav ├── samplePlayer3.py ├── sample_player2.py └── sample_player.py ├── musrara_projects ├── grain_player.wav ├── pack01 │ ├── file04-12-2020 02-24-38.wav │ ├── file04-12-2020 02-33-54.wav │ ├── file04-12-2020 03-15-12.wav │ ├── file04-12-2020 16-52-10.wav │ ├── file04-12-2020 16-52-46.wav │ ├── file04-12-2020 16-58-00.wav │ ├── file04-12-2020 17-03-01.wav │ ├── file04-12-2020 17-05-20.wav │ ├── file04-12-2020 17-05-43.wav │ ├── file04-12-2020 17-59-40.wav │ ├── file04-12-2020 18-00-10.wav │ ├── file04-12-2020 18-00-31.wav │ ├── file04-12-2020 18-00-55.wav │ ├── file04-12-2020 18-01-15.wav │ ├── file04-12-2020 18-01-40.wav │ ├── file04-12-2020 18-02-00.wav │ ├── file04-12-2020 18-03-00.wav │ ├── file04-12-2020 18-03-30.wav │ ├── file04-12-2020 18-05-08.wav │ ├── file04-12-2020 18-05-28.wav │ ├── file04-12-2020 18-21-25.wav │ ├── file04-12-2020 18-22-05.wav │ ├── file04-12-2020 18-22-37.wav │ ├── file05-12-2020 00-28-08.wav │ ├── file05-12-2020 00-28-45.wav │ ├── file05-12-2020 00-29-10.wav │ ├── file05-12-2020 00-29-30.wav │ ├── file05-12-2020 00-30-03.wav │ ├── file05-12-2020 00-31-20.wav │ ├── file05-12-2020 00-32-42.wav │ ├── file05-12-2020 00-33-03.wav │ ├── file05-12-2020 00-33-35.wav │ ├── file05-12-2020 00-33-53.wav │ ├── file05-12-2020 00-34-18.wav │ ├── file05-12-2020 00-34-54.wav │ ├── file05-12-2020 00-35-22.wav │ ├── file05-12-2020 00-35-41.wav │ ├── file05-12-2020 00-36-29.wav │ ├── file05-12-2020 00-36-45.wav │ ├── file05-12-2020 00-37-10.wav │ ├── file05-12-2020 00-37-28.wav │ ├── file05-12-2020 00-37-48.wav │ ├── file05-12-2020 00-38-04.wav │ ├── file05-12-2020 00-38-15.wav │ ├── file05-12-2020 15-06-53.wav │ ├── file05-12-2020 15-08-14.wav │ ├── file05-12-2020 15-09-04.wav │ ├── file05-12-2020 15-09-09.wav │ ├── file05-12-2020 15-14-56.wav │ ├── file05-12-2020 15-15-43.wav │ ├── file05-12-2020 15-16-12.wav │ ├── file05-12-2020 15-18-14.wav │ ├── file05-12-2020 15-18-33.wav │ ├── file05-12-2020 15-18-51.wav │ ├── file05-12-2020 15-19-30.wav │ ├── file05-12-2020 15-19-54.wav │ ├── file05-12-2020 15-20-17.wav │ ├── file05-12-2020 15-20-34.wav │ ├── file05-12-2020 15-20-51.wav │ ├── file05-12-2020 15-22-25.wav │ ├── file05-12-2020 15-22-42.wav │ ├── file05-12-2020 15-22-56.wav │ ├── file05-12-2020 15-23-21.wav │ ├── file06-12-2020 17-56-40.wav │ ├── file06-12-2020 17-57-18.wav │ ├── file06-12-2020 17-57-24.wav │ ├── file06-12-2020 17-57-29.wav │ ├── file06-12-2020 17-57-37.wav │ ├── file06-12-2020 17-57-41.wav │ ├── file06-12-2020 17-57-52.wav │ ├── file06-12-2020 17-57-58.wav │ └── file06-12-2020 17-58-03.wav ├── Simple Sine Wave Printer.py ├── Simple Triangle Wave Printer.py ├── Develop String Pattern.py ├── Grain Player.py ├── Simple Tone Sequencer.py ├── Simple Tone Sequencer#2.py └── Sample Player.py ├── tonegenerator ├── myDriver.py ├── notes.txt └── tonegenerator.py ├── 19_audio_recorder.py ├── window_functions.py ├── 07_quantization.py ├── 01_generate_signal.py ├── 12_removing_normalize_offset_from_samples.py ├── 06_clipping_overdrive_distortion.py ├── 20_pyquncer.py ├── 05_butterworth filter.py ├── 02_add_noise.py ├── .github └── FUNDING.yml ├── 11_Chorus.py ├── 08_AM.py ├── wav_analyzer ├── wav_analyzer_simple_hist.py ├── create_wav.py └── wav_analyzer.py ├── 17_rms.py ├── 14_saw_&_unison.py ├── 03_filter_signal_LP.py ├── 10_FM_samples.py ├── 09a_FM.py ├── 04_filter_signal_HP.py ├── wavtable.py ├── 13_Echo.py ├── 15_filter_sweep.py ├── XDSP.py ├── 09b_FM_synthesis.py ├── 18_noise_gate.py ├── AGC_compressor.py └── 16_sigmoid.py /beat.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/beat.wav -------------------------------------------------------------------------------- /count.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/count.wav -------------------------------------------------------------------------------- /guitar.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/guitar.wav -------------------------------------------------------------------------------- /sample.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/sample.wav -------------------------------------------------------------------------------- /renderer/woodz/a.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/a.wav -------------------------------------------------------------------------------- /renderer/woodz/b.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/b.wav -------------------------------------------------------------------------------- /renderer/woodz/t.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/t.wav -------------------------------------------------------------------------------- /polymetrix/sound01.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/polymetrix/sound01.wav -------------------------------------------------------------------------------- /polymetrix/sound02.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/polymetrix/sound02.wav -------------------------------------------------------------------------------- /renderer/woodz/st.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/st.wav -------------------------------------------------------------------------------- /renderer/woodz/st1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/st1.wav -------------------------------------------------------------------------------- /renderer/woodz/t1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/t1.wav -------------------------------------------------------------------------------- /renderer/woodz/glass.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/renderer/woodz/glass.wav -------------------------------------------------------------------------------- /AmenSynth/Amen_Break_CD.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/AmenSynth/Amen_Break_CD.wav -------------------------------------------------------------------------------- /AmenSynth/Amen_Break_Vinyl.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/AmenSynth/Amen_Break_Vinyl.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/01.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/01.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/02.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/02.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/03.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/03.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/bd1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/bd1.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/bd2.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/bd2.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/bd3.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/bd3.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/bd4.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/bd4.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/hh1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/hh1.wav -------------------------------------------------------------------------------- /SamplePatternPlayer/pack01/sd1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/SamplePatternPlayer/pack01/sd1.wav -------------------------------------------------------------------------------- /musrara_projects/grain_player.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/grain_player.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 02-24-38.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 02-24-38.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 02-33-54.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 02-33-54.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 03-15-12.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 03-15-12.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 16-52-10.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 16-52-10.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 16-52-46.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 16-52-46.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 16-58-00.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 16-58-00.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 17-03-01.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 17-03-01.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 17-05-20.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 17-05-20.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 17-05-43.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 17-05-43.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 17-59-40.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 17-59-40.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-00-10.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-00-10.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-00-31.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-00-31.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-00-55.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-00-55.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-01-15.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-01-15.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-01-40.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-01-40.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-02-00.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-02-00.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-03-00.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-03-00.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-03-30.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-03-30.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-05-08.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-05-08.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-05-28.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-05-28.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-21-25.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-21-25.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-22-05.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-22-05.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file04-12-2020 18-22-37.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file04-12-2020 18-22-37.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-28-08.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-28-08.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-28-45.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-28-45.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-29-10.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-29-10.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-29-30.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-29-30.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-30-03.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-30-03.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-31-20.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-31-20.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-32-42.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-32-42.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-33-03.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-33-03.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-33-35.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-33-35.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-33-53.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-33-53.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-34-18.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-34-18.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-34-54.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-34-54.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-35-22.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-35-22.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-35-41.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-35-41.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-36-29.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-36-29.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-36-45.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-36-45.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-37-10.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-37-10.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-37-28.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-37-28.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-37-48.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-37-48.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-38-04.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-38-04.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 00-38-15.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 00-38-15.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-06-53.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-06-53.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-08-14.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-08-14.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-09-04.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-09-04.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-09-09.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-09-09.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-14-56.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-14-56.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-15-43.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-15-43.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-16-12.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-16-12.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-18-14.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-18-14.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-18-33.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-18-33.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-18-51.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-18-51.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-19-30.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-19-30.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-19-54.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-19-54.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-20-17.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-20-17.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-20-34.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-20-34.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-20-51.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-20-51.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-22-25.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-22-25.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-22-42.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-22-42.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-22-56.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-22-56.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file05-12-2020 15-23-21.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file05-12-2020 15-23-21.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-56-40.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-56-40.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-18.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-18.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-24.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-24.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-29.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-29.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-37.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-37.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-41.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-41.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-52.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-52.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-57-58.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-57-58.wav -------------------------------------------------------------------------------- /musrara_projects/pack01/file06-12-2020 17-58-03.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Metallicode/python_dsp/HEAD/musrara_projects/pack01/file06-12-2020 17-58-03.wav -------------------------------------------------------------------------------- /renderer/print_text.py: -------------------------------------------------------------------------------- 1 | import time 2 | import random 3 | 4 | with open("introText") as f: 5 | d = f.read().strip() 6 | for i in range(len(d)): 7 | for j in range(len(d[i])): 8 | print(d[i][j], end="") 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /tonegenerator/myDriver.py: -------------------------------------------------------------------------------- 1 | from tonegenerator import Tone 2 | import time 3 | import sounddevice as sd 4 | 5 | f = open("notes.txt") 6 | 7 | l = 0.1 8 | 9 | for x in f: 10 | Tone(int(x), length=l, wavform="sin").generate() 11 | time.sleep(l) 12 | 13 | -------------------------------------------------------------------------------- /musrara_projects/Simple Sine Wave Printer.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | length = 100 4 | t = [i/length for i in range(length)] 5 | 6 | s = [math.sin(j*2*math.pi) for j in t] 7 | 8 | while True: 9 | for i in s: 10 | print('*'*int(((i+1)/2)*60)) 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /tonegenerator/notes.txt: -------------------------------------------------------------------------------- 1 | 345 2 | 789 3 | 456 4 | 345 5 | 789 6 | 456 7 | 232 8 | 6789 9 | 978 10 | 345 11 | 789 12 | 456 13 | 232 14 | 6789 15 | 978 16 | 3453 17 | 234 18 | 5674 19 | 354 20 | 2344 21 | 234 22 | 456 23 | 567 24 | 3453 25 | 3453 26 | 232 27 | 6789 28 | 978 29 | 3453 30 | 234 31 | 5674 32 | 354 33 | 2344 34 | 234 35 | 456 36 | 567 37 | 3453 -------------------------------------------------------------------------------- /polymetrix/composer.py: -------------------------------------------------------------------------------- 1 | while 1: 2 | BASE = input("Enter base pattern: \n") 3 | 4 | part_a = BASE[:len(BASE)//2] 5 | part_b = BASE[len(BASE)//2:] 6 | 7 | outro = part_a[:len(part_a)//2][::-1] 8 | 9 | pattern = part_a*2 + part_b + part_b[:-len(outro)] + outro 10 | 11 | #pattern = (part_a + part_b)*2 + part_b[:-len(outro)] + outro*3 12 | 13 | print(pattern) 14 | -------------------------------------------------------------------------------- /musrara_projects/Simple Triangle Wave Printer.py: -------------------------------------------------------------------------------- 1 | import time 2 | 3 | wave_length = 14 4 | 5 | x = 0 6 | directionIsUp = True 7 | 8 | while True: 9 | time.sleep(0.02) 10 | print("*"*(x+wave_length)) 11 | 12 | if directionIsUp is True: 13 | x+=1 14 | else: 15 | x-=1 16 | 17 | if x > wave_length: 18 | directionIsUp = False 19 | elif x < -wave_length: 20 | directionIsUp = True 21 | 22 | -------------------------------------------------------------------------------- /19_audio_recorder.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import sounddevice as sd 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | sr = 48000 7 | time = 5 8 | 9 | signal = sd.rec(int(time*sr), samplerate=sr, channels=1) 10 | sd.wait() 11 | 12 | sd.play(signal) 13 | 14 | #draw 15 | plt.plot(range(len(signal)), signal, "black") 16 | plt.show() 17 | 18 | #write file 19 | signal*= 32767 20 | signal = np.int16(signal) 21 | wavfile.write("file.wav", sr, signal) 22 | -------------------------------------------------------------------------------- /renderer/07_simple_fft.py: -------------------------------------------------------------------------------- 1 | import scipy.io.wavfile as wavfile 2 | import scipy 3 | import scipy.fftpack as fftpk 4 | from scipy import signal as sgl 5 | import numpy as np 6 | from matplotlib import pyplot as plt 7 | 8 | s_rate, signal = wavfile.read(input("filename?\n")) 9 | 10 | FFT = abs(scipy.fft.fft(signal)) 11 | freqs = fftpk.fftfreq(len(FFT), (1.0/s_rate)) 12 | 13 | plt.plot(freqs[range(len(FFT)//10)], FFT[range(len(FFT)//10)], color="red") 14 | 15 | plt.xlabel('Frequency (Hz)') 16 | plt.ylabel('Amplitude') 17 | plt.show() 18 | -------------------------------------------------------------------------------- /window_functions.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | 4 | if __name__ == '__main__': 5 | ## g = np.blackman(200) 6 | ## b = np.hanning(200) 7 | ## k = np.kaiser(200,1) 8 | ## v = np.bartlett(200) 9 | 10 | #draw 11 | ## plt.plot(range(len(g)),-g+1) 12 | ## plt.plot(range(len(b)),b) 13 | ## plt.plot(range(len(k)),k) 14 | 15 | ## plt.plot(range(len(v)),v) 16 | 17 | t = np.linspace(-50.0,50.0,100) 18 | s = np.cosh(t) 19 | plt.plot(range(len(s)),s) 20 | 21 | plt.show() 22 | -------------------------------------------------------------------------------- /07_quantization.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | 6 | 7 | 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 12 | 13 | 14 | 15 | ###get sample data from file 16 | samplerate, data = wavfile.read("beat.wav") 17 | data = norm(data) 18 | 19 | q = 0.8 20 | y = q* np.round(data/q) 21 | 22 | plt.plot(np.arange(len(data)),data) 23 | plt.show() 24 | 25 | ####WRITE AUDIO FILE#### 26 | y *= 32767 27 | y = np.int16(y) 28 | wavfile.write("file.wav", 44100, y) 29 | 30 | -------------------------------------------------------------------------------- /01_generate_signal.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | sample_rate = 44100 6 | frequency = 4 7 | 8 | t = np.arange(0,1.0,1.0/sample_rate) 9 | 10 | signal = np.sin(2 * np.pi * frequency * t) 11 | 12 | #signal = (np.mod(frequency*t,1) < 0.5)*2.0-1 13 | #noise = 1.0*np.random.randn(*signal.shape) 14 | 15 | ####PLOT SIGNAL#### 16 | ##plt.plot(t, signal,'black') 17 | ##plt.plot(t, signal+noise,'orange'); 18 | ##plt.show() 19 | 20 | 21 | 22 | ####WRITE AUDIO FILE#### 23 | ##signal *= 32767 24 | ##signal = np.int16(signal) 25 | ##wavfile.write("file.wav", sample_rate, signal) 26 | -------------------------------------------------------------------------------- /renderer/01_generate_sin.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | #first arg is length 7 | ## 2nd arg is frq 8 | 9 | frq = 440 10 | sr = 44100 11 | length = 5.0 12 | 13 | if(len(sys.argv)>1): 14 | length = float(sys.argv[1]) 15 | 16 | if(len(sys.argv)>2): 17 | frq = float(sys.argv[2]) 18 | 19 | 20 | 21 | 22 | 23 | 24 | t = np.arange(0, length, 1.0/sr) 25 | s = np.sin(2*np.pi* frq *t) 26 | 27 | 28 | plt.plot(t, s) 29 | plt.show() 30 | 31 | 32 | s *= 32767 33 | s = np.int16(s) 34 | print(f"rendering {frq}Hz_{length}Sec.wav") 35 | wavfile.write(f"{frq}Hz_{length}Sec.wav", sr, s) 36 | 37 | 38 | -------------------------------------------------------------------------------- /musrara_projects/Develop String Pattern.py: -------------------------------------------------------------------------------- 1 | def develop_pattern(pat_str): 2 | length = len(pat_str) 3 | if(length>2): 4 | p01 = develop_pattern(pat_str[:length//2]) 5 | p02 = develop_pattern(pat_str[length//2:]) 6 | return p01+p02 7 | 8 | return pat_str*2 9 | 10 | def repeate_every(seq, step, times=2): 11 | s = [] 12 | for i in range(len(seq)): 13 | s.append(seq[i]) 14 | if i%step==0: 15 | s.append(seq[i]) 16 | return "".join(s) 17 | 18 | my_str = input("enter your string: \n") 19 | x = repeate_every(develop_pattern(my_str), 4) 20 | z = repeate_every(develop_pattern(my_str[::-1]), 4) 21 | print(develop_pattern(x)+develop_pattern(z)[::-1]) 22 | -------------------------------------------------------------------------------- /12_removing_normalize_offset_from_samples.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | #better normalize function 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | 10 | #fix offset 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | 14 | #normalize array 15 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 16 | 17 | #scale values and return array 18 | return data * ((max_v/min_v)*-1) 19 | 20 | 21 | 22 | 23 | 24 | sr, data = wavfile.read("guitar.wav") 25 | 26 | data = norm(data) 27 | 28 | ##plot signal 29 | t = np.arange(0,1.0,1.0/len(data)) 30 | plt.plot(t, data) 31 | plt.show() 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /renderer/03_mix_signals.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | #arg 1 is length 7 | #arg 2 is comma seperated freqs 8 | 9 | frq = [440] 10 | sr = 44100 11 | length = 5.0 12 | 13 | if(len(sys.argv)>1): 14 | length = float(sys.argv[1]) 15 | 16 | if(len(sys.argv)>2): 17 | frq = [float(x) for x in sys.argv[2].split(",")] 18 | 19 | t = np.arange(0, length, 1.0/sr) 20 | s = np.zeros(int(length*sr)) 21 | 22 | for i in range(len(frq)): 23 | s += np.sin(2*np.pi* frq[i] *t) 24 | 25 | plt.plot(t, s) 26 | plt.show() 27 | 28 | s *= 32767 29 | s = np.int16(s) 30 | print(f"rendering Complex{length}Sec.wav") 31 | wavfile.write(f"Complex{length}Sec.wav", sr, s) 32 | 33 | 34 | -------------------------------------------------------------------------------- /renderer/04_amplitude_range.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | #arg 1 is length 7 | #arg 2 is comma seperated freqs 8 | 9 | frq = [440] 10 | sr = 44100 11 | length = 5.0 12 | 13 | if(len(sys.argv)>1): 14 | length = float(sys.argv[1]) 15 | 16 | if(len(sys.argv)>2): 17 | frq = [float(x) for x in sys.argv[2].split(",")] 18 | 19 | t = np.arange(0, length, 1.0/sr) 20 | s = np.zeros(int(length*sr)) 21 | 22 | for i in range(len(frq)): 23 | s += np.sin(2*np.pi* frq[i] *t)/len(frq) 24 | 25 | plt.plot(t, s) 26 | plt.show() 27 | 28 | s *= 32767 29 | s = np.int16(s) 30 | print(f"rendering Complex{length}Sec.wav") 31 | wavfile.write(f"Complex{length}Sec.wav", sr, s) 32 | 33 | -------------------------------------------------------------------------------- /renderer/02_binural_beats.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | #first arg is length 7 | #2nd arg is base freq 8 | #3rd arg is brainwave type 9 | 10 | sr = 44100 11 | brainwaves = {"delta":2, "theta":5, "alpha":10, "beta":20, "gamma":50} 12 | 13 | length = int(sys.argv[1]) 14 | frq = float(sys.argv[2]) 15 | diff = brainwaves[sys.argv[3].lower()] 16 | 17 | t = np.arange(0, length, 1.0/sr) 18 | 19 | s=np.vstack((np.sin(2*np.pi* frq *t), np.sin(2*np.pi* (frq+diff) *t))) 20 | s=s.transpose() 21 | 22 | s *= 32767 23 | s = np.int16(s) 24 | print(f"rendering {sys.argv[3].lower()}_Binural_{frq}Hz_{length}Sec.wav") 25 | wavfile.write(f"{sys.argv[3].lower()}_Binural_{frq}Hz_{length}Sec.wav", sr, s) 26 | 27 | 28 | -------------------------------------------------------------------------------- /06_clipping_overdrive_distortion.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | 6 | 7 | #normalize function 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 12 | 13 | ###get sample data from file 14 | samplerate, data = wavfile.read("sample.wav") 15 | 16 | 17 | #signal clipping 18 | thd = 0.3 19 | y = np.array([x/np.abs(x)-((x/np.abs(x))-(thd*x/np.abs(x))) if np.abs(x) > thd and x != 0 else x for x in signal]) 20 | 21 | 22 | ##signal overdrive 23 | drive = 5 24 | y = norm([1-np.exp(-x*drive) if x > 0 else -1+np.exp(x*drive) for x in signal]) 25 | 26 | 27 | 28 | ####WRITE AUDIO FILE#### 29 | y *= 32767 30 | y = np.int16(y) 31 | wavfile.write("clipped sample2.wav", 44100, y) 32 | 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /20_pyquncer.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | 4 | def prog(hz, length): 5 | t = np.arange(0,length,1.0/sample_rate) 6 | signal = np.sin(2 * np.pi * hz * t) 7 | return list(signal) 8 | 9 | sample_rate = 44100 10 | 11 | 12 | list_of_hz = [690,78,764,234,876,2000,100,234] 13 | list_of_lengths = [0.2,0.1,0.5,0.4,0.6,0.2,0.1,0.2] 14 | 15 | 16 | new_melody = [] 17 | 18 | 19 | for i in range(len(list_of_hz)): 20 | new_melody+=prog(list_of_hz[i], list_of_lengths[i]) 21 | 22 | new_melody = np.array(new_melody*5) 23 | 24 | 25 | 26 | ####FM it 27 | t = np.arange(0,len(new_melody)/sample_rate,1.0/sample_rate) 28 | new_melody = np.sin(2 * np.pi * 5 * new_melody * t) 29 | 30 | 31 | ##WRITE AUDIO FILE#### 32 | new_melody *= 32767 33 | new_melody = np.int16(new_melody) 34 | wavfile.write("file.wav", sample_rate, new_melody) 35 | -------------------------------------------------------------------------------- /tonegenerator/tonegenerator.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | import sounddevice as sd 4 | 5 | class Tone(): 6 | 7 | def __init__(self,pitch, wavform="sin", length=0.2, sample_rate=44100): 8 | self.wavform = wavform 9 | self.length = length 10 | self.pitch = pitch 11 | self.sample_rate = sample_rate 12 | self.signal = None 13 | 14 | def generate(self): 15 | t = np.arange(0,self.length,1.0/self.sample_rate) 16 | x = t * np.pi * 2 * self.pitch 17 | if self.wavform == "sin": 18 | self.signal = np.sin(2 * np.pi * self.pitch * t) 19 | elif self.wavform == "triangle": 20 | self.signal = np.abs((x/np.pi-0.5)%2-1)*2-1 21 | elif self.wavform == "saw": 22 | self.signal = -((x/np.pi)%2)+1 23 | 24 | sd.play(self.signal, self.sample_rate) 25 | -------------------------------------------------------------------------------- /05_butterworth filter.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy import signal 5 | 6 | 7 | def normalize(data): 8 | mi = min(data) 9 | ma = max(data) 10 | return np.array([((x-mi)/(ma-mi)) for x in data])*2.0-1 11 | 12 | 13 | sr, tone = wavfile.read("sample.wav") 14 | 15 | cutoff =1000 16 | w = cutoff/(44100/2) 17 | 18 | a,b = signal.butter(4, w, "high", analog=False) 19 | z = signal.filtfilt(a,b,tone) 20 | 21 | a,b = signal.bessel(4, w, "high", analog=False) 22 | q = signal.filtfilt(a,b,tone) 23 | 24 | z = normalize(z) 25 | q = normalize(q) 26 | 27 | #Graph signals 28 | plt.plot(np.arange(len(z)), normalize(tone), "orange") 29 | plt.plot(np.arange(len(z)), z, "black") 30 | 31 | plt.show() 32 | 33 | 34 | ####WRITE AUDIO FILE#### 35 | z *= 32767 36 | z = np.int16(z) 37 | wavfile.write("hp_filter.wav", sr, z) 38 | 39 | 40 | -------------------------------------------------------------------------------- /renderer/05_clusters.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | #arg 1 is length 7 | #arg 2 is freq 8 | #arg 3 is osc_n 9 | #arg 4 is q 10 | 11 | frq = 440 12 | sr = 44100 13 | length = 5.0 14 | osc_n = 2 15 | q = 1 16 | 17 | 18 | if(len(sys.argv)>1): 19 | length = float(sys.argv[1]) 20 | 21 | if(len(sys.argv)>2): 22 | frq = float(sys.argv[2]) 23 | 24 | if(len(sys.argv)>3): 25 | osc_n = int(sys.argv[3]) 26 | 27 | if(len(sys.argv)>4): 28 | q = float(sys.argv[4]) 29 | 30 | t = np.arange(0, length, 1.0/sr) 31 | 32 | s = np.sin(2*np.pi*frq*t)/osc_n 33 | 34 | for i in range(osc_n-1): 35 | s += np.sin(2*np.pi* (frq+(i*(q/osc_n))) *t)/osc_n 36 | 37 | plt.plot(t, s) 38 | plt.show() 39 | 40 | s *= 32767 41 | s = np.int16(s) 42 | print(f"rendering cluster{length}Sec.wav") 43 | wavfile.write(f"cluster_{length}Sec.wav", sr, s) 44 | 45 | -------------------------------------------------------------------------------- /02_add_noise.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | #normalize function 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 10 | 11 | ###SET sample rate & signal frequency 12 | sample_rate = 44100 13 | frequency = 80 #Hz 14 | 15 | t = np.arange(0,1.0,1.0/sample_rate) 16 | 17 | ####PRODUCE SIGNALS 18 | #signal = np.sin(2 * np.pi * frequency * t) 19 | signal = (np.mod(frequency*t,1) < 0.5)*2.0-1 20 | noise = 1.0*np.random.randn(*signal.shape) 21 | 22 | ####COMBINE NOISE AND SIGNAL (and normalize array...) 23 | dirty = norm(signal+noise) 24 | 25 | ####PLOT SIGNAL#### 26 | plt.plot(t, dirty,'orange'); 27 | plt.show() 28 | 29 | ####WRITE AUDIO FILE#### 30 | ##signal *= 32767 31 | ##signal = np.int16(signal) 32 | ##wavfile.write("file.wav", sample_rate, signal) 33 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] 4 | patreon: # Replace with a single Patreon username 5 | open_collective: # Replace with a single Open Collective username 6 | ko_fi: # Replace with a single Ko-fi username 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry 9 | liberapay: # Replace with a single Liberapay username 10 | issuehunt: # Replace with a single IssueHunt username 11 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry 12 | polar: # Replace with a single Polar username 13 | buy_me_a_coffee: metallicode 14 | thanks_dev: # Replace with a single thanks.dev username 15 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] 16 | -------------------------------------------------------------------------------- /11_Chorus.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy.signal import savgol_filter 5 | 6 | 7 | #normalize function 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 12 | 13 | ###get sample data from file 14 | samplerate, data = wavfile.read("guitar.wav") 15 | t = np.arange(0,1.0,1.0/len(data)) 16 | data = np.array(data,dtype=np.float64) 17 | data = norm(data) 18 | 19 | ###Chorus FX#### 20 | mod_frequency = 7.0 #Hz 21 | depth = 100.0 22 | 23 | lfo = np.sin(2*np.pi * t * mod_frequency)*depth 24 | 25 | 26 | product = np.zeros_like(data) 27 | 28 | 29 | for i in range(0, len(data)): 30 | product[i] = data[i + int(lfo[i])] 31 | 32 | 33 | product = savgol_filter(product, 51, 3) 34 | 35 | product = norm(data + product) 36 | 37 | 38 | 39 | #plot signal 40 | plt.plot(t,product) 41 | plt.show() 42 | 43 | ####WRITE AUDIO FILE#### 44 | product *= 32767 45 | product = np.int16(product) 46 | wavfile.write("chorus_out.wav", 44100, product) 47 | -------------------------------------------------------------------------------- /musrara_projects/Grain Player.py: -------------------------------------------------------------------------------- 1 | import time 2 | from scipy.io import wavfile 3 | import numpy as np 4 | 5 | def OpenFile(name): 6 | samplerate, signal = wavfile.read(f"{name}") 7 | return np.array(signal,dtype=np.float64) 8 | 9 | 10 | def MakeFile(signal): 11 | signal *=32767 12 | signal = np.int16(signal) 13 | wavfile.write(f"file.wav", 44100, signal) 14 | 15 | def norm(data): 16 | min_v = min(data) 17 | max_v = max(data) 18 | offset = min_v+max_v 19 | data = data+(offset/2) 20 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 21 | return data * ((max_v/min_v)*-1) 22 | 23 | 24 | signal = OpenFile("grain_player.wav") 25 | 26 | segments = 100 27 | grain_size = 3 28 | directionIsUp = True 29 | buff = len(signal)//segments 30 | 31 | 32 | x = 0 33 | z = 5 34 | ls = [] 35 | 36 | while z > 0: 37 | 38 | ls += list(signal[x:x+(buff*grain_size)]) 39 | if directionIsUp is True: 40 | x+=buff 41 | else: 42 | x-=buff 43 | 44 | if x > segments*buff: 45 | directionIsUp = False 46 | elif x < 0: 47 | directionIsUp = True 48 | z -=1 49 | 50 | MakeFile(norm(ls)) 51 | 52 | 53 | -------------------------------------------------------------------------------- /08_AM.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | 6 | #normalize function 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 11 | 12 | ###get sample data from file 13 | ##samplerate, data = wavfile.read("beat.wav") 14 | ##data = norm(data) 15 | 16 | t = np.arange(0,1.0,1.0/44100) 17 | ##t = np.arange(0,1.0,1.0/len(data)) 18 | 19 | ###signal frequency 20 | carrier_frequency = 100 #Hz 21 | modulator_frequency = 70 #Hz 22 | 23 | depth = 0.9 24 | carrier = np.sin(2 * np.pi * carrier_frequency * t) 25 | modulator = np.sin(2 * np.pi * modulator_frequency * t)*depth-(1-depth) 26 | 27 | 28 | 29 | y = norm(carrier*modulator) 30 | 31 | plt.plot(t, y) 32 | plt.show() 33 | 34 | 35 | ####PLOT SIGNAL IN FREQUENCY DOMAIN#### 36 | ##plt.plot(np.arange(20000),np.abs(np.fft.ifft(norm(data)))[:20000]) 37 | plt.plot(np.arange(500),np.abs(np.fft.ifft(y))[:500]) 38 | plt.show() 39 | 40 | ####WRITE AUDIO FILE#### 41 | ##y *= 32767 42 | ##y = np.int16(y) 43 | ##wavfile.write("file.wav", samplerate, y) 44 | ## 45 | 46 | -------------------------------------------------------------------------------- /wav_analyzer/wav_analyzer_simple_hist.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from create_wav import wave_maker 5 | 6 | def _burst(signal, index): 7 | counter = 0 8 | for i in range(index,len(signal)): 9 | if signal[i] == signal[index]: 10 | counter +=1 11 | else: 12 | break 13 | return counter 14 | 15 | def analyze(signal, min_burst_length = 1): 16 | counter = 0 17 | bursts_indexes = [] 18 | 19 | while counter min_burst_length: 25 | counter += burst_size 26 | else: 27 | counter+=1 28 | return bursts_indexes 29 | 30 | 31 | if __name__ == "__main__": 32 | 33 | sr, data = wavfile.read("file.wav") 34 | output = analyze(data) 35 | 36 | lengths = [x[1]-x[0] for x in output] 37 | 38 | plt.hist(lengths, bins = 100) 39 | plt.show() 40 | 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /renderer/06_log_amplitude.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | offset = min_v+max_v 10 | data = data+(offset/2) 11 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 12 | return data * ((max_v/min_v)*-1) 13 | 14 | 15 | #arg 1 is length 16 | #arg 2 is fondamental 17 | #arg 3 is n_overtons 18 | 19 | frq = 100 20 | sr = 44100 21 | length = 5.0 22 | n_overtons = 5 23 | 24 | if(len(sys.argv)>1): 25 | length = float(sys.argv[1]) 26 | 27 | if(len(sys.argv)>2): 28 | frq = float(sys.argv[2]) 29 | 30 | if(len(sys.argv)>3): 31 | n_overtons = int(sys.argv[3]) 32 | 33 | 34 | t = np.arange(0, length, 1.0/sr) 35 | s = np.zeros(int(length*sr)) 36 | 37 | for i in range(n_overtons): 38 | s += np.sin(2*np.pi* (frq*(i+1)) *t)*(1/(i+1)) 39 | 40 | s=norm(s) 41 | 42 | plt.bar(range(n_overtons),[1/(x+1) for x in range(n_overtons)]) 43 | plt.show() 44 | plt.plot(t, s) 45 | plt.show() 46 | 47 | s *= 32767 48 | s = np.int16(s) 49 | print(f"rendering StringHarmony{length}Sec_LogGain.wav") 50 | wavfile.write(f"StringHarmony{length}Sec_LogGain.wav", sr, s) 51 | 52 | 53 | 54 | -------------------------------------------------------------------------------- /17_rms.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy.signal import butter,filtfilt 5 | 6 | #normalize function 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | offset = min_v+max_v 11 | data = data+(offset/2) 12 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 13 | return data * ((max_v/min_v)*-1) 14 | 15 | #read file 16 | samplerate, signal = wavfile.read("count.wav") 17 | signal = norm(np.array(signal,dtype=np.float64)) 18 | 19 | ########-RMS-######### 20 | rms = np.zeros_like(signal) 21 | db = np.zeros_like(signal) 22 | buffer_size = 1000 23 | 24 | for i in range(0,len(signal),buffer_size): 25 | s = signal[i:i+buffer_size] 26 | buffer = np.sqrt(np.mean(s**2)) 27 | rms[i:i+buffer_size] = buffer 28 | db[i:i+buffer_size] = 20 * np.log10(buffer) 29 | 30 | #smooth... 31 | cutoff = 20 32 | normal_cutoff = cutoff / (44100/2) 33 | b, a = butter(2, normal_cutoff, btype="low", analog=False) 34 | rms = filtfilt(b, a,rms) 35 | db = filtfilt(b, a,db) 36 | 37 | #draw 38 | plt.subplot(211, ylabel='RMS') 39 | plt.plot(range(len(signal)), signal, "black") 40 | plt.plot(range(len(rms)), rms, "red") 41 | plt.subplot(212, ylabel='dBFS') 42 | plt.plot(range(len(db)), db, "green") 43 | plt.show() 44 | -------------------------------------------------------------------------------- /14_saw_&_unison.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy import signal as sgl 5 | 6 | #normalize function 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 11 | 12 | sample_rate = 44100 13 | frequency = 100 14 | note_length = 2 15 | t = np.arange(0,1.0*note_length,1.0/sample_rate) 16 | 17 | 18 | def cloud_maker(freq , n, diff, t, octaver=True): 19 | product = sgl.sawtooth(2 * np.pi * freq * t) 20 | 21 | for i in range(n): 22 | product += sgl.sawtooth(2 * np.pi * (freq-diff) * t) 23 | product += sgl.sawtooth(2 * np.pi * (freq+diff) * t) 24 | diff += diff 25 | product = norm(product) 26 | if octaver == True: 27 | product += sgl.sawtooth(2 * np.pi * freq/2 * t) 28 | product += sgl.sawtooth(2 * np.pi * freq/4 * t)*0.5 29 | return product 30 | 31 | 32 | 33 | 34 | 35 | 36 | #SAW WAVE 37 | product = cloud_maker(frequency, 20, 0.000001, t) 38 | 39 | y = norm(product) 40 | 41 | 42 | 43 | 44 | 45 | 46 | ####PLOT SIGNAL IN FREQUENCY DOMAIN#### 47 | plt.plot(np.arange(4000),np.abs(np.fft.ifft(y))[:4000]) 48 | 49 | #plt.plot(t,y) 50 | plt.show() 51 | 52 | ####WRITE AUDIO FILE#### 53 | y *= 32767 54 | y = np.int16(y) 55 | wavfile.write("file.wav", 44100, y) 56 | 57 | 58 | -------------------------------------------------------------------------------- /03_filter_signal_LP.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | 6 | def LPF(data,alpha): 7 | yi = 0 8 | y = [] 9 | for i in range(len(data)): 10 | yi += alpha*(data[i]-yi) 11 | y.append(yi) 12 | return y 13 | 14 | #normalize function 15 | def norm(data): 16 | min_v = min(data) 17 | max_v = max(data) 18 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 19 | 20 | 21 | 22 | ###SET sample rate & signal frequency 23 | sample_rate = 44100 24 | frequency = 5 #Hz 25 | 26 | t = np.arange(0,1.0,1.0/sample_rate) 27 | 28 | ####PRODUCE SIGNALS 29 | #signal = np.sin(2 * np.pi * frequency * t) 30 | signal = (np.mod(frequency*t,1) < 0.5)*2.0-1 31 | noise = 1.0*np.random.randn(*signal.shape) 32 | 33 | ####COMBINE NOISE AND SIGNAL (and normalize array...) 34 | #dirty = norm(signal+noise) 35 | 36 | sr, data = wavfile.read("sample.wav") 37 | 38 | dirty = norm(data) 39 | 40 | 41 | cutoff = 5 42 | alpha = cutoff / (sample_rate/2) 43 | 44 | 45 | 46 | 47 | ####PLOT SIGNAL IN FREQUENCY DOMAIN#### 48 | ##plt.plot(np.arange(20000),np.abs(np.fft.ifft(norm(data)))[:20000]) 49 | ##plt.plot(np.arange(20000),np.abs(np.fft.ifft(dirty))[:20000]) 50 | ## 51 | ##plt.show() 52 | 53 | ####WRITE AUDIO FILE#### 54 | dirty *= 32767 55 | dirty = np.int16(dirty) 56 | wavfile.write("filed.wav", sample_rate, dirty) 57 | -------------------------------------------------------------------------------- /10_FM_samples.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | #normalize function 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 10 | 11 | ###get sample data from file 12 | samplerate, data = wavfile.read("beat.wav") 13 | t = np.arange(0,1.0,1.0/len(data)) 14 | data = norm(np.array(data,dtype=np.float64)) #using float64 type for np.array 15 | 16 | 17 | 18 | 19 | ###FM the sample######################### 20 | carrier_frequency = 10000.0 # Hz 21 | depth = 5000.0 # Hz 22 | 23 | #memory allocation 24 | product = np.zeros_like(data) 25 | 26 | #reset phase variable 27 | phase = 0 28 | 29 | 30 | #FM the signal 31 | for n in range(0, len(data)): 32 | #calc phase 33 | phase += data[n] * np.pi * depth / samplerate 34 | phase %= 2 * np.pi 35 | 36 | #calc carrier 37 | carrier = 2 * np.pi * carrier_frequency * (n / float(samplerate)) 38 | 39 | #modulate signals 40 | product[n] = np.cos(phase) * np.cos(carrier) - np.sin(phase) * np.sin(carrier) 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | product = norm(product) 49 | 50 | 51 | #plot signal 52 | plt.plot(t,product) 53 | plt.show() 54 | 55 | ####WRITE AUDIO FILE#### 56 | product *= 32767 57 | product = np.int16(product) 58 | wavfile.write("file.wav", 44100, product) 59 | -------------------------------------------------------------------------------- /musrara_projects/Simple Tone Sequencer.py: -------------------------------------------------------------------------------- 1 | ####THIS IS THE MODULES WE NEED TO RUN OUR SCRIPT 2 | import numpy as np 3 | from scipy.io import wavfile 4 | import matplotlib.pyplot as plt 5 | import datetime 6 | 7 | 8 | ####HERE ARE THE FUNCTIONS WE WILL USE TO CREATE OUR SIGNALS AND FILE 9 | def Make_A_Tone(length, freq): 10 | t = np.arange(0,length, 1.0/44100) 11 | return list(np.sin(2*np.pi* t * freq)) 12 | 13 | def MakeFile(signal): 14 | now = datetime.datetime.now() 15 | signal *=32767 16 | signal = np.int16(signal) 17 | wavfile.write(f"file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav", 44100, signal) 18 | 19 | 20 | #####FROM HERE IS THE DRIVER CODE 21 | 22 | #FIRST WE SET SOME VARIABLES 23 | steps_in_sequence = 10 #HOW MENY STEPS IN OUR MELODY 24 | signal_length = 0.1 #IN SECONDS 25 | base_freq = 400 #IN Hz 26 | 27 | sequence = [] 28 | 29 | 30 | #******************************************************************************# 31 | 32 | #HERE IS THE LOOP WE USE TO SET OUR TONES 33 | for i in range(steps_in_sequence): 34 | sequence += Make_A_Tone(signal_length, base_freq*i) #<----TRY PLAYING WITH THIS PART 35 | 36 | #******************************************************************************# 37 | 38 | sequence *= 2 #WE CAN MAKE OUR PATTERN PLAY MORE THEN ONCE... 39 | 40 | 41 | ####HERE WE CALL THE MAKEFILE FUNCTION THAT WILL SAVE OUR DATA TO A FILE 42 | MakeFile(np.array(sequence)) 43 | 44 | 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /SamplePatternPlayer/samplePlayer3.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | import glob 4 | from datetime import datetime 5 | import random 6 | 7 | 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 14 | return data * ((max_v/min_v)*-1) 15 | 16 | 17 | 18 | loop_string = input("enter loop string:\n") 19 | 20 | 21 | speed = 8000 22 | pack = "pack01" 23 | 24 | all_files_in_dir = glob.glob(f"{pack}/*.wav") 25 | 26 | 27 | sample_pool = [] 28 | 29 | for i in range(len(all_files_in_dir)): 30 | _, signal = wavfile.read(all_files_in_dir[i]) 31 | sample_pool.append(np.array(signal,dtype=np.float64)[:speed]) 32 | 33 | 34 | loop = [] 35 | 36 | for i in range(len(loop_string)): 37 | current = loop_string[i] 38 | inx = ord(current)%len(all_files_in_dir) 39 | current_sample_length = len(sample_pool[inx]) 40 | 41 | l = list(sample_pool[inx]) 42 | if i%4==0: 43 | v = random.choice([2,4,8,16]) 44 | l = l[:current_sample_length//v]*v 45 | elif i%6==0: 46 | l = l[:current_sample_length//3]*3 47 | elif i%5==0: 48 | l = l[::-1] 49 | loop += l 50 | 51 | 52 | 53 | 54 | loop *= 10 55 | 56 | 57 | loop = norm(loop) 58 | now = datetime.now() 59 | loop *=32767 60 | loop = np.int16(loop) 61 | wavfile.write(f"file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav",44100, loop) 62 | -------------------------------------------------------------------------------- /musrara_projects/Simple Tone Sequencer#2.py: -------------------------------------------------------------------------------- 1 | ####THIS IS THE MODULES WE NEED TO RUN OUR SCRIPT 2 | import numpy as np 3 | from scipy.io import wavfile 4 | import matplotlib.pyplot as plt 5 | import datetime 6 | 7 | 8 | ####HERE ARE THE FUNCTIONS WE WILL USE TO CREATE OUR SIGNALS AND FILE 9 | def Make_A_Tone(length, freq): 10 | t = np.arange(0,length, 1.0/44100) 11 | return list(np.sin(2*np.pi* t * freq)) 12 | 13 | def MakeFile(signal): 14 | now = datetime.datetime.now() 15 | signal *=32767 16 | signal = np.int16(signal) 17 | wavfile.write(f"melod{now.strftime('%d-%m-%Y %H-%M-%S')}.wav", 44100, signal) 18 | 19 | 20 | #####FROM HERE IS THE DRIVER CODE 21 | 22 | #FIRST WE SET SOME VARIABLES 23 | steps_in_sequence = 100 #HOW MENY STEPS IN OUR MELODY 24 | signal_length = 0.1 #IN SECONDS 25 | base_freq = 400 #IN Hz 26 | 27 | sequence = [] 28 | 29 | 30 | #******************************************************************************# 31 | 32 | #HERE IS THE LOOP WE USE TO SET OUR TONES 33 | for i in range(steps_in_sequence): 34 | sequence += Make_A_Tone(signal_length, i*(base_freq+i*9)%700) #<----TRY PLAYING WITH THIS PART 35 | 36 | #******************************************************************************# 37 | 38 | sequence *= 2 #WE CAN MAKE OUR PATTERN PLAY MORE THEN ONCE... 39 | 40 | 41 | ####HERE WE CALL THE MAKEFILE FUNCTION THAT WILL SAVE OUR DATA TO A FILE 42 | MakeFile(np.array(sequence)) 43 | 44 | 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /musrara_projects/Sample Player.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | import glob 4 | from datetime import datetime 5 | import random 6 | 7 | 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 14 | return data * ((max_v/min_v)*-1) 15 | 16 | 17 | 18 | loop_string = input("enter loop string:\n") 19 | 20 | 21 | speed = 8000 22 | pack = "pack"+input("pack number:\n") 23 | 24 | all_files_in_dir = glob.glob(f"{pack}/*.wav") 25 | 26 | 27 | sample_pool = [] 28 | 29 | for i in range(len(all_files_in_dir)): 30 | _, signal = wavfile.read(all_files_in_dir[i]) 31 | sample_pool.append(np.array(signal,dtype=np.float64)[:speed]) 32 | 33 | 34 | loop = [] 35 | 36 | for i in range(len(loop_string)): 37 | current = loop_string[i] 38 | inx = ord(current)%len(all_files_in_dir) 39 | current_sample_length = len(sample_pool[inx]) 40 | 41 | l = list(sample_pool[inx]) 42 | if i%3==0: 43 | v = random.choice([2,4,8,16,32,64]) 44 | l = l[:current_sample_length//v]*v 45 | elif i%4==0: 46 | l = l[:current_sample_length//3]*3 47 | elif i%5==0: 48 | l = l[::-1] 49 | loop += l 50 | 51 | 52 | 53 | 54 | loop *= 2 55 | 56 | loop = norm(loop) 57 | now = datetime.now() 58 | loop *=32767 59 | loop = np.int16(loop) 60 | wavfile.write(f"file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav",44100, loop) 61 | -------------------------------------------------------------------------------- /09a_FM.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | #normalize function 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 10 | 11 | 12 | 13 | 14 | 15 | ###FM Part#### 16 | modulator_frequency = 5.0 #Hz 17 | carrier_frequency = 100.0 #Hz 18 | 19 | length = 1 20 | #signal length in seconds 21 | sr = 44100.0 #sample rate 22 | t = np.arange(0,1.0,1.0/(length*sr)) #time axis 23 | 24 | depth = 2 #modulation strength 25 | modulator = np.sin(2.0 * np.pi * modulator_frequency * t) * depth #modulator signal 26 | 27 | product = np.zeros_like(modulator) #allocat memory 28 | 29 | #generate modulated signal 30 | for i, j in enumerate(t): 31 | product[i] = np.sin(2. * np.pi * (carrier_frequency * j + modulator[i])) 32 | 33 | y = norm(product) #normalize signal 34 | 35 | 36 | 37 | 38 | 39 | 40 | #plot time & frequency and save to disk..... 41 | 42 | plt.plot(t,y ) 43 | plt.plot(t, norm(modulator), color="red") 44 | plt.show() 45 | 46 | ####PLOT SIGNAL IN FREQUENCY DOMAIN#### 47 | plt.plot(np.arange(1000),np.abs(np.fft.ifft(y))[:1000]) 48 | plt.show() 49 | 50 | ####WRITE AUDIO FILE#### 51 | y *= 32767 52 | y = np.int16(y) 53 | wavfile.write("file.wav", 44100, y) 54 | 55 | 56 | -------------------------------------------------------------------------------- /04_filter_signal_HP.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | 5 | 6 | def LPF(data,alpha): 7 | yi = 0 8 | y = [] 9 | for i in range(len(data)): 10 | yi += alpha*(data[i]-yi) 11 | y.append(yi) 12 | return y 13 | 14 | #normalize function 15 | def norm(data): 16 | min_v = min(data) 17 | max_v = max(data) 18 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 19 | 20 | ###SET sample rate & signal frequency 21 | sample_rate = 44100 22 | frequency = 5 #Hz 23 | 24 | t = np.arange(0,1.0,1.0/sample_rate) 25 | 26 | ####PRODUCE SIGNALS 27 | signal = np.sin(2 * np.pi * frequency * t) 28 | #signal = (np.mod(frequency*t,1) < 0.5)*2.0-1 29 | noise = 1.0*np.random.randn(*signal.shape) 30 | 31 | ####COMBINE NOISE AND SIGNAL (and normalize array...) 32 | #dirty = norm(signal+noise) 33 | 34 | sr, data = wavfile.read("sample.wav") 35 | data = norm(data) 36 | 37 | cutoff = 1000 38 | alpha = cutoff / (sample_rate/2) 39 | 40 | 41 | ##HPF Trick 42 | inverted = norm(LPF(data,alpha))*-1 43 | dirty = norm(data+inverted) 44 | 45 | 46 | 47 | ####PLOT SIGNAL IN FREQUENCY DOMAIN#### 48 | plt.plot(np.arange(20000),np.abs(np.fft.ifft(norm(data)))[:20000]) 49 | plt.plot(np.arange(20000),np.abs(np.fft.ifft(dirty))[:20000]) 50 | 51 | plt.show() 52 | 53 | ####WRITE AUDIO FILE#### 54 | dirty *= 32767 55 | dirty = np.int16(dirty) 56 | wavfile.write("file.wav", sample_rate, dirty) 57 | -------------------------------------------------------------------------------- /SamplePatternPlayer/sample_player2.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | import glob 4 | from datetime import datetime 5 | 6 | 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | offset = min_v+max_v 11 | data = data+(offset/2) 12 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 13 | return data * ((max_v/min_v)*-1) 14 | 15 | 16 | 17 | loop_string = "poikiujpoikiujpoikhyufrtbhjxfxfxfxfdrt" 18 | 19 | 20 | speed = 6000 21 | pack = "pack01" 22 | 23 | all_files_in_dir = glob.glob(f"{pack}/*.wav") 24 | 25 | 26 | sample_pool = [] 27 | 28 | for i in range(len(all_files_in_dir)): 29 | _, signal = wavfile.read(all_files_in_dir[i]) 30 | sample_pool.append(np.array(signal,dtype=np.float64)[:speed]) 31 | 32 | 33 | loop = [] 34 | 35 | for i in range(len(loop_string)): 36 | current = loop_string[i] 37 | inx = ord(current)%len(all_files_in_dir) 38 | current_sample_length = len(sample_pool[inx]) 39 | 40 | l = list(sample_pool[inx]) 41 | if i%4==0: 42 | l = l[:current_sample_length//2]*2 43 | elif i%6==0: 44 | l = l[:current_sample_length//3]*3 45 | elif i%5==0: 46 | l = l[::-1] 47 | loop += l 48 | 49 | 50 | 51 | 52 | loop *= 10 53 | 54 | 55 | loop = norm(loop) 56 | now = datetime.now() 57 | loop *=32767 58 | loop = np.int16(loop) 59 | wavfile.write(f"file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav",88888, loop) 60 | 61 | 62 | 63 | 64 | 65 | 66 | -------------------------------------------------------------------------------- /polymetrix/polymetrix.py: -------------------------------------------------------------------------------- 1 | from scipy.io import wavfile 2 | import numpy as np 3 | from datetime import datetime 4 | 5 | def norm(data): 6 | min_v = min(data) 7 | max_v = max(data) 8 | offset = min_v+max_v 9 | data = data+(offset/2) 10 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 11 | return data * ((max_v/min_v)*-1) 12 | 13 | def render(beat, smpl): 14 | signal = [] 15 | silence = np.zeros(len(smpl)) 16 | for i in beat: 17 | if (i == "1"): 18 | signal+=list(np.array(smpl,dtype=np.float64)) 19 | elif (i == "0"): 20 | signal+=list(silence) 21 | else: 22 | signal+=list(np.array(smpl,dtype=np.float64))[::-1] 23 | 24 | return np.array(signal) 25 | 26 | 27 | 28 | 29 | 30 | SAMPLE_RATE = 44100 31 | BPM = 200 32 | TEMPO = 2 33 | STEP_TIME = 60000/(BPM * TEMPO) 34 | 35 | _, sample_a = wavfile.read("sound01.wav") 36 | _, sample_b = wavfile.read("sound02.wav") 37 | 38 | sample_a = sample_a[:int(SAMPLE_RATE*(STEP_TIME/1000))] 39 | sample_b = sample_b[:int(SAMPLE_RATE*(STEP_TIME/1000))] 40 | 41 | beat_a = input("enter first pattern: ") 42 | beat_b = input("enter 2nd pattern: ") 43 | 44 | beat_a *= len(beat_b) 45 | beat_b *= len(beat_a)//len(beat_b) 46 | 47 | new = norm(render(beat_a, sample_a)+render(beat_b, sample_b)) 48 | 49 | 50 | new = np.array(list(new)*20) 51 | 52 | ####WRITE AUDIO FILE#### 53 | now = datetime.now() 54 | new *=32767 55 | new = np.int16(new) 56 | wavfile.write(f"file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav", int(44100), new) 57 | -------------------------------------------------------------------------------- /SamplePatternPlayer/sample_player.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import wavfile 3 | import glob 4 | from datetime import datetime 5 | 6 | def norm(data): 7 | min_v = min(data) 8 | max_v = max(data) 9 | offset = min_v+max_v 10 | data = data+(offset/2) 11 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 12 | return data * ((max_v/min_v)*-1) 13 | 14 | 15 | #set sample pack & loop string 16 | pack = "pack01" 17 | loop_string = "07704050405050201063225412457643100"*10 18 | speed = 5000 19 | pitch = 0.5 20 | 21 | 22 | 23 | #read all files in folder pack 24 | all_files_in_dir = glob.glob(f"{pack}/*.wav") 25 | 26 | sample_pool = [] 27 | 28 | for i in range(len(all_files_in_dir)): 29 | _, signal = wavfile.read(all_files_in_dir[i]) 30 | sample_pool.append(np.array(signal,dtype=np.float64)[:speed]) 31 | 32 | 33 | 34 | 35 | 36 | #Build Loop 37 | new = [] 38 | 39 | for x in range(len(loop_string)): 40 | current = int(loop_string[x]) 41 | current_sample_length = len(sample_pool[current]) 42 | 43 | l = list(sample_pool[current]) 44 | if x%4==0: 45 | l = l[:current_sample_length//2]*2 46 | elif x%6==0: 47 | l = l[:current_sample_length//3]*3 48 | elif x%5==0: 49 | l = l[::-1] 50 | 51 | new += l 52 | 53 | new = norm(new) 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | ####WRITE AUDIO FILE#### 62 | now = datetime.now() 63 | new *=32767 64 | new = np.int16(new) 65 | wavfile.write(f"exports/file{now.strftime('%d-%m-%Y %H-%M-%S')}.wav", int(44100*pitch), new) 66 | -------------------------------------------------------------------------------- /wavtable.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | import scipy.fftpack as fftpk 5 | import scipy 6 | 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 11 | 12 | def slop(n, s_type = "lin", direction_up='false'): 13 | if(s_type == "lin"): 14 | w = np.linspace(1.0, 0, n) 15 | elif(s_type == "log"): 16 | w = 1.0/(np.logspace(0, 1.0, n)) 17 | elif(s_type == "cir"): 18 | w = [1-(1-(i/(n-1)-1)**2)**0.5 for i in range(n)] 19 | elif(s_type == "sig"): 20 | w = (-np.sin(np.linspace(1.0, 0, n)*np.pi +np.pi/2)+1.0)/2.0 21 | 22 | return w if direction_up else w[::-1] 23 | 24 | 25 | 26 | sr = 44100 27 | length = 0.1 28 | n_overtones = 20 29 | fondemental = 100 30 | weights = slop(n_overtones, s_type = "cir") 31 | 32 | plt.bar(range(n_overtones), weights) 33 | plt.show() 34 | 35 | 36 | 37 | t = np.arange(0, length, 1.0/sr) 38 | 39 | signal = np.zeros(int(sr*length)) 40 | series = [] 41 | for i in range(1,n_overtones,1): 42 | signal += np.sin(2*np.pi*(fondemental*i)*t)*weights[i] 43 | #series += list(np.sin(2*np.pi*(fondemental*i)*t)) 44 | 45 | signal = norm(signal) 46 | 47 | FFT = abs(scipy.fft.fft(signal)) 48 | freqs = fftpk.fftfreq(len(FFT), (1.0/sr)) 49 | 50 | plt.plot(freqs[range(len(FFT)//n_overtones)], FFT[range(len(FFT)//n_overtones)]) 51 | plt.show() 52 | 53 | 54 | 55 | 56 | #plt.plot(t, signal) 57 | #plt.show() 58 | 59 | #signal = norm(series) 60 | 61 | 62 | #signal *= 32767 63 | #signal = np.int16(signal) 64 | #wavfile.write("file7.wav", sr, signal) 65 | 66 | 67 | -------------------------------------------------------------------------------- /renderer/wavetables.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from scipy.io import wavfile 5 | 6 | class Wavtable: 7 | def __init__(self, frqs=[440], length=1.0, slop_type=None, sr=44100): 8 | self.frqs = frqs 9 | self.sr = 44100 10 | self.length = length 11 | self.slop_type = slop_type 12 | self.t = np.arange(0, self.length, 1.0/self.sr) 13 | self.s = np.zeros(int(self.length*self.sr)) 14 | 15 | 16 | def _norm(self, data): 17 | min_v = min(data) 18 | max_v = max(data) 19 | offset = min_v+max_v 20 | data = data+(offset/2) 21 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 22 | return data * ((max_v/min_v)*-1) 23 | 24 | def _slop_maker(self, n, s_type, direction_up='false'): 25 | if(self.slop_type is None): 26 | w = [1 for i in range(n)] 27 | else: 28 | if(s_type == "lin"): 29 | w = np.linspace(1.0, 0, n) 30 | elif(s_type == "log"): 31 | w = 1.0/(np.logspace(0, 1.0, n)) 32 | elif(s_type == "cir"): 33 | w = [1-(1-(i/(n-1)-1)**2)**0.5 for i in range(n)] 34 | elif(s_type == "sig"): 35 | w = (-np.sin(np.linspace(1.0, 0, n)*np.pi +np.pi/2)+1.0)/2.0 36 | 37 | return w if direction_up else w[::-1] 38 | 39 | def MakeSignal(self): 40 | slop_weights = self._slop_maker(len(self.s), s_type=self.slop_type) 41 | for i in range(len(self.frqs)): 42 | self.s += np.sin(2*np.pi* self.frqs[i] * self.t)*slop_weights[i] 43 | self.s = self._norm(self.s) 44 | return self.s 45 | 46 | def Render(self, name): 47 | self.s *= 32767 48 | self.s = np.int16(self.s) 49 | print(f"rendering wav file..") 50 | wavfile.write(f"{name}.wav", self.sr, self.s) 51 | 52 | 53 | 54 | -------------------------------------------------------------------------------- /13_Echo.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy import signal as sig 5 | 6 | #better normalize function 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | 11 | #fix offset 12 | offset = min_v+max_v 13 | data = data+(offset/2) 14 | 15 | #normalize array 16 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 17 | 18 | #scale values and return array 19 | return data * ((max_v/min_v)*-1) 20 | 21 | 22 | 23 | 24 | sr, data = wavfile.read("guitar.wav") 25 | data = norm(data) 26 | 27 | 28 | 29 | #######echo FX############## 30 | def echo(signal, bpm, feedback,mix=1.0,cutoff =4000): 31 | #create filter 32 | w = cutoff/(44100/2) 33 | a,b = sig.butter(4, w, "low", analog=False) 34 | 35 | #calc time in samples 36 | x = round(1/bpm * 60 * 44100) 37 | d = x 38 | 39 | #allocate memory 40 | product = np.zeros_like(signal, dtype='float64') 41 | 42 | 43 | for i in range(feedback): 44 | #create empty array in length of delay time X feedback iteration 45 | shift = np.zeros(d) 46 | #concatenate to empty array 47 | delay = np.concatenate([shift, signal[:-d]*(1.0/(i+1))]) 48 | #increase shift size for next iteration 49 | d += x 50 | #mix product with filtered & delayed signal 51 | product += sig.filtfilt(a,b,delay) 52 | 53 | return norm(product)*mix 54 | 55 | 56 | 57 | #create 'wet' signal 58 | e= echo(data, 300 ,10 , 0.5, 3000) 59 | 60 | 61 | 62 | 63 | ##plot signals 64 | t = np.arange(0,1.0,1.0/len(data)) 65 | plt.plot(t, data) 66 | plt.plot(t, e) 67 | plt.show() 68 | 69 | 70 | 71 | ##mix dry & wet signals 72 | e = norm(e+data) 73 | 74 | 75 | 76 | ####WRITE AUDIO FILE#### 77 | e *= 32767 78 | e = np.int16(e) 79 | wavfile.write("file.wav", 44100, e) 80 | 81 | 82 | -------------------------------------------------------------------------------- /15_filter_sweep.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | from scipy.signal import butter,filtfilt 4 | from scipy import signal as sgl 5 | from scipy.io import wavfile 6 | 7 | def norm(data): 8 | min_v = min(data) 9 | max_v = max(data) 10 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 11 | 12 | def split_signal(signal, step, size): 13 | return [signal[i : i + size] for i in range(0, len(signal), step)] 14 | 15 | def heal(chunks, x_len): 16 | x = chunks[0] 17 | for i in range(0,len(chunks)-1): 18 | x= merge(x, chunks[i+1], x_len) 19 | return x 20 | 21 | def merge(a,b, overlap): 22 | return list(a[:-overlap]) + cross_fade(a[len(a)-overlap:], b[:overlap]) + list(b[overlap:] ) 23 | 24 | def cross_fade(a,b): 25 | lin = np.arange(0,1.0, 1/len(a)) 26 | return [((a[i]*lin[::-1][i]) + (b[i]*lin[i])) for i in range(len(a))] 27 | 28 | def filter_sweep(signal, hi_freq, order = 5, step=1000, upsweep=True): 29 | p = split_signal(signal, step, step*2) 30 | 31 | env = np.linspace(10,hi_freq, len(p)) 32 | 33 | x = [] 34 | 35 | for i in range(0, len(p)-1): 36 | cutoff = env[i] if upsweep else env[::-1][i] 37 | normal_cutoff = cutoff / (44100/2) 38 | b, a = butter(order, [normal_cutoff, normal_cutoff+0.2], btype="band", analog=False) 39 | x.append(filtfilt(b, a,p[i])) 40 | 41 | x = heal(x, step) 42 | return np.array(x) 43 | 44 | 45 | 46 | 47 | ##create signal 48 | sample_rate = 44100 49 | frequency = 60 50 | note_length = 5 51 | t = np.arange(0,1.0*note_length,1.0/sample_rate, dtype='float64') 52 | product = sgl.sawtooth(2 * np.pi * frequency * t) 53 | 54 | ##Filter the signal 55 | product = filter_sweep(product, 5000, upsweep=False) 56 | 57 | ##Normalize...... 58 | product = norm(product)[::-1] 59 | 60 | ##Plot 61 | plt.plot(t,product) 62 | plt.show() 63 | 64 | ##Write to file 65 | product *= 32767 66 | product = np.int16(product) 67 | wavfile.write("file.wav", 44100, product) 68 | -------------------------------------------------------------------------------- /XDSP.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy import signal 3 | from scipy.io import wavfile 4 | import matplotlib.pyplot as plt 5 | 6 | sample_rate = 44100 7 | 8 | def norm(data): 9 | min_v = min(data) 10 | max_v = max(data) 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 14 | return data * ((max_v/min_v)*-1) 15 | 16 | def BIG_small(s1,s2): 17 | return (s2,s1) if len(s1)sum(frag02) else 1 37 | 38 | def evolve(signal01, signal02, dna_code): 39 | new_gen = [] 40 | for i in range(len(dna_code)): 41 | if dna_code[i] == 0: 42 | new_gen.append(signal01[i]) 43 | else: 44 | new_gen.append(signal02[i]) 45 | 46 | return new_gen 47 | 48 | def fix(l): 49 | new_lst = [] 50 | for i in range(len(l)): 51 | for j in range(len(l[i])): 52 | new_lst.append(l[i][j]) 53 | return np.array(new_lst) 54 | 55 | def write_file(y): 56 | y *= 32767 57 | y = np.int16(y) 58 | wavfile.write("file.wav", 44100, y) 59 | 60 | 61 | _, signal01 = wavfile.read("count.wav") 62 | _, signal02 = wavfile.read("sample.wav") 63 | 64 | signal01 = signal01 65 | signal02 = signal02 66 | 67 | os = BIG_small(signal01, signal02) 68 | 69 | s1 = resample(os[1],len(os[0])) 70 | s2 = os[0] 71 | 72 | b1 = break_signal(s1, 6) 73 | b2 = break_signal(s2, 6) 74 | dna = compare_clips(b1,b2,max_sum) 75 | 76 | child = norm(fix(evolve(b1, b2, dna))) 77 | 78 | write_file(child) -------------------------------------------------------------------------------- /wav_analyzer/create_wav.py: -------------------------------------------------------------------------------- 1 | from datetime import datetime 2 | import random 3 | import numpy as np 4 | import matplotlib.pyplot as plt 5 | from scipy.io import wavfile 6 | 7 | class wave_maker: 8 | 9 | def __init__(self, length=1.0 , sampleRate=44100): 10 | self.length = length 11 | self.sr = sampleRate 12 | 13 | def _norm(self, data): 14 | min_v = min(data) 15 | max_v = max(data) 16 | 17 | offset = min_v+max_v 18 | data = data+(offset/2) 19 | 20 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 21 | 22 | return data * ((max_v/min_v)*-1) 23 | 24 | 25 | def _wav_fragmentation(self, signal): 26 | num_of_breaks = random.randint(1,100) 27 | list_of_breaks = [] 28 | 29 | step_size = self.sr//num_of_breaks 30 | counter = 0 31 | 32 | for i in range(num_of_breaks): 33 | list_of_breaks.append((random.randint(1+counter ,counter+step_size), 34 | random.randint(1+counter+step_size ,(step_size*2)+counter))) 35 | counter += step_size 36 | new_buffer = np.zeros_like(signal) 37 | 38 | for i in range(len(list_of_breaks)): 39 | signal[list_of_breaks[i][0]:list_of_breaks[i][1]] = 0 40 | 41 | return signal 42 | 43 | def make_signal(self): 44 | t = np.arange(0,self.length,1/self.sr) 45 | sig01 = np.sin(2 * np.pi * random.randint(20, 20000) * t) 46 | sig02 = np.sin(2 * np.pi * random.randint(20, 20000) * t) 47 | sig03 = np.sin(2 * np.pi * random.randint(20, 20000) * t) 48 | noise = 0.2 * np.random.randn(*sig01.shape) 49 | 50 | complex_wav = sig01+sig02+sig03+noise 51 | return self._norm(self._wav_fragmentation(complex_wav)) 52 | 53 | 54 | def make_wav_file(self, signal): 55 | new = [x*32767 for x in signal] 56 | new = np.int16(new) 57 | wavfile.write(f"file.wav", self.sr, new) 58 | return signal 59 | 60 | if __name__ == "__main__": 61 | w = wave_maker() 62 | w.make_wav_file(w.make_signal()) 63 | 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /wav_analyzer/wav_analyzer.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from create_wav import wave_maker 5 | 6 | class analysys: 7 | def __init__(self, signal, locations, sr=44100): 8 | self.locations = locations 9 | self.numofkrechtz = len(locations) 10 | self.signal = signal 11 | self.sr = sr 12 | 13 | def __repr__(self): 14 | return f"Krechtz count in signal: {self.numofkrechtz}\n Krechtz index: {self.locations}" 15 | 16 | def show(self): 17 | plt.plot(np.arange(0,self.sr*(len(self.signal)/self.sr),1) , self.signal) 18 | locs = [item for t in self.locations for item in t] 19 | for i in range(len(locs)): 20 | if i%2 == 0: 21 | plt.axvspan(locs[i], locs[i+1], facecolor='0.05', alpha=0.5) 22 | plt.axvline(x=locs[i], color ="red") 23 | 24 | plt.show() 25 | 26 | 27 | 28 | class wave_analyzer: 29 | def __init__(self, signal): 30 | self.signal = signal 31 | 32 | def _burst(self, index): 33 | counter = 0 34 | for i in range(index,len(self.signal)): 35 | if self.signal[i] == self.signal[index]: 36 | counter +=1 37 | else: 38 | break 39 | return counter 40 | 41 | def analyze(self, min_burst_length = 0): 42 | counter = 0 43 | bursts_indexes = [] 44 | 45 | while counter 1: 51 | counter += burst_size 52 | 53 | else: 54 | counter+=1 55 | 56 | return analysys(self.signal, bursts_indexes) 57 | 58 | 59 | 60 | 61 | if __name__ == "__main__": 62 | 63 | wm = wave_maker() 64 | sig = wm.make_signal() 65 | 66 | a = wave_analyzer(sig).analyze() 67 | 68 | print(a) 69 | 70 | a.show() 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | -------------------------------------------------------------------------------- /renderer/introText: -------------------------------------------------------------------------------- 1 | hello everyone, this is the second video I am making on this topic, ill put a link for the first 2 | one in the comments. 3 | so this time we will continue our journey of learning to use python for creative audio processing. 4 | the topics I will be covering today are: 5 | - Complex Waveforms (Basically mixing 2 or more signals) 6 | - Binaural beats (we will write a powerful short script capable of generating binaural beats style audio files, based on our choice of fundamental freq + desired brain wave pattern. 7 | - We will see that mixing signals can result in combined amplitude output levels, which if left unattended will result in digital distortion. I will show you how to work around this problem by 8 | setting different amplitudes to each component signal, allowing their amplitude sum to stay within a range of -1 and 1 values. 9 | - we will see also how to normalize our signals for an easier approach to this problem. 10 | - after this, we will see a simple cluster generator - this is a very nice concept of potting hundreds or more detuned signals and playing with the result. 11 | - this will be a good place to mention FastFouriTransform and implement a simple FFT analyzer. 12 | - next, I will go on with a general idea of tone perception, and how harmonically aligned components result in a perceived "oneness" and each component is perceived as a "overtone" of a fondemental freq, vs the perception of a fragmented set of intervals, when generating a non-harminic set of components. 13 | - after this we will write a script capable of generating "string-like" tones, using a simple harmonic series of frequencies, and setting their amplitude with a couple of slop functions. this will give us a very powerful synthesizer, which we will refactor again to create a Wavetable synthesizer. 14 | - and last will be a nice concept I'm working on; the abstract is to analyze an audio sample with FFT, get a list of components, and regenerate them using our wavetable synthesizer. this will be an experimental tool that I'm sure you will love to try out and use. 15 | so before we start I want to encourage you to pull this git repo from my Github so you will have all the code I will be writing. 16 | and for everyone who enjoys this topic and my videos, please consider giving this video a like & subscribing to my channel. 17 | 18 | 19 | -------------------------------------------------------------------------------- /09b_FM_synthesis.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | import sounddevice 5 | 6 | 7 | 8 | #operator class 9 | class Op(): 10 | 11 | op_counter = 0 12 | 13 | def __init__(self, freq, gain=1.0, feed=0.0): 14 | self.freq = freq 15 | self.gain = gain 16 | self.feed = feed 17 | self.name = f"mod_{Op.op_counter}" 18 | Op.op_counter += 1 19 | 20 | def __repr__(self): 21 | return f"name: {self.name} \ 22 | freq:{self.freq} gain:{self.gain} \ 23 | feed:{self.feed}" 24 | 25 | 26 | 27 | #synth class 28 | class FM_Synth(): 29 | 30 | def __init__(self, f=440, length=1): 31 | self.sr = 44100.0 32 | self.length = length 33 | self.time = np.arange(0,1.0,1.0/(self.sr*self.length)) 34 | self.ops = [] 35 | self.output = Op(freq=f) 36 | self.signal = None 37 | 38 | def norm(self, data): 39 | min_v = min(data) 40 | max_v = max(data) 41 | return np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 42 | 43 | def create_op(self, freq, gain=1.0, feed=0.0): 44 | self.ops.append(Op(freq, gain, feed)) 45 | 46 | def build(self): 47 | mix = np.zeros(int(self.length * self.sr)) 48 | 49 | for i in self.ops: 50 | #print(f"{i.freq}") 51 | s = np.sin(2.0 * np.pi * i.freq * (i.feed*i.freq) * self.time) * i.gain 52 | mix+=s 53 | 54 | product = np.zeros_like(mix) 55 | 56 | for i, t in enumerate(self.time): 57 | product[i] = np.sin(2. * np.pi * (self.output.freq * t + mix[i])) 58 | 59 | y = self.norm(product) 60 | self.signal= y 61 | 62 | def clear(self): 63 | self.ops = [] 64 | self.signal = None 65 | 66 | def plot(self): 67 | plt.plot(self.time, self.signal) 68 | plt.show() 69 | 70 | def play(self): 71 | sounddevice.play(self.signal, self.sr) 72 | 73 | def save_file(self): 74 | s = [i for i in self.signal] 75 | 76 | s *= 32767 77 | s = np.int16(s) 78 | wavfile.write("output.wav", int(self.sr), s) 79 | 80 | def __repr__(self): 81 | return str([i for i in self.ops]) 82 | 83 | 84 | 85 | #Drive Synth 86 | if __name__ == "__main__": 87 | from random import randint as rnd 88 | import time 89 | 90 | note_length = 2 91 | 92 | synth = FM_Synth(f=100, length=note_length) 93 | 94 | while True: 95 | for i in range(rnd(0,5)): 96 | synth.create_op(freq = rnd(40,4000), gain=1.0/rnd(2,9), feed=1.0/rnd(1,3)) 97 | 98 | synth.build() 99 | synth.play() 100 | synth.clear() 101 | time.sleep(note_length) 102 | 103 | 104 | ## synth.plot() 105 | ## synth.save_file() 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | -------------------------------------------------------------------------------- /AmenSynth/amen_synth.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import sounddevice as sd 3 | from scipy import signal as sgl 4 | from scipy.io import wavfile 5 | from itertools import cycle 6 | 7 | class waveform: 8 | def __init__(self, signal, start, length): 9 | self.set(signal, start, length) 10 | def set(self, signal, start, length): 11 | self.s = cycle(signal[start:start+length]) 12 | def get_next(self, buff_size): 13 | return np.array([next(self.s) for x in range(buff_size)]) 14 | 15 | def norm(data, simple=False): 16 | min_v = min(data) 17 | max_v = max(data) 18 | if simple is False: 19 | offset = min_v+max_v 20 | data = data+(offset/2) 21 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 22 | return data * ((max_v/min_v)*-1) 23 | else: 24 | return np.array([((x-min_v) / (max_v-min_v)) for x in data]) 25 | 26 | samplerate, signal = wavfile.read("Amen_Break_CD.wav") 27 | signal = np.array([x[0] for x in signal]) 28 | cutoff =6200 29 | w = cutoff/(44100/2) 30 | 31 | a,b = sgl.butter(4, w, 'low', analog=True) 32 | z = sgl.filtfilt(a,b,signal) 33 | 34 | resampled = sgl.resample(z, int(len(signal)*1.5)) 35 | 36 | tone = waveform(resampled, 0, len(resampled)) 37 | 38 | def change(e, length): 39 | global tone 40 | tone = waveform(resampled, e, length) 41 | 42 | def play_thread(tone): 43 | start_idx = 0 44 | 45 | try: 46 | samplerate = 44100 47 | 48 | def callback(outdata, frames, time, status): 49 | nonlocal start_idx 50 | global tone 51 | outdata[:] = tone.get_next(len(outdata)).reshape(len(outdata),1) 52 | start_idx += frames 53 | 54 | with sd.OutputStream(channels=1, callback=callback,samplerate=samplerate): 55 | print('*****press Return to quit*****') 56 | input() 57 | 58 | except KeyboardInterrupt: 59 | pass 60 | except Exception as e: 61 | parser.exit(type(e).__name__ + ': ' + str(e)) 62 | 63 | 64 | import threading 65 | 66 | t = threading.Thread(target=play_thread, args=(tone,)) 67 | t.start() 68 | 69 | 70 | import tkinter as tk 71 | 72 | #create window & frames 73 | class App: 74 | def __init__(self): 75 | self.root = tk.Tk() 76 | self._job = None 77 | 78 | w = tk.Label(self.root, text="Start") 79 | w.pack() 80 | 81 | self.slider = tk.Scale(self.root, from_=5, to=200000, 82 | orient="horizontal", 83 | command=self.updateValue) 84 | self.slider.pack() 85 | 86 | w2 = tk.Label(self.root, text="Length") 87 | w2.pack() 88 | 89 | self.slider2 = tk.Scale(self.root, from_=5, to=30000, 90 | orient="horizontal", 91 | command=self.updateValue) 92 | self.slider2.pack() 93 | 94 | 95 | self.root.mainloop() 96 | 97 | def updateValue(self, event): 98 | if self._job: 99 | self.root.after_cancel(self._job) 100 | self._job = self.root.after(500, self._do_something) 101 | 102 | def _do_something(self): 103 | self._job = None 104 | change(self.slider.get(), self.slider2.get()) 105 | 106 | 107 | 108 | 109 | app=App() 110 | -------------------------------------------------------------------------------- /18_noise_gate.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy.signal import butter,filtfilt 5 | 6 | #normalize function 7 | def norm(data, simple=False): 8 | min_v = min(data) 9 | max_v = max(data) 10 | if simple is False: 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 14 | return data * ((max_v/min_v)*-1) 15 | else: 16 | return np.array([((x-min_v) / (max_v-min_v)) for x in data]) 17 | 18 | def flat_edge(arr,keyframes, intro=True): 19 | if intro: 20 | a = keyframes[0] 21 | b = int(keyframes[1]//2) 22 | else: 23 | a = int(keyframes[-2]+((len(arr) - keyframes[-2]) // 2)) 24 | b = keyframes[-1] 25 | 26 | for i in range(a,b): 27 | arr[i] = 0 28 | return arr 29 | 30 | def gates(signal, segments, speed=50): 31 | ones = np.ones_like(signal) 32 | for s in segments: 33 | ones[s[0]:s[1]] = norm(np.cosh(np.linspace(-speed,speed,s[1]-s[0])), True) 34 | return ones 35 | 36 | def segments(keyframes, First=True): 37 | return [(keyframes[i],keyframes[i+1]) for i in range(int(not First),len(keyframes)-1,2)] 38 | 39 | def threshold_keyframes(rms, threshold): 40 | keyframes = [0] 41 | lastkeyframewasUp = False 42 | 43 | for i in range(len(rms)): 44 | if rms[i] < threshold: 45 | if lastkeyframewasUp == True: 46 | keyframes.append(i) 47 | lastkeyframewasUp = False 48 | else: 49 | if lastkeyframewasUp == False: 50 | keyframes.append(i) 51 | lastkeyframewasUp = True 52 | 53 | keyframes.append(len(signal)) 54 | 55 | if keyframes[1] == 0: 56 | del keyframes[0] 57 | return keyframes 58 | 59 | 60 | 61 | 62 | 63 | 64 | #read file 65 | samplerate, signal = wavfile.read("beat.wav") 66 | signal = norm(np.array(signal,dtype=np.float64)) 67 | 68 | ########-RMS-######### 69 | rms = np.zeros_like(signal) 70 | buffer_size = 1000 71 | 72 | for i in range(0,len(signal),buffer_size): 73 | s = signal[i:i+buffer_size] 74 | rms[i:i+buffer_size] = np.sqrt(np.mean(s**2)) 75 | 76 | #smooth... 77 | cutoff = 20 78 | normal_cutoff = cutoff / (44100/2) 79 | b, a = butter(2, normal_cutoff, btype="low", analog=False) 80 | rms = filtfilt(b, a,rms) 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | # calculate gate 89 | threshold = 0.18 90 | flip_order = False 91 | 92 | keyframes = threshold_keyframes(rms, threshold) 93 | g = gates(signal, segments(keyframes, flip_order), 50) 94 | 95 | ### flate edges ##### 96 | ##g = flat_edge(g, keyframes, True) 97 | ##g = flat_edge(g, keyframes, False) 98 | 99 | 100 | ## gate signal 101 | gated = signal*g 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | ######## Draw ########## 112 | plt.plot(range(len(signal)), signal, "black") 113 | plt.plot(range(len(signal)), gated, "pink") 114 | 115 | plt.plot(range(len(signal)), g, "yellow") 116 | plt.plot(range(len(signal)), rms, "red") 117 | 118 | plt.axhline(y=threshold, color ="green") 119 | 120 | plt.show() 121 | 122 | 123 | 124 | 125 | #write to file 126 | gated *= 32767 127 | gated = np.int16(gated) 128 | wavfile.write("file.wav", 44100, gated) 129 | 130 | 131 | -------------------------------------------------------------------------------- /AGC_compressor.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy.signal import butter,filtfilt 5 | 6 | #normalize function 7 | def norm(data, simple=False): 8 | min_v = min(data) 9 | max_v = max(data) 10 | if simple is False: 11 | offset = min_v+max_v 12 | data = data+(offset/2) 13 | data = np.array([((x-min_v) / (max_v-min_v)) for x in data])*2.0-1 14 | return data * ((max_v/min_v)*-1) 15 | else: 16 | return np.array([((x-min_v) / (max_v-min_v)) for x in data]) 17 | 18 | def segments(keyframes, First=True): 19 | if First == True: 20 | return [(keyframes[i],keyframes[i+1]) for i in range(0,len(keyframes)-1,2)] 21 | else: 22 | return [(keyframes[i],keyframes[i+1]) for i in range(1,len(keyframes)-1,2)] 23 | 24 | def calculate_dynamics(rms, threshold): 25 | keyframes = [0] 26 | lastkeyframewasUp = False 27 | 28 | for i in range(len(rms)): 29 | if rms[i] < threshold: 30 | if lastkeyframewasUp == True: 31 | keyframes.append(i) 32 | lastkeyframewasUp = False 33 | else: 34 | if lastkeyframewasUp == False: 35 | keyframes.append(i) 36 | lastkeyframewasUp = True 37 | 38 | keyframes.append(len(signal)) 39 | return keyframes 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | #read file 48 | samplerate, signal = wavfile.read("beat.wav") 49 | signal = norm(np.array(signal,dtype=np.float64)) 50 | 51 | ########-RMS-######### 52 | rms = np.zeros_like(signal) 53 | buffer_size = 1000 54 | 55 | for i in range(0,len(signal),buffer_size): 56 | s = signal[i:i+buffer_size] 57 | rms[i:i+buffer_size] = np.sqrt(np.mean(s**2)) 58 | 59 | #smooth... 60 | cutoff = 20 61 | normal_cutoff = cutoff / (44100/2) 62 | b, a = butter(2, normal_cutoff, btype="low", analog=False) 63 | rms = filtfilt(b, a,rms) 64 | 65 | #calculate_dynamics 66 | threshold = 0.05 67 | keyframes = calculate_dynamics(rms, threshold) 68 | 69 | 70 | #commpression power 71 | ratio = 1.2 72 | bias = -0.2 73 | speed = 80 74 | makeup_gain =1 75 | 76 | min_rms = min(rms) 77 | 78 | c = np.zeros_like(rms) 79 | gr = np.zeros_like(rms) 80 | 81 | compression = (-rms*ratio)+(1-(min_rms+threshold)) 82 | 83 | for segment in segments(keyframes, False): 84 | gr[segment[0]:segment[1]] = ((rms[segment[0]:segment[1]]-bias)*(-1*norm(np.cosh(np.linspace(-speed,speed,segment[1]-segment[0])), True)+1)) 85 | for i in range(segment[0],segment[1],buffer_size): 86 | s = gr[i:i+buffer_size]*-1+1 87 | c[i:i+buffer_size] = signal[i:i+buffer_size] * s 88 | 89 | for segment in segments(keyframes): 90 | for i in range(segment[0],segment[1],buffer_size): 91 | c[i:i+buffer_size] = signal[i:i+buffer_size] 92 | 93 | c = norm(c)*makeup_gain 94 | 95 | 96 | 97 | 98 | 99 | #draw 100 | plt.plot(range(len(signal)), signal, "black") 101 | 102 | plt.plot(range(len(signal)), c, "pink") 103 | plt.plot(range(len(compression)), compression*-1+1-threshold, "red", dashes=[6, 2]) 104 | plt.plot(range(len(signal)), gr*-1+1, "blue") 105 | plt.axhline(y=threshold, color ="green") 106 | 107 | for i in range(len(keyframes)): 108 | plt.axvline(x=keyframes[i], color ="yellow") 109 | 110 | for v in segments(keyframes): 111 | plt.axvspan(v[0],v[1], facecolor='0.2', alpha=0.5) 112 | 113 | for v in segments(keyframes, False): 114 | plt.axvspan(v[0],v[1], facecolor='0.5', alpha=0.2) 115 | 116 | 117 | plt.show() 118 | 119 | 120 | 121 | #write file 122 | c *= 32767 123 | c = np.int16(c) 124 | wavfile.write("file.wav", 44100, c) 125 | 126 | -------------------------------------------------------------------------------- /renderer/physical_renderer.py: -------------------------------------------------------------------------------- 1 | import scipy.io.wavfile as wavfile 2 | import scipy 3 | import scipy.fftpack as fftpk 4 | from scipy import signal as sgl 5 | import numpy as np 6 | from wavetables import Wavtable 7 | 8 | class PhysicalSynth: 9 | def __init__(self): 10 | self.sample_rate = None 11 | self.file_name = "tone" 12 | self.length = 0 13 | self.raw_data = None 14 | self.signal = None 15 | self.lp_cutoff_freq = 700 16 | self.hp_cutoff_freq = 100 17 | self.FFT = None 18 | self.freqs = None 19 | self.peaks = None 20 | self.min_peak_heigth = 50 21 | self.freq_list = None 22 | self.slop_type = None 23 | self.wavtable = None 24 | self.generated_signal = None 25 | 26 | def _read_file(self): 27 | self.sample_rate, self.raw_data = wavfile.read(self.file_name) 28 | 29 | def _marge_to_mono(self): 30 | if(len(np.shape(self.raw_data))>1): 31 | self.raw_data = self.raw_data[:, 0] + self.raw_data[:, 1] 32 | 33 | def _norm(self, data): 34 | min_v = min(data) 35 | max_v = max(data) 36 | offset = min_v+max_v 37 | data = data+(offset/2) 38 | return np.array([((x-min_v) / (max_v-min_v)) for x in data], dtype='float')*2.0-1 39 | 40 | def _filter(self): 41 | w = self.lp_cutoff_freq/(self.sample_rate/2) 42 | a,b = sgl.butter(4, w, "low", analog=False) 43 | self.signal = sgl.filtfilt(a,b,self.signal) 44 | 45 | w = self.hp_cutoff_freq/(self.sample_rate/2) 46 | a,b = sgl.butter(4, w, "high", analog=False) 47 | self.signal = sgl.filtfilt(a,b,self.signal) 48 | 49 | def _do_fft(self): 50 | self.FFT = abs(scipy.fft.fft(self.signal)) 51 | self.freqs = fftpk.fftfreq(len(self.FFT), (1.0/self.sample_rate)) 52 | 53 | def _read_peaks(self): 54 | indices = sgl.find_peaks(self.FFT[range(len(self.FFT)//20)], height=self.min_peak_heigth, width=2)[0] 55 | peaks = [self.freqs[x] for x in indices] 56 | self.freq_list = [np.roll(i, int(i%180)) for i in peaks] 57 | 58 | def _generate_wavetable(self): 59 | self.wavtable = Wavtable(self.freq_list, self.length, self.slop_type, self.sample_rate) 60 | self.generated_signal = self._norm(self.wavtable.MakeSignal()) 61 | 62 | def _make_file(self): 63 | self.generated_signal *= 32767 64 | self.generated_signal = np.int16(self.generated_signal) 65 | print(f"rendering wav file..") 66 | wavfile.write(f"x_{self.file_name.split('/')[1]}", self.sample_rate, self.generated_signal) 67 | 68 | 69 | def Load(self): 70 | self._read_file() 71 | 72 | def Prepare(self): 73 | self._marge_to_mono() 74 | self.signal = self._norm(self.raw_data) 75 | 76 | def Analyze(self): 77 | self._filter() 78 | self._do_fft() 79 | self._read_peaks() 80 | 81 | def Set(self,fileName=None,length=None,slop_type=None,lp_cutoff_freq=None, 82 | hp_cutoff_freq=None,min_peak_heigth=None): 83 | if (fileName is not None): 84 | self.file_name=fileName 85 | if (length is not None): 86 | self.length=length 87 | if (slop_type is not None): 88 | self.slop_type=slop_type 89 | if (lp_cutoff_freq is not None): 90 | self.lp_cutoff_freq=lp_cutoff_freq 91 | if (hp_cutoff_freq is not None): 92 | self.hp_cutoff_freq=hp_cutoff_freq 93 | if (min_peak_heigth is not None): 94 | self.min_peak_heigth=min_peak_heigth 95 | 96 | def Synthesize(self, fn, fl = 1.0, st = "log"): 97 | self.Set(fileName=fn, length=fl, slop_type=st) 98 | self.Load() 99 | self.Prepare() 100 | self.Analyze() 101 | 102 | self._generate_wavetable() 103 | self._make_file() 104 | 105 | if __name__ == "__main__": 106 | p = PhysicalSynth() 107 | x = input('filename\n') 108 | p.Synthesize(fn=f"woodz/{x}.wav") 109 | 110 | 111 | 112 | 113 | 114 | -------------------------------------------------------------------------------- /16_sigmoid.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | from scipy.io import wavfile 4 | from scipy import signal as sgl 5 | from scipy.signal import savgol_filter 6 | plt.style.use('dark_background') 7 | 8 | #normalize function 0-1 9 | def norm(data): 10 | min_v = min(data) 11 | max_v = max(data) 12 | return np.array([((x-min_v) / (max_v-min_v)) for x in data]) 13 | 14 | ##a is the s location on the x axis, b is power of curve 15 | def sigmoid_a(length, a=1, b=1): 16 | t = np.arange(-1.0*(length/2),1.0*(length/2),1.0/sample_rate) 17 | sig = 1 / (a + np.exp(-t*b)) 18 | return sig 19 | 20 | #speed is length of linear function, direction[up, down, bi], length of signal 21 | def sigmoid_b(speed, direction, length): 22 | #create -1 to 1 vector t 23 | T = np.arange(-1.0,1.0,1.0/sample_rate) 24 | #create mid linear function (sustain) 25 | tq = np.arange(1,speed,1.0/sample_rate) 26 | 27 | x = np.zeros_like(T) 28 | 29 | #create sigmoid and normalize.. SAD! 30 | for i in range(len(T)): 31 | x[i] = T[i]/((T[i]**2)+1) 32 | 33 | x = norm(x) 34 | 35 | #concatenate functions 36 | if direction=='up': 37 | new_t = np.concatenate([x[:(len(x)//2)],tq-0.5]) 38 | elif direction=='down': 39 | new_t = np.concatenate([tq-0.5,x[(len(x)//2):]+speed-1]) 40 | elif direction=='bi': 41 | new_t = np.concatenate([x[:(len(x)//2)],tq-0.5,x[(len(x)//2):]+speed-1]) 42 | 43 | #normalize again and compress x to 1 (time shift) 44 | x = norm([new_t[i] for i in range(len(new_t)) if i%(len(new_t)/sample_rate)==0]) 45 | 46 | #rescale time to length 47 | out = [] 48 | for i in x: 49 | for j in range(length): 50 | out.append(i) 51 | 52 | #fix aliasing... SAD! :( 53 | for i in range(2): 54 | out = savgol_filter(out, 71, 3) 55 | 56 | return out 57 | 58 | #x is the value at z & zb intercept. b & a are shape. 59 | def sigmoid_c(length, x, b, a): 60 | 61 | #create X vector and allocate axis. 62 | t = np.arange(0,1.0*length,1/44100) 63 | z = np.zeros_like(t) 64 | zb = np.zeros_like(t) 65 | zc = np.zeros_like(t) 66 | 67 | #Create first exponential function 68 | Tangent_index = 0 69 | done = False 70 | for i in range(len(t)): 71 | z[i] = b*t[i]**2 72 | 73 | if t[i] >= x and done is False: 74 | Tangent_index = i 75 | done=True 76 | 77 | #calculate function derivative ( the sensitivity to change of the function value (output value) with respect to a change in its argument (input value)) 78 | #gradient and tangent point 79 | derivative = b*2 80 | gradient = derivative*x 81 | tangent = (x, b*x**2) 82 | 83 | #create linear function based on gradient and tan 84 | for i in range(len(t)): 85 | zb[i] = gradient*t[i] + (tangent[1] - (gradient*tangent[0])) 86 | 87 | last = -1000000 88 | 89 | #create logarithmic function with same gradiant as zb at (0,0) 90 | for i in range(len(t)): 91 | zc[i] = (a*t[i]**2) + (gradient*t[i]) + (tangent[1] - (gradient*tangent[0])) 92 | if zc[i] > last: 93 | last = zc[i] 94 | else: 95 | zc[i]=last 96 | 97 | #plot III functions 98 | ## plt.plot(t, z) 99 | ## plt.plot(t, zb) 100 | ## plt.plot(t, zc) 101 | ## plt.show() 102 | 103 | #concatenate functions to one vector 104 | delta = max(zb) + max(z[:Tangent_index]) 105 | f = norm(np.concatenate([z[:Tangent_index], zb[Tangent_index:], zc+delta])) 106 | return f 107 | 108 | 109 | 110 | ########## Be Quiet And Drive... ##################### 111 | ############################################# 112 | sample_rate = 44100 113 | frequency = 200 114 | length = 5 115 | 116 | s = sigmoid_a(10, 1, 2) 117 | ##s = sigmoid_b(10, 'bi',length) 118 | ##s = sigmoid_c(length,3,2,-10) 119 | 120 | 121 | ###Sin WAVE 122 | ##y = np.sin(2 * np.pi * frequency * s) 123 | 124 | ##LFO 125 | ##y = np.sin(2 * np.pi * frequency * y) 126 | 127 | 128 | ####WRITE AUDIO FILE#### 129 | ##y *= 32767 130 | ##y = np.int16(y) 131 | ##wavfile.write("Sigmoid_Env.wav", 44100, y) 132 | 133 | plt.plot(range(len(s)), s) 134 | plt.grid() 135 | plt.show() 136 | 137 | --------------------------------------------------------------------------------