Porting ARM software interrupts to ESP32 / FreeRTOS software interrupt

I'm porting the PJRC Teensy Audio Library for ESP32, because I want to stay compatible with the API. I'm having trouble how to port the update() functions of AudioStream(). So far I've added the IRAM_ATTR to the interrupt funtion, but I'm not sure if that's correct.

https://github.com/PaulStoffregen/cores/blob/master/teensy3/AudioStream.cpp#L302

So far my code looks like this:

#include <Arduino.h>
#include "AudioStream.h"

#define MAX_AUDIO_MEMORY 49152

#define NUM_MASKS  (((MAX_AUDIO_MEMORY / AUDIO_BLOCK_SAMPLES / 2) + 31) / 32)

audio_block_t * AudioStream::memory_pool;
uint32_t AudioStream::memory_pool_available_mask[NUM_MASKS];
uint16_t AudioStream::memory_pool_first_mask;

uint16_t AudioStream::cpu_cycles_total = 0;
uint16_t AudioStream::cpu_cycles_total_max = 0;
uint16_t AudioStream::memory_used = 0;
uint16_t AudioStream::memory_used_max = 0;

void AudioStream::initialize_memory(audio_block_t *data, unsigned int num)
{
    unsigned int i;
    unsigned int maxnum = MAX_AUDIO_MEMORY / AUDIO_BLOCK_SAMPLES / 2;

    //Serial.println("AudioStream initialize_memory");
    //delay(10);
    if (num > maxnum) num = maxnum;
    __disable_irq();
    memory_pool = data;
    memory_pool_first_mask = 0;
    for (i=0; i < NUM_MASKS; i++) {
        memory_pool_available_mask[i] = 0;
    }
    for (i=0; i < num; i++) {
        memory_pool_available_mask[i >> 5] |= (1 << (i & 0x1F));
    }
    for (i=0; i < num; i++) {
        data[i].memory_pool_index = i;
    }
    __enable_irq();

}

// Allocate 1 audio data block.  If successful
// the caller is the only owner of this new block
audio_block_t * AudioStream::allocate(void)
{
    uint32_t n, index, avail;
    uint32_t *p, *end;
    audio_block_t *block;
    uint32_t used;

    p = memory_pool_available_mask;
    end = p + NUM_MASKS;
    __disable_irq();
    index = memory_pool_first_mask;
    p += index;
    while (1) {
        if (p >= end) {
            __enable_irq();
            //Serial.println("alloc:null");
            return NULL;
        }
        avail = *p;
        if (avail) break;
        index++;
        p++;
    }
    n = __builtin_clz(avail);
    avail &= ~(0x80000000 >> n);
    *p = avail;
    if (!avail) index++;
    memory_pool_first_mask = index;
    used = memory_used + 1;
    memory_used = used;
    __enable_irq();
    index = p - memory_pool_available_mask;
    block = memory_pool + ((index << 5) + (31 - n));
    block->ref_count = 1;
    if (used > memory_used_max) memory_used_max = used;
    //Serial.print("alloc:");
    //Serial.println((uint32_t)block, HEX);
    return block;
}

// Release ownership of a data block.  If no
// other streams have ownership, the block is
// returned to the free pool
void AudioStream::release(audio_block_t *block)
{
    //if (block == NULL) return;
    uint32_t mask = (0x80000000 >> (31 - (block->memory_pool_index & 0x1F)));
    uint32_t index = block->memory_pool_index >> 5;

    __disable_irq();
    if (block->ref_count > 1) {
        block->ref_count--;
    } else {
        //Serial.print("reles:");
        //Serial.println((uint32_t)block, HEX);
        memory_pool_available_mask[index] |= mask;
        if (index < memory_pool_first_mask) memory_pool_first_mask = index;
        memory_used--;
    }
    __enable_irq();
}

void AudioStream::transmit(audio_block_t *block, unsigned char index)
{
    for (AudioConnection *c = destination_list; c != NULL; c = c->next_dest) {
        if (c->src_index == index) {
            if (c->dst.inputQueue[c->dest_index] == NULL) {
                c->dst.inputQueue[c->dest_index] = block;
                block->ref_count++;
            }
        }
    }
}

audio_block_t * AudioStream::receiveReadOnly(unsigned int index)
{
    audio_block_t *in;

    if (index >= num_inputs) return NULL;
    in = inputQueue[index];
    inputQueue[index] = NULL;
    return in;
}

audio_block_t * AudioStream::receiveWritable(unsigned int index)
{
    audio_block_t *in, *p;

    if (index >= num_inputs) return NULL;
    in = inputQueue[index];
    inputQueue[index] = NULL;
    if (in && in->ref_count > 1) {
        p = allocate();
        if (p) memcpy(p->data, in->data, sizeof(p->data));
        in->ref_count--;
        in = p;
    }
    return in;
}

void AudioConnection::connect(void)
{
    AudioConnection *p;

    if (isConnected) return;
    if (dest_index > dst.num_inputs) return;
    __disable_irq();
    p = src.destination_list;
    if (p == NULL) {
        src.destination_list = this;
    } else {
        while (p->next_dest) {
            if (&p->src == &this->src && &p->dst == &this->dst
                && p->src_index == this->src_index && p->dest_index == this->dest_index) {
                //Source and destination already connected through another connection, abort
                __enable_irq();
                return;
            }
            p = p->next_dest;
        }
        p->next_dest = this;
    }
    this->next_dest = NULL;
    src.numConnections++;
    src.active = true;

    dst.numConnections++;
    dst.active = true;

    isConnected = true;

    __enable_irq();
}

void AudioConnection::disconnect(void)
{
    AudioConnection *p;

    if (!isConnected) return;
    if (dest_index > dst.num_inputs) return;
    __disable_irq();
    // Remove destination from source list
    p = src.destination_list;
    if (p == NULL) {
//>>> PAH re-enable the IRQ
        __enable_irq();
        return;
    } else if (p == this) {
        if (p->next_dest) {
            src.destination_list = next_dest;
        } else {
            src.destination_list = NULL;
        }
    } else {
        while (p) {
            if (p == this) {
                if (p->next_dest) {
                    p = next_dest;
                    break;
                } else {
                    p = NULL;
                    break;
                }
            }
            p = p->next_dest;
        }
    }
//>>> PAH release the audio buffer properly
    //Remove possible pending src block from destination
    if(dst.inputQueue[dest_index] != NULL) {
        AudioStream::release(dst.inputQueue[dest_index]);
        // release() re-enables the IRQ. Need it to be disabled a little longer
        __disable_irq();
        dst.inputQueue[dest_index] = NULL;
    }

    //Check if the disconnected AudioStream objects should still be active
    src.numConnections--;
    if (src.numConnections == 0) {
        src.active = false;
    }

    dst.numConnections--;
    if (dst.numConnections == 0) {
        dst.active = false;
    }

    isConnected = false;

    __enable_irq();
}

bool AudioStream::update_scheduled = false;

bool AudioStream::update_setup(void)
{
    if (update_scheduled) return false;
    NVIC_SET_PRIORITY(IRQ_SOFTWARE, 208); // 255 = lowest priority
    NVIC_ENABLE_IRQ(IRQ_SOFTWARE);
    update_scheduled = true;
    return true;
}

void AudioStream::update_stop(void)
{
    NVIC_DISABLE_IRQ(IRQ_SOFTWARE);
    update_scheduled = false;
}

AudioStream * AudioStream::first_update = NULL;

void IRAM_ATTR software_isr(void) // AudioStream::update_all()
{
    AudioStream *p;

    uint32_t totalcycles = micros();

    //digitalWriteFast(2, HIGH);
    for (p = AudioStream::first_update; p; p = p->next_update) {
        if (p->active) {
            uint32_t cycles = get_cycles_esp32(); 
            p->update();
            // TODO: traverse inputQueueArray and release
            // any input blocks that weren't consumed?
            cycles = ( get_cycles_esp32() - cycles) >> 4;
            p->cpu_cycles = cycles;
            if (cycles > p->cpu_cycles_max) p->cpu_cycles_max = cycles;
        }
    }

    totalcycles = micros() - totalcycles;
    AudioStream::cpu_cycles_total = totalcycles;
    if (totalcycles > AudioStream::cpu_cycles_total_max)
        AudioStream::cpu_cycles_total_max = totalcycles;
}

where

uint32_t get_cycles_esp32(){ uint32_t ccount; RSR(CCOUNT, ccount); return ccount; }

Now I cannot figure out what NVIC_SET_PRIORITY,NVIC_ENABLE_IRQ, NVIC_DISABLE_IRQ equivalents would be and I'm not sure if I use ESP32 interrupt handles or FreeRTOS.