ML_synthtools sampler velocity control not working?

[KontinuumLab]

I am unable to get velocity response to work when using Sampler_NoteOn(channel, note, velocity);
Actual output volume of the sample is unchanged with any velocity value i feed the function.
My use case is complex, as I'm incorporating sensors, display etc, but I'm able to reproduce the issue with a slightly modified version of the original sampler example - posted below.

Should I be controlling velocity somewhere else, or am I missing some other detail somewhere?
Any help much appreciated

/*
 * Copyright (c) 2024 Marcel Licence
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Dieses Programm ist Freie Software: Sie können es unter den Bedingungen
 * der GNU General Public License, wie von der Free Software Foundation,
 * Version 3 der Lizenz oder (nach Ihrer Wahl) jeder neueren
 * veröffentlichten Version, weiter verteilen und/oder modifizieren.
 *
 * Dieses Programm wird in der Hoffnung bereitgestellt, dass es nützlich sein wird, jedoch
 * OHNE JEDE GEWÄHR,; sogar ohne die implizite
 * Gewähr der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
 * Siehe die GNU General Public License für weitere Einzelheiten.
 *
 * Sie sollten eine Kopie der GNU General Public License zusammen mit diesem
 * Programm erhalten haben. Wenn nicht, siehe <https://www.gnu.org/licenses/>.
 */

/**
 * @file ml_synth_sampler_example.ino
 * @author Marcel Licence
 * @date 26.11.2021
 *
 * @brief   This is the main project file of the soundfont, wav-files loading sampler project
 *          It should be compatible with ESP32, Raspberry Pi Pico / RP2040, others my follow in future
 */


#ifdef __CDT_PARSER__
#include <cdt.h>
#endif


#include "config.h"


#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>


/*
 * Library can be found on https://github.com/marcel-licence/ML_SynthTools
 */
#include <ml_types.h>

#ifdef REVERB_ENABLED
#include <ml_reverb.h>
#endif
#ifdef MAX_DELAY_Q
#include <ml_delay_q.h>
#endif
#include <ml_phaser.h>
#include <ml_tremolo.h>
#include <ml_lfo.h>
#include <ml_system.h>
#include <ml_vibrato.h>
#include <ml_pitch_shifter.h>
#include <ml_utils.h>


#ifdef OLED_OSC_DISP_ENABLED
#include <ml_scope.h>
#endif

/*
 * following modules will be available in version 1.2.0
 */
#include <ml_sampler.h>
#include <ml_soundfont.h>


#include "fs/fs_access.h"

/* centralized modules */
#define ML_SYNTH_INLINE_DECLARATION
#include <ml_inline.h>
#undef ML_SYNTH_INLINE_DECLARATION


#if (defined ARDUINO_GENERIC_F407VGTX) || (defined ARDUINO_DISCO_F407VG)
#include <Wire.h> /* todo remove, just for scanning */
#endif


float lfo1_buffer[SAMPLE_BUFFER_SIZE];
ML_LFO lfo1(SAMPLE_RATE, lfo1_buffer, SAMPLE_BUFFER_SIZE);

float lfo2_buffer[SAMPLE_BUFFER_SIZE];
float lfo2_buffer_scale[SAMPLE_BUFFER_SIZE];
ML_LFO lfo2(SAMPLE_RATE, lfo2_buffer, SAMPLE_BUFFER_SIZE);

#ifdef REVERB_ENABLED
ML_Tremolo tremolo(SAMPLE_RATE);
#endif

ML_Vibrato vibrato(SAMPLE_RATE);

ML_PitchShifter pitchShifter(SAMPLE_RATE);

char shortName[] = "ML_Sampler";


#ifdef SAMPLER_DYNAMIC_BUFFER_SIZE
int16_t *sample_buffer;
#endif



unsigned long startCounter = 0;
int currentNote = 0;

/**
    @brief This function contains the setup routines.
 */
void setup(void)
{
    /*
     * this code runs once
     */
    Serial.begin(SERIAL_BAUDRATE);
    //while (!Serial);
    delay(1000);
    Serial.printf("Hallo\n");
    delay(1000);
    Serial.printf("ml_sampler\n");

#if defined ESP_IDF_VERSION_MAJOR and  defined ESP_IDF_VERSION_MINOR and defined ESP_IDF_VERSION_PATCH
    /* @see https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/misc_system_api.html#sdk-version */
    Serial.printf("ESP IDF Version: %d, %d, %d\n", ESP_IDF_VERSION_MAJOR, ESP_IDF_VERSION_MINOR, ESP_IDF_VERSION_PATCH);
#endif
#ifdef CHIP_FEATURE_EMB_FLASH
    Serial.printf("Chip has embedded flash memory.\n");
#endif
#ifdef CHIP_FEATURE_WIFI_BGN
    Serial.printf("Chip has 2.4GHz WiFi.\n");
#endif
#ifdef CHIP_FEATURE_BLE
    Serial.printf("Chip has Bluetooth LE.\n");
#endif
#ifdef CHIP_FEATURE_BT
    Serial.printf("Chip has Bluetooth Classic.\n");
#endif
#ifdef CHIP_FEATURE_IEEE802154
    Serial.printf("Chip has IEEE 802.15.4.\n");
#endif
#ifdef CHIP_FEATURE_EMB_PSRAM
    Serial.printf("Chip has embedded psram.\n");
#endif


#ifdef ML_BOARD_SETUP
    Board_Setup();
#else
    Audio_Setup();

    /*
     * setup midi module / rx port
     */
    Midi_Setup();

#ifdef MIDI_USB_ENABLED
    Midi_Usb_Setup();
#endif
#endif


#ifdef ESP32
#ifndef ML_BOARD_SETUP
    Midi_Setup();
#endif
#endif


#ifdef BLINK_LED_PIN
    Blink_Setup();
    Blink_Fast(3);
#endif


    Serial.println();
    delay(250);

    Serial.printf("Loading data\n");


    Serial.printf("Sampler Example\n");


    Sampler_Init(SAMPLE_RATE);

#ifdef SAMPLER_STATIC_BUFFER_SAMPLE_CNT
    static Q1_14 buffer[SAMPLER_STATIC_BUFFER_SAMPLE_CNT];
    Sampler_UseStaticBuffer(buffer, SAMPLER_STATIC_BUFFER_SAMPLE_CNT);
#endif


#ifdef ESP32
#ifndef BOARD_HAS_PSRAM
#warning PSRAM required for this project to work
#endif
    if (ESP.getFreePsram() == 0)
    {
        Serial.printf("PSRAM has no free Memory! Please ensure PSRAM is enabled and also available on your ESP32");
        while (true)
        {
            delay(1000);
        }
    }

    uint32_t storageBytes = ESP.getFreePsram() ;

    Serial.printf("Try to allocate %d bytes\n", storageBytes);

    static uint8_t *storage = (uint8_t *)ps_calloc(storageBytes, 1);
    if (storage == NULL)
    {
        Serial.printf("Not able to allocate the complete PSRAM buffer!\nNow trying to reduce the allocation buffer size...\n");

        /*
         * for some reason using a newer ESP32 board library you cannot allocate the complete PSRAM memory
         * this loop will decrease the buffer size and repeat the allocation step again until it is successful
         */
        while ((storage == NULL))
        {
            storageBytes -= 1;
            storage = (uint8_t *)ps_calloc(storageBytes, 1);
        }
        Serial.printf("alloced %" PRIu32 " bytes\n", storageBytes);
    }

    Sampler_SetSampleBuffer(storage, storageBytes);
#endif

    /*
     * Initialize Phase Effect
     * A small buffer is needed for this effect to work
     */
    static float phaser_buffer[PHASER_BUFFER_SIZE];
    Phaser_Init(phaser_buffer, PHASER_BUFFER_SIZE);

    /*
     * Setup two LFOs, second is shifted by 90�
     */
    lfo1.setPhase(0);
    lfo2.setPhase(M_PI / 2.0f); /* like sine and cosine */

#ifdef REVERB_ENABLED
    /*
     * Initialize reverb
     * The buffer shall be static to ensure that
     * the memory will be exclusive available for the reverb module
     */
    //static float revBuffer[REV_BUFF_SIZE];
    static float *revBuffer = (float *)malloc(sizeof(float) * REV_BUFF_SIZE);
    Reverb_Setup(revBuffer);
#endif

#ifdef MAX_DELAY_Q
    /*
     * Prepare a buffer which can be used for the delay
     */
#ifdef ESP32
    static int16_t *delBuffer1 = (int16_t *)malloc(sizeof(int16_t) * MAX_DELAY_Q);
    static int16_t *delBuffer2 = (int16_t *)malloc(sizeof(int16_t) * MAX_DELAY_Q);
#else
    static int16_t delBuffer1[MAX_DELAY_Q];
    static int16_t delBuffer2[MAX_DELAY_Q];
#endif
    DelayQ_Init2(delBuffer1, delBuffer2, MAX_DELAY_Q);
#endif

    /*
     * Here is the interesting part loading some samples
     */


    Serial.printf("Loading data\n");

#ifdef SAMPLER_DYNAMIC_BUFFER_SIZE
    sample_buffer = (int16_t *)malloc(SAMPLER_DYNAMIC_BUFFER_SIZE);
    if (sample_buffer == NULL)
    {
        Serial.printf("Malloc failed for sample buffer");
    }
#endif


    FS_Setup();



//##################################################
//########## INSERTED BY ME: #########################

    SoundFontSamplerCtrl(1);
    Serial.println("Sample loaded");    
    Sampler_AllNotesOff();

    Serial.printf("setup done!\n");

    Sampler_NoteOn(0, 52, 127);
//################################################
//################################################

    startCounter = millis();

    Serial.printf("setup done!\n");

    //Sampler_NoteOn(0, 69, 127);

#ifdef MIDI_STREAM_PLAYER_ENABLED
    MidiStreamPlayer_Init();
    char midiFile[] = "/esp32_sampler_demo.mid";
    //char midiFile[] = "/esp32_sampler_demo2.mid";
    MidiStreamPlayer_PlayMidiFile_fromLittleFS(midiFile, 2);
#endif

#ifdef ESP32
    Core0TaskInit();
#else
    //#error only supported by ESP32 platform
#endif
}


#ifdef ESP32
/*
 * Core 0
 */
/* this is used to add a task to core 0 */
TaskHandle_t Core0TaskHnd;


bool setup_toggle = false;

inline
void Core0TaskInit(void)
{
    /* we need a second task for the terminal output */
    xTaskCreatePinnedToCore(Core0Task, "CoreTask0", 8000, NULL, 4, &Core0TaskHnd, 0);
}

void Core0TaskSetup(void)
{
#ifdef STRIP_ENABLED
    // StripSetup();
#endif


    /*
     * init your stuff for core0 here
     */
#ifdef TFT_ENABLED
    /* setup display if available */
#endif

#ifdef OLED_OSC_DISP_ENABLED
    ScopeOled_Setup();
#endif
#ifdef MIDI_VIA_USB_ENABLED
    UsbMidi_Setup();
#endif
#ifdef ADC_ENABLED
    AdcSetup();
#endif
}



//##################################################
//########## MODIFIED BY ME:######################

void Core0TaskLoop(void)
{ if(millis() - startCounter > 12000 && currentNote == 10){
    currentNote = 0;
    startCounter = millis();
  }
  else if(millis() - startCounter > 10000 && currentNote == 9){
    currentNote = 10;
    Sampler_NoteOn(0, 52, 127);
    Serial.println("note 10");
  }
  else if(millis() - startCounter > 9000 && currentNote == 8){
    currentNote = 9;
    Sampler_NoteOn(0, 52, 110);
    Serial.println("note 9");
  }
  else if(millis() - startCounter > 8000 && currentNote == 7){
    currentNote = 8;
    Sampler_NoteOn(0, 52, 95);
    Serial.println("note 8");
  }
  else if(millis() - startCounter > 7000 && currentNote == 6){
    currentNote = 7;
    Sampler_NoteOn(0, 52, 80);
    Serial.println("note 7");
  }
  else if(millis() - startCounter > 6000 && currentNote == 5){
    currentNote = 6;
    Sampler_NoteOn(0, 52, 65);
    Serial.println("note 6");
  }
  else if(millis() - startCounter > 5000 && currentNote == 4){
    currentNote = 5;
    Sampler_NoteOn(0, 52, 50);
    Serial.println("note 5");
  }
  else if(millis() - startCounter > 4000 && currentNote == 3){
    currentNote = 4;
    Sampler_NoteOn(0, 52, 35);
    Serial.println("note 4");
  }
  else if(millis() - startCounter > 3000 && currentNote == 2){
    currentNote = 3;
    Sampler_NoteOn(0, 52, 20);
    Serial.println("note 3");
  }
  else if(millis() - startCounter > 2000 && currentNote == 1){
    currentNote = 2;
    Sampler_NoteOn(0, 52, 10);
    Serial.println("note 2");
  }
  else if(millis() - startCounter > 1000 && currentNote == 0){
    currentNote = 1;
    Sampler_NoteOn(0, 52, 0);
    Serial.println("note 1");
  }
  int i;
  // for(i = 0; i < 128; i += 10){
  //   Sampler_NoteOn(0, 52, i);
  // }
  // #ifdef MIDI_VIA_USB_ENABLED
  //     UsbMidi_Loop();
  // #endif

  // #ifdef OLED_OSC_DISP_ENABLED
  //     ScopeOled_Process();
  // #endif

  // #ifdef STRIP_ENABLED
  //     //StripLoop();
  // #endif

  // #ifdef ADC_ENABLED
  //     AdcLoop();
  // #endif

  // #ifdef MCP23_ENABLED
  //     MCP23_Loop();
  // #endif

  // #ifdef TFT_ENABLED
  //     /* tft code could be here */
  // #endif
}
//##################################################
//##################################################




void Core0Task(void *parameter)
{
    Core0TaskSetup();

    while (true)
    {
        Core0TaskLoop();

        /* this seems necessary to trigger the watchdog */
        delay(1);
        yield();
    }
}
#endif /* ESP32 */


/**
    @brief This function will be called every second.
        In case of an overload the function will not called so often
  */
void loop_1Hz(void)
{
#ifdef BLINK_LED_PIN
    Blink_Process();
#endif
}

float preAmp = 0.125f;
float postAmp = 1.0f;
float bypassAmp = 1.0f;
float rotLevel = 1.0f;
bool hq_enabled = true;
float inputGain = 1.0f;

/**
    @brief This function contains the mainloop
 */
void loop(void)
{
    static int loop_cnt_1hz = 0; /*!< counter to allow 1Hz loop cycle */

    loop_cnt_1hz += SAMPLE_BUFFER_SIZE;

    if (loop_cnt_1hz >= SAMPLE_RATE)
    {
        loop_cnt_1hz -= SAMPLE_RATE;
        loop_1Hz();
    }

    /*
     * MIDI processing
     */
    Midi_Process();

#ifdef MIDI_VIA_USB_ENABLED
    UsbMidi_ProcessSync();
#endif

#ifdef MIDI_STREAM_PLAYER_ENABLED
    MidiStreamPlayer_Tick(SAMPLE_BUFFER_SIZE);
#endif

#ifdef MIDI_BLE_ENABLED
    midi_ble_loop();
#endif

#ifdef USB_HOST_ENABLED
    Usb_Host_Midi_loop();
#endif

#ifdef MIDI_USB_ENABLED
    Midi_Usb_Loop();
#endif

    Status_Loop(240000);
    Status_LoopMain();

    /*
     * And finally the audio stuff
     */
    Q1_14 left[SAMPLE_BUFFER_SIZE], right[SAMPLE_BUFFER_SIZE];

    memset(left, 0, sizeof(left));
    memset(right, 0, sizeof(right));


#ifdef AUDIO_PASS_THROUGH
    Audio_Input(left, right);

    mul(left, inputGain, left, SAMPLE_BUFFER_SIZE);
    mul(right, inputGain, right, SAMPLE_BUFFER_SIZE);
#endif

    Sampler_Process(left, right, SAMPLE_BUFFER_SIZE);

#ifdef REVERB_ENABLED
    float mono[SAMPLE_BUFFER_SIZE];

    mixStereoToMono(left, right, mono, SAMPLE_BUFFER_SIZE);

    Reverb_Process(mono, SAMPLE_BUFFER_SIZE);

    lfo2.Process(SAMPLE_BUFFER_SIZE);



    if (hq_enabled)
    {
        Phaser_ProcessHQ(mono, lfo1_buffer, mono, SAMPLE_BUFFER_SIZE);
    }
    else
    {
        Phaser_Process(mono, lfo1_buffer, mono, SAMPLE_BUFFER_SIZE);
    }

    if (hq_enabled)
    {
        vibrato.ProcessHQ(mono, lfo1_buffer, mono, SAMPLE_BUFFER_SIZE);
    }
    else
    {
        vibrato.Process(mono, lfo1_buffer, mono, SAMPLE_BUFFER_SIZE);
    }

    if (hq_enabled)
    {
        pitchShifter.ProcessHQ(mono, mono, SAMPLE_BUFFER_SIZE);
    }
    else
    {
        pitchShifter.Process(mono, mono, SAMPLE_BUFFER_SIZE);
    }

    float f_l[SAMPLE_BUFFER_SIZE], f_r[SAMPLE_BUFFER_SIZE];
    tremolo.Process(mono, mono, lfo1_buffer, f_l, f_r, SAMPLE_BUFFER_SIZE);

    for (int n = 0; n < SAMPLE_BUFFER_SIZE; n++)
    {
        left[n].s16 = f_l[n] * 16384;
        right[n].s16 = f_r[n] * 16384;
    }
#endif

#ifdef MAX_DELAY_Q
    /*
     * post process delay
     */
    DelayQ_Process_Buff(&left[0].s16, &right[0].s16, &left[0].s16, &right[0].s16, SAMPLE_BUFFER_SIZE);
#endif

    /*
     * Output the audio
     */
    Audio_Output(left, right);

#ifdef OLED_OSC_DISP_ENABLED
    {
        float fl_sample[SAMPLE_BUFFER_SIZE];
        float fr_sample[SAMPLE_BUFFER_SIZE];
        const float convf = 1.0f / 16384.0f;
        for (uint32_t n = 0; n < SAMPLE_BUFFER_SIZE; n++)
        {
            fl_sample[n] = ((float)left[n].s16) * convf;
            fr_sample[n] = ((float)right[n].s16) * convf;
        }
        ScopeOled_AddSamples(fl_sample, fr_sample, SAMPLE_BUFFER_SIZE);
    }
#endif

#ifdef ESP8266
    static int32_t xxr = 0;
    int32_t mono_i32[SAMPLE_BUFFER_SIZE];
    for (int n = 0; n < SAMPLE_BUFFER_SIZE; n++)
    {
        xxr += 0x4;
        int32_t s = left[n].s16;
        s << 16UL;
        s += right[n].s16;
        mono_i32[n] = s;
    }
    Audio_OutputMono(mono_i32);
#endif
}

/*
 * MIDI callbacks
 */
inline void AppBtn(uint8_t param, uint8_t value)
{
    if (value > 0)
    {

        switch (param)
        {
#ifdef BOARD_ESP32_AUDIO_KIT_AC101
        case 0:
            ac101_setSourceMic();
            break;
        case 1:
            ac101_setSourceLine();
            break;
#endif
#if 0
        case 2:
            hq_enabled = true;
            break;
        case 3:
            hq_enabled = false;
            break;
#endif
        case 7:
            Sampler_DecSample();
            break;
        case 8:
            Sampler_IncSample();
            break;

        default:
            SoundFontSamplerCtrl(param + 9);
        }
    }
}

inline void AppBtnB(uint8_t param, uint8_t value)
{
    if (value > 0)
    {
        SoundFontSamplerCtrl(param);
    }
}

void AppSetInputGain(uint8_t unused __attribute__((unused)), uint8_t value)
{
    inputGain = log2fromU7(value, -16, 5);
    Status_ValueChangedFloat("Input", "Gain", inputGain);
}

#ifdef REVERB_ENABLED
void AppReverb_SetLevel(uint8_t param __attribute__((unused)), uint8_t value)
{
    Reverb_SetLevel(param, floatFromU7(value));
}
#endif

void AppTremolo_SetDepth(uint8_t param __attribute__((unused)), uint8_t value)
{
#ifdef REVERB_ENABLED
    tremolo.setDepth(floatFromU7(value));
#else
    (void)value;
#endif
}

void AppVibrato_SetDepth(uint8_t param __attribute__((unused)), uint8_t value)
{
    vibrato.setDepth(floatFromU7(value));
}

void AppVibrato_SetIntensity(uint8_t param __attribute__((unused)), uint8_t value)
{
    vibrato.setIntensity(floatFromU7(value));
}

/**
 * @brief
 *
 * @param unused
 * @param value
 */
void App_DelayQ_SetLength(uint8_t unused __attribute__((unused)), uint8_t value)
{
#ifdef MAX_DELAY_Q
    uint32_t val32 = value;
    val32 *= 189;
    DelayQ_SetLength(unused, val32);
#endif
}

/**
 * @brief
 *
 * @param slider
 * @param value
 */
void App_SliderSawCtrl(uint8_t slider, uint8_t value)
{
    Serial.printf("slider %d: %d\n", slider, value);
}


/**
 * @brief Implemented callback to display debug information of sampler module
 *
 */
void Sampler_DebugInt(const char *str __attribute__((unused)), uint32_t num __attribute__((unused)))
{
    //Serial.printf("%s: %" PRIu32 "\n", str, num);
}

void Sampler_DebugFloat(const char *str __attribute__((unused)), float num __attribute__((unused)))
{
    //Serial.printf("%s: %f\n", str, num);
}

void Lfo1_SetSpeed(uint8_t unused __attribute__((unused)), uint8_t value)
{
    float f = log10fromU7(value, -2, 3);
    lfo1.setFrequency(f);
    lfo2.setFrequency(f);
    Status_ValueChangedFloat("Lfo", "Frequency", f);
}

void PitchShifter_SetSpeed(uint8_t unused __attribute__((unused)), uint8_t value)
{
    float f = value;

    f -= 64.0f;

    f /= 12.0f;
    f = pow(2, f);

    pitchShifter.setSpeed(-f);
}

void PitchShifter_SetMix(uint8_t unused __attribute__((unused)), uint8_t value)
{
    pitchShifter.setMix(floatFromU7(value));
}

void PitchShifter_SetFeedback(uint8_t unused __attribute__((unused)), uint8_t value)
{
    pitchShifter.setFeedback(floatFromU7(value));
}

[marcel-licence]

I've checked the code. The velocity value was not processed during the playback. I could prepare an update

[marcel-licence]

Sounds great. The name comes from the idea to manipulate the initial vel value but I would agree that we are talking about the volume.
Do you need a smooth independent volume for each note or are they groups? The smoothing will cost processing power. So I am careful with features or I should find a way to switch between different processing methods. Which might a good way which can be used in future.

[KontinuumLab]

The way I've made wind instruments in the past, was mostly using the Teensy audio library, specifically the wavetable synth, which can use .sf2 files, after some modification. I don't know how it handles smoothing, but it works very well, when adjusting the volume live through a breath sensor for example. Like I mentioned, I normally implement some signal smoothing before changing the volume, so that helps to avoid jumps and weird clipping.

As for my tests, I'm working right now on adapting my current prototype for this, and also trying to get a looping .sf2 sample up and running. I'll be back shortly

[KontinuumLab]

The new function works very well in my early tests. But it is pretty crunchy on quick changes, so some smoothing is probably in order.
A group based solution like you mentioned, could be very useful for touch based keyboards, with pressure based volume, or anything that has a general volume pedal.
Realistically, for a wind instrument I'd generally use two channels I find switching back and forth on note changes, letting the decay and attack of each note partially overlap, can result in a much smoother phrasing. Especially on wind instrument samples with long "breathy" attacks.
So two would be the minimum useful number of channels for that particular use case.

But separate volume control on as many voices as possible would of course be ideal. 😁 What do you think a sensible upper limit would be, of separately controlled and smoothed voices?

[marcel-licence]

I tried something very interesting for you. It should be an accordion project at the end of the day. At the moment it is just a single reed I want to get more realistic.
Do you have a fast pressure sensor? I tried mine (from the FM with pressure video) but it seems a bit slow for a good feeling.

[KontinuumLab]

Do you mean a reed simulating synth? That sounds very cool! Would love to try it out. I'm not an expert on synth engines, but I guess that could be adapted to emulate other reed instruments as well as the accordion, right?
I've also found industry air pressure sensors to be either slow, or impractical, or they respond to impractical pressure ranges. Now, being a saxophone player myself, that's unacceptable, so I actually make my own breath sensors. They are very fast, and can be adjusted to different players needs....
Here's a simple example of how I put one together: https://www.youtube.com/watch?v=es92GqYBge0
But I also use the same concept in more advanced instruments: https://www.youtube.com/watch?v=PZ-1ABUruD0

[marcel-licence]

Yes, it should be kind of simulating synth. The implementation was stuck a bit. An accordion needs much more sounds but for mono or dual sound it should be much easier having enough headroom of processing power.

I could imagine that it can be adopted to other instruments as-well.

The pressure sensors are very nice. I should try something like this too soon. At the moment I am checking the variation by using some slider or knob.

I've updated the sampler and added Sampler_SetChannelVolume.
You should be able to assign different channels to the same sound but using independent volumes. Smoothing is still missing but can be added soon.

To link it update z_config:

{ 0xFF, 0x07, "Volume", Sampler_SetChannelVolume, NULL, 0},

[KontinuumLab]

Now it works, thanks so much.
I should have thought to actually set the new volume parameter to some sensible value, makes sense.

[marcel-licence]

I am happy to hear that. Did you tried to use static samples from flash? This is nice and avoids using PSRAM, LitteFS and SDCard. In case you want to go very small with the device

[KontinuumLab]

I tried for a long time to fit samples for your sampler on to the lolin32 lite, which has no PSRAM, but I was never able to fit more than 28kb on there and have it work, which I mentioned at the end of another thread.

But like I mentioned, when I was previously using STK and audioTools I was able to use several MB for samples on the same board, because that library uses static arrays for samples.
STK only works with wav samples, but the Teensy audio library on the other hand, can work with heavily modified sf2 files, also included in the sketch as static entities.

Now, recently I've switched to a wrover devkit, just for the PSRAM. But it's more expensive, and I don't like it very much to be honest. So if I could fit a couple of megabytes of samples on a lolin32 lite, that would be extremely awesome.

Could this work with both wav and sf2 files?
If so, how would you go about generating the necessary arrays or whatever, and how would you then play it through the sampler?
For STK I had to - export a raw file from audacity, put it through a hex editor and export a C array from there, modify some details, and include in the sketch
To put sf2 files on the Teensy, the process was super complicated, too long to get into.

[marcel-licence]

At the moment I have only wav playback but I could check if that could be extend to sf2.
Loading wav files (converted them from wav to .h) could be done within a loop for example:

    /*
     * load static samples from flash assigned to note C (36) ++
     */
    for (uint32_t i = 0; i < sizeof(sample_list) / sizeof(sample_list[0]); i++)
    {
        Sampler_NewSampleStatic(sample_list[i].data, sample_list[i].len, 36 + i);
    }

with
struct sample_list_s
{
const unsigned char *data;
int len;
} ;

struct sample_list_s sample_list[] =

{
    {_ac001_BD9, sizeof(_ac001_BD9)},
    {_ac002_SD9, sizeof(_ac002_SD9)},
...
    {_ac208_CH6, sizeof(_ac208_CH6)},
    {_ac210_CY6, sizeof(_ac210_CY6)},
};

For example to load some 909 or similar drum set.

I am using the wrover on my own PCB. That avoids some random trouble.

When supporting sf2 it should be easy as possible. Just to convert it to .h and pass data to a loading function. Would be nice =)

[KontinuumLab]

If you do decide to implement something like that for sf2 as well, I'd be very interested 👍