Skip to content

Latest commit

 

History

History
760 lines (498 loc) · 35 KB

meeting-notes.md

File metadata and controls

760 lines (498 loc) · 35 KB

2024-01-12

Meeting

Fotis showed Cardinal’s version Surge XT’s effects, a collection of loopable audio forms captured from analog gear, and we discussed how to compile Faust effects to JSFX, including how to install Faust on Windows Subsystem for Linux.

Leandro shared their progress on the DIY EWI project: We connected the microphone module to the power coming from the Raspberry Pi Pico and we managed to see the generated waveforms in the oscilloscope.

2023-11-23

Meeting

Fotis showed us the latest synth plugin by Tukan and his use of parallel effects in REAPER 7.

Bo showed us an experiment with a cascade of FIR and IIR filters, and his attempt at a truly awful sounding plugin.

Kevin talked about his wish for a “replace razor selection with the contents of the clipboard” action.

Leandro announced that he’ll be attempting the Advent of Code this year.

Here’s the code that we wrote together to downsample:

@init

sample_counter = 0;

@sample

sample_counter == 0 ? downsample = spl0;

spl0 = downsample;

sample_counter += 1;
sample_counter == 6 ? sample_counter = 0;

2023-11-07

Meeting

Fotis showed us how to train a model for GuitarML.

Cwits talked about some challenges trying to display a waveform with Qt.

Leandro and our special guest David solved Project Euler problem 10 with C++.

Bo shared with us his JSFX that’s a limiter with dynamic lowpass filtering.

2023-10-25

Meeting

Cwits is working on a GUI with Qt for his music project that uses a small touch-sensitive screen.

Fotis showed us an old DIY analog switcher and played with scripts that create samples from synthesizers.

V talked about how to implement convolution in JSFX and AI in the context of music production.

2023-10-11

Meeting

Fotis showed us no-input mixing and REAPER’s Container FX that coming in REAPER 7.

Cwits showed us an application he’s developing for Android that will find good ways to pack boxes.

Bo showed us a distortion JSFX he’s developing.

Leandro reported on the current state of the EWI: it’s sending MIDI notes and it has a button, but it’s running into issues with bouncing. He also shared his AI to detect screenshots of code that has been trained with https://teachablemachine.withgoogle.com/

2023-09-27

Meeting

Aline is a special guest. She’s a friend of Leandro’s from college.

Leandro introduced how to program a Raspberry Pi Pico with CircuitPython, which will be part of the EWI project pitched last meeting.

Bo showed the code for a JSFX which splits the signal between low and high frequencies and distorts the low frequencies.

Fotis is developing a user interface in HISE, and also showed a sequencer that runs in the browser and works by drawing shapes. Finally, he showed as a vocoder effect done in TurboSynth, from back in the 90s(!)

2023-09-05

Meeting

Fotis tried to get HISE’s new feature of time stretching to work, both from the GUI as well as from a script, but it didn’t work. Yet.

Cwits showed us some file editing features in his project: cutting and pasting sections of audio, reversing audio, and so forth.

Bo showed us some JSFX with a really clever idea for distortion in which the coefficient of a low-pass filter is modulated with the incoming signal.

Leandro pitched an idea of a EWI with a Raspberry Pi Pico, showed a Hammerspoon script that disables a MacBook keyboard for cleaning, and worked on Project Euler’s problem 9.

2023-08-24

Meeting

Fotis showed some updates to HISE, wrote some JSFX for sliders, and brought The Signal State for us to play together.

Cwits is dealing with weird edge cases in MIDI files.

Leandro coded Project Euler problem 8. We learned to use vectors and that we need to be mindful of int overflows.

2023-08-10

Meeting

Cwits got all parts working and is able to record and playback audio 🙌

Leandro solved Project Euler problem 7 and showed that brute force goes a long way.

Fotis showed a sketch of the user interface for his new not-Juno synthesizer, and showed a bunch of other interesting things. His homework is to come up with sliders for a time vs musical divisions modification he wants to do to a JSFX.

Bo talked about his Revolver compressor, an RMS-based compressor with novel transfer curves. He also showed his implementation a really nerdy way of going about BPMs.

2023-06-28

Meeting

Cwits received some more components but is now having problems with the power supply.

Leandro solved Project Euler problem 6 in C++ and compared it to the ChatGPT solution. We also discussed best practices around numeric types in C++.

Fotis finished simplifying sai'ke’s Filther to make it use less CPU.

2023-06-14

Meeting

Bo brought us an RBJ all-pass for us to implement, which is part of a widener he’s working on. He also showed us a work-in-progress of a bus summing effect based on wave-shaping and a first-order low-pass filter.

Cwits developed an user interface for a DAW running in the Ableton Push.

Leandro solved Project Euler problem 5 in C++ and compared it to the ChatGPT solution.

2023-05-31

Meeting

Cwits got some new components to replace those that had been burned, but something is still wrong: for the time being the output is just white noise. Unfortunately right now he doesn’t have access to the test equipment he needs: an oscilloscope and a good multimeter.

Fotis released a synth: Wild 👏 He also showed some new plugins by Tale. And then together we adapted a fancy JSFX plugin to have a lightweight user interface.

Leandro live-coded the solution to Project Euler problem 4, and we compared to the solutions given by ChatGPT.

2023-05-18

Meeting

Bo is learning about C# & Python for his day job.

Cwits had an issue with burning an expensive microcontroller, but bounced back and soldered a prototype together with a power supply for the Raspberry Pi and other components, and is now figuring out some quirks with the mute pins on some ICs on the damaged Audient audio interface he’s using for parts.

Fotis live-coded in JSFX an adaptation of an Airwindows effect to use a different type of distortion.

2023-04-20

Meeting

Cwits has refactored his code so that it isn’t so deeply nested.

Fotis showed the following projects:

Bo is considering JUCE again, given that iPlug2 didn’t work for him.

Leandro wrote a brute-force solution to Project Euler problem 3.

2023-03-29

Meeting

Cwits got the microcontrollers he needed and refactored some of his code, but is now taking a bit of a break and considering how to get excited about the project again.

Fotis talked about Rhapsody (a sampler) and Libre Wave (a collection of virtual instruments).

Bo talked about an idea for an octaver that he’s developing with the help of ChatGPT. We developed a concept in JSFX together.

Leandro solved a few Project Euler problems in C++.

2023-03-15

Meeting

Leandro is thinking of doing some Project Euler exercises in C++: https://projecteuler.net/

Bo worked on his compressor, widener, and novel equalizers.

Fotis compiled his Wild instrument, and we wrote some JSFX for slew rates together.

2023-02-22

Meeting

Cwits is pondering whether to do a user interface in Qt in a monolithic way, or separate the backend from the frontend.

Fotis created a synthesizer with HISE that is reminiscent of a Game Boy.

Bo created a stereo widener and showed us how it works in a goniometer.

Leandro watched some videos by The Cherno and read “YIN, a fundamental frequency estimator for speech and music”.

2023-02-08

Meeting

  • Fotis worked on some scripts for using ffmpeg from REAPER to manage dialog normalization in AC3 files.

  • Cwits is waiting for a microcontroller to manage the clock on his project (the first one burned 😬) and playing with Qt for the user interface on a display separate from the Ableton Push display.

2023-01-25

Meeting

Bo is working on his compressor, split distortion, and playing with ChatGPT.

Fotis tweaked a script to explode media streams.

Leandro setup Visual Studio Code for C++ and played around with a library to do HTTP servers in C++.

2022-12-07

Meeting

Bo showed us two of his JSFX projects: An extreme clipper to win the loudness war, and a compressor. We talked about look-up tables and fixed an issue that was causing differences between the left and right channels.

Leandro is getting his feet wet in iPlug. In particular, he’s interested in using a web view to do the user interface of a plugin in HTML/CSS/JavaScript.

Fotis showed a couple effects using FAUST in HISE. And his New Year’s resolution is to migrate a bunch of synthesizers from FlowStone to C++.

We’ll be back 2023-01-04.

2022-11-23

Meeting

Leandro learned more about the noise issues in his oscilloscope. He also learned a thing or two about the anti-aliasing filters in the digital-to-analog converters of his iPad & Thinkpad.

Fotis learned that his HISE plugin was actually working to begin with. And he dove deeper into FAUST.

And here’s the link of Fotis collaborating with Ian Shepherd: https://www.youtube.com/watch?v=n1Yfl6KGRk8

Cwits is pondering what to work on next.

Bo worked on his compressor & some waveshaping distortions.

2022-11-09

Meeting

Leandro opened Xcode and closed it back down 🤷

Fotis looked into HISE & Faust integration.

Bo did some distortion & filters in JSFX.

Cwits did some light effects in Ableton Push and showed us Ableton’s MIDI documentation.

2022-10-26

Meeting

Fotis wrote some code in HISE to do a XY pad.

Leandro is still procrastinating 😅

Cwits worked on fade-in/fade-out curves, routing between samplers, and ran into an issue with playback rates below 1.

2022-10-12

Meeting

Fotis talked about doing a hybrid synth (sample + synth) in HISE.

Leandro found that 1x probes don’t help with noise all that much. And he fixed his microwave oven with his newly acquired knowledge in electronics.

Cwits mentioned that using the microcontroller like discussed last meeting didn’t work. He’s now waiting for parts for an ADC.

Bo wrote a exponential-moving-average filter in JSFX using functions.

2022-09-28

Meeting

Leandro: Still working on the Automixer in JSFX. Learning about electronics with a new oscilloscope. Wondering what amount of noise one is supposed to expect from an oscilloscope, and if 1x probes may help…

Bo: Still running into issues trying to build plugins with iPlug.

Fotis: Developed a Rompler with controls for attack, release, reverb, and so forth.

Cwits: Refactored the code to represent menus with data structures instead of blocks of code. Started experimenting with a microcontroller attached to the Raspberry Pi.

2022-09-14

Meeting

Cwits: Implement ways to manipulate samples, for example, trimming the edges.

Fotis: Developed an user interface for a sampler using HISE. Ran into an issue with the onscreen keyboard, which we fixed by removing the onscreen keyboard 🙃

Leandro: Did a reverse-avalanche oscillator in a toy for his son.

  • https://www.youtube.com/watch?v=WjrJeUBjw5g&lc=Ugwfq6USi3crwV5tI5t4AaABAg (see Leandro’s comment for some more technical details):

    I just spent a couple hours playing around with this circuit. Here’s what I learned:

    1. The trick that made it work for me was to shine a bright light close to the LDR. Like Sam did in the video, I used my phone light.

    2. If you just want to play around with the circuit, you can use a breadboard.

    3. I tried a couple transistors with the middle leg still on, even with the middle leg connected to the breadboard. It worked 🤷

    4. The type of LDR will change the range. I found that the GL5539 worked the best from me, after having tried the GL5506, GL5516, GL5528, GL5537, and the GL5549. But they all worked to some extent.

    5. Different kinds of transistors gave me different frequencies. With the 2N3904 I could only produce annoyingly high-pitched sounds, no matter how big the capacitor. With the BC547 I got sounds similar to Sam’s. The BC337 also worked, though less pleasing. And the BC517 was my favorite. Fun stuff. I didn’t even need the phone light for the oscillation to start with all of these, except for the 2N3904. If playing around with different transistors remember to swap the legs around, because the pinouts are different.

    6. It won’t take just a couple of minutes to put together 😉

    Overall, really enjoyable experiment. Thanks, Sam!

  • https://www.youtube.com/watch?v=zCTLeNxge54

  • https://www.youtube.com/c/airwindows/search?query=diy

  • https://twitter.com/matttytel/status/1483878590089506828

2022-08-31

Meeting

Cwits: Implemented a step sequencer and is considering turning the project into a product.

Fotis: Using the development version of HISE to build an interface. Finishing his first commercial sample pack.

Bo: Implemented a new concept for a filter with a combination of averaging. Running into issue with the build system perhaps caused by having updated Visual Studio.

Leandro: Working on Automixer for Video, which is JSFX-only. Learning about simple circuits such as the Atari Punk Console & an analog VU meter.

2022-08-17

Meeting

Leandro is still working on the JSFX Automixer & learning about electronics.

Bo got the iPlug installation issues sorted out and we coded a first-order filter together.

Fotis got HISE compiled.

Cwits fixed the timing issues in the metronome.

2022-08-03

Meeting

Leandro is prototyping the Automixer in JSFX and learning about electronics. Shout out to:

Cwits has fixed his MIDI-recording timing issues by putting MIDI processing in the same loop as audio processing.

Fotis translated an Airwindows plugin to JSFX with the help of Mark Heath’s tutorial.

Bo installed iPlug2 and built an example plugin.

2022-07-20

Meeting

Cwits talked about adding audio inputs to his Raspberry Pi project by getting an Analog-to-Digital Converter (ADC). We also discussed the issues he’s been having with timing events.

Fotis talked about a C++ book he’s reading: Absolute C++, by Walter Savitch. We also discussed some issue he had trying to compile a JUCE port of an Airwindows plugin.

Leandro talked about communication between plugin instances using global variables, which is necessary for the Automixer. We also looked at Room EQ Wizard to measure & analyze electronics circuits.

2022-07-07

Meeting

Leandro talked about his first experiences with electronics: from basic components and what they do up to an overdrive pedal. Shout out to https://www.youtube.com/user/aritosuzuki !

Alessandro is working on software for transcribing music. In particular, he’s implementing an algorithm to slow playback and help you transcribe fast parts. See more at https://github.com/Thronplunder/transcriber.

Fotis talked about spatial audio and showed us his drums plugin from the past.

2022-06-22

Meeting

  • Fotis had a plugin working iPlug2. We discussed the tradeoffs when compared to JUCE, looked at the boilerplate generated by iPlug2, and talked about lambdas.
  • Leandro finished reading A Tour of C++. Next he’ll use this knowledge to create a side-channel to communicate streams of audio between instances of his Automixer.
  • Bo made his plugin stereo & created sliders. He’ll now attach these sliders to the member variables in the audio processor.
  • Cwits made the sequencer work and trigger samples. He also showed us how he uses lambdas as callbacks for loading files without interrupting audio playback.
void Fudge____AudioEditor::sliderValueChanged(juce::Slider* slider) override
{
  if (slider == &slider1)
    fudge____AudioProcessor.weight = slider1.getValue();
  else if (slider == &slider2)
    fudge____AudioProcessor.fudge = slider2.getValue();
}

2022-06-08

Meeting

2022-05-11

Meeting

  • Cwits: Implemented the timing of MIDI events using a combination of precise sleep with nanosleep() & a bit of busy wait. For next meeting will try to fix a crash that’s probably caused by a race condition.
  • Fotis: https://github.com/DISTRHO/Cardinal & https://aria.dog/barks/why-i-will-never-create-modules-for-vcv-rack-anymore/. For next meeting will study about sound engines combining sampling & synthesis.
  • Leandro: Reading A Tour of C++, by Bjarne Stroustrup. Recommended for experienced programmers with a foot in programming-language theory who want to get up to speed in C++ relatively fast. For next meeting will finish reading the book and start applying the knowledge to the Automixer.
  • Bo: Following along The Audio Programmer’s JUCE tutorials. Got stuck because of a couple syntax issues & a misnamed class, but back on track now. We talked about classes, inheritance, and namespaces. For next meeting will continue with the tutorials.

2022-05-11

Meeting

2022-04-26

Meeting

2022-04-13

Meeting

2022-03-29

Meeting

  • Unusual meeting because some people were busy and we wanted to catch https://www.youtube.com/watch?v=gnbSMmTiDxk
  • Leandro’s progress:
    • Ergonomics: Having to close and reopen REAPER to load a new version of a VST.
      • Tale told me a probable reason for this: REAPER keeps the VST loaded in memory; on Windows one isn’t even able to overwrite the VST file while a DAW has it open.
      • Tried to get the plugin to load in Live, just to check. But Live doesn’t pick it up. Probably because Xcode puts it under ~/Library/Audio/Plug-ins/, instead of /Library/Audio/Plug-ins/ 🤷
    • Plugin still crashes REAPER from time to time.
    • Using Tale’s trick of outputting RMS as audio, it turns out that RMS computation is wrong! 🤷
    • Plugin delays on different automixed tracks could be an issue!

2022-03-15

Meeting

2022-03-02

Meeting

2022-02-15

Meeting

  • We talked about our goals.
    • Fotis: Learn how synthesizers work, for example, what makes a synth from brand X different from brand Y. Explore CLAP.
    • Victor: Learn how the mathematics, music, and code come together. Build a custom livelooping that works well for accompanying monophonic instruments (flute).
    • Tom: Build a standalone application with PulseAudio, instead of a plugin that’s loaded into a DAW. Build delays & reverbs for guitar. Build an instrument similar to theremin that’s controlled with something like a Leap Motion.
    • Cwits: Learn how the mathematics, music, and code come together. Build basic plugins like delays.
    • Leandro: Develop a version of his Automixer that works in every DAW.
  • We reported success in building the basic example code given by APIs/frameworks of choice.
  • We looked at the basic example code generated by Projucer and discussed the lifecycle of a plugin and some C++.
  • We chose a task that will take us towards our goals that’s small enough we can finish it until next meeting (2022-03-01).

Links

2022-02-01

Meeting

We started by introducing ourselves. We have some people who are new to programming, and so people who are authors of C++ programming books(!)

Logistics

We’ll meet every 15 days for about 1~1.5h. We’ll communicate on Discord, Skype, and over here on this GitHub repository, where we’ll also share the code we end up writing.

Materials

Goals for Next Week

  • Setting an objective. Examples: Making a synthesizer, making a compressor, contributing to an existing open-source project, learning how a reverb works.
  • Digital Signal Processing:
    • Have a basic understanding of Digital Audio Workstations (DAW) and what some audio effects do: EQ, compression, delay, reverb, distortion, and so forth.
    • Understand how digital audio is represented: floating points, sampling rates, bit depths, frequency, amplitude, audio-to-digital conversation and digital-to-audio conversion, DC, Nyquist frequency, aliasing, time-domain vs frequency domain, and so forth.
    • How to make sense of what’s displayed in an oscilloscope (time-domain) and on a frequency spectrum analyzer (frequency domain).
    • Get a point where the first chapter of Designing Audio Effect Plug-Ins in C++ makes sense.
  • Programming:
    • Setting up a project for an audio plugin, getting it to compile, and running it inside a DAW. Either using JUCE or something else.