mirror of https://github.com/probonopd/MiniDexed
jnonis
7 months ago
parent
9c55aa6a46
commit
0cb0553f25
@ -0,0 +1,101 @@ |
||||
#include "midi_arp.h" |
||||
#include <stdio.h> |
||||
|
||||
MidiArp::MidiArp(float32_t samplerate, CDexedAdapter* synth) |
||||
{ |
||||
this->samplerate = samplerate; |
||||
this->syncMode = 1; |
||||
this->synth = synth; |
||||
|
||||
arpeggiator.transmitHostInfo(0, 4, 1, 1, 120.0); |
||||
arpeggiator.setSampleRate(samplerate); |
||||
arpeggiator.setDivision(7); |
||||
|
||||
arpeggiator.getMidiBuffer(); |
||||
} |
||||
|
||||
MidiArp::~MidiArp() |
||||
{ |
||||
} |
||||
|
||||
void MidiArp::keydown(int16_t pitch, uint8_t velocity) |
||||
{ |
||||
MidiEvent event; |
||||
event.data[0] = MIDI_NOTE_ON << 4; |
||||
event.data[1] = pitch; |
||||
event.data[2] = velocity; |
||||
event.size = 3; |
||||
event.frame = 0; |
||||
this->events.push_back(event); |
||||
} |
||||
|
||||
void MidiArp::keyup(int16_t pitch) |
||||
{ |
||||
MidiEvent event; |
||||
event.data[0] = MIDI_NOTE_OFF << 4; |
||||
event.data[1] = pitch; |
||||
event.data[2] = 0; |
||||
event.size = 3; |
||||
event.frame = 0; |
||||
this->events.push_back(event); |
||||
} |
||||
|
||||
void MidiArp::process(uint16_t len) |
||||
{ |
||||
arpeggiator.emptyMidiBuffer(); |
||||
|
||||
// Check if host supports Bar-Beat-Tick position
|
||||
/*
|
||||
const TimePosition& position = getTimePosition(); |
||||
if (!position.bbt.valid) { |
||||
// set-arpeggiator in free running mode
|
||||
arpeggiator.setSyncMode(0); |
||||
} else { |
||||
arpeggiator.setSyncMode(syncMode); |
||||
arpeggiator.transmitHostInfo(position.playing, position.bbt.beatsPerBar, position.bbt.beat, position.bbt.barBeat, static_cast<float>(position.bbt.beatsPerMinute)); |
||||
} |
||||
*/ |
||||
|
||||
arpeggiator.process(events.data(), events.size(), len); |
||||
events.clear(); |
||||
events.shrink_to_fit(); |
||||
|
||||
/*
|
||||
printf("Before Send Midi\n"); |
||||
fflush(NULL); |
||||
struct MidiBuffer buffer = arpeggiator.getMidiBuffer(); |
||||
for (unsigned x = 0; x < buffer.numBufferedEvents + buffer.numBufferedThroughEvents; x++) { |
||||
printf("Loop x: %d\n", x); |
||||
fflush(NULL); |
||||
|
||||
MidiEvent event = buffer.bufferedEvents[x]; |
||||
unsigned eventType = event.data[0] >> 4; |
||||
|
||||
switch (eventType) |
||||
{ |
||||
case MIDI_NOTE_ON: |
||||
if (event.data[2] > 0) |
||||
{ |
||||
if (event.data[2] <= 127) |
||||
{ |
||||
this->synth->keydown(event.data[1], event.data[2]); |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
this->synth->keyup(event.data[1]); |
||||
} |
||||
break; |
||||
|
||||
case MIDI_NOTE_OFF: |
||||
this->synth->keyup(event.data[1]); |
||||
break; |
||||
|
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
printf("After Send Midi\n"); |
||||
fflush(NULL); |
||||
*/ |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
/*
|
||||
* Base AudioEffect interface |
||||
* Javier Nonis (https://github.com/jnonis) - 2024
|
||||
*/ |
||||
#ifndef _MIDI_ARP_H |
||||
#define _MIDI_ARP_H |
||||
|
||||
#include <vector> |
||||
#include <arm_math.h> |
||||
#include "modarpeggiator/common/commons.h" |
||||
#include "modarpeggiator/arpeggiator.hpp" |
||||
#include "modarpeggiator/common/clock.hpp" |
||||
#include "modarpeggiator/common/pattern.hpp" |
||||
#include "dexedadapter.h" |
||||
|
||||
class MidiArp |
||||
{ |
||||
public: |
||||
MidiArp(float32_t samplerate, CDexedAdapter* synth); |
||||
~MidiArp(); |
||||
|
||||
void keydown(int16_t pitch, uint8_t velocity); |
||||
void keyup(int16_t pitch); |
||||
|
||||
void process(uint16_t len); |
||||
protected: |
||||
bool bypass = false; |
||||
float32_t samplerate; |
||||
|
||||
private: |
||||
static const unsigned MIDI_NOTE_OFF = 0b1000; |
||||
static const unsigned MIDI_NOTE_ON = 0b1001; |
||||
|
||||
CDexedAdapter* synth; |
||||
Arpeggiator arpeggiator; |
||||
int syncMode; |
||||
std::vector<MidiEvent> events; |
||||
}; |
||||
|
||||
#endif // _MIDI_ARP_H
|
||||
@ -0,0 +1,648 @@ |
||||
#include "arpeggiator.hpp" |
||||
|
||||
Arpeggiator::Arpeggiator() : |
||||
notesPressed(0), |
||||
activeNotes(0), |
||||
notePlayed(0), |
||||
octaveMode(0), |
||||
octaveSpread(1), |
||||
arpMode(0), |
||||
noteLength(0.8), |
||||
pitch(0), |
||||
previousMidiNote(0), |
||||
velocity(80), |
||||
previousSyncMode(0), |
||||
activeNotesIndex(0), |
||||
activeNotesBypassed(0), |
||||
timeOutTime(1000), |
||||
firstNoteTimer(0), |
||||
barBeat(0.0), |
||||
pluginEnabled(true), |
||||
first(true), |
||||
arpEnabled(true), |
||||
latchMode(false), |
||||
previousLatch(false), |
||||
latchPlaying(false), |
||||
trigger(false), |
||||
firstNote(false), |
||||
quantizedStart(false), |
||||
resetPattern(false), |
||||
midiNotesCopied(false), |
||||
panic(false), |
||||
division(0), |
||||
sampleRate(48000), |
||||
bpm(0) |
||||
{ |
||||
clock.transmitHostInfo(0, 4, 1, 1, 120.0); |
||||
clock.setSampleRate(static_cast<float>(48000.0)); |
||||
clock.setDivision(7); |
||||
|
||||
arpPattern = new Pattern*[6]; |
||||
|
||||
arpPattern[0] = new PatternUp(); |
||||
arpPattern[1] = new PatternDown(); |
||||
arpPattern[2] = new PatternUpDown(); |
||||
arpPattern[3] = new PatternUpDownAlt(); |
||||
arpPattern[4] = new PatternUp(); |
||||
arpPattern[5] = new PatternRandom(); |
||||
|
||||
|
||||
octavePattern = new Pattern*[5]; |
||||
|
||||
octavePattern[0] = new PatternUp(); |
||||
octavePattern[1] = new PatternDown(); |
||||
octavePattern[2] = new PatternUpDown(); |
||||
octavePattern[3] = new PatternUpDownAlt(); |
||||
octavePattern[4] = new PatternCycle(); |
||||
|
||||
for (unsigned i = 0; i < NUM_VOICES; i++) { |
||||
midiNotes[i][0] = EMPTY_SLOT; |
||||
midiNotes[i][1] = 0; |
||||
midiNotesBypassed[i] = EMPTY_SLOT; |
||||
} |
||||
for (unsigned i = 0; i < NUM_VOICES; i++) { |
||||
noteOffBuffer[i][MIDI_NOTE] = EMPTY_SLOT; |
||||
noteOffBuffer[i][MIDI_CHANNEL] = 0; |
||||
noteOffBuffer[i][TIMER] = 0; |
||||
} |
||||
} |
||||
|
||||
Arpeggiator::~Arpeggiator() |
||||
{ |
||||
|
||||
delete arpPattern[0]; |
||||
delete arpPattern[1]; |
||||
delete arpPattern[2]; |
||||
delete arpPattern[3]; |
||||
delete arpPattern[4]; |
||||
delete arpPattern[5]; |
||||
delete octavePattern[0]; |
||||
delete octavePattern[1]; |
||||
delete octavePattern[2]; |
||||
delete octavePattern[3]; |
||||
delete octavePattern[4]; |
||||
|
||||
delete[] arpPattern; |
||||
arpPattern = nullptr; |
||||
delete[] octavePattern; |
||||
octavePattern = nullptr; |
||||
} |
||||
|
||||
void Arpeggiator::setArpEnabled(bool arpEnabled) |
||||
{ |
||||
this->arpEnabled = arpEnabled; |
||||
} |
||||
|
||||
void Arpeggiator::setLatchMode(bool latchMode) |
||||
{ |
||||
this->latchMode = latchMode; |
||||
} |
||||
|
||||
void Arpeggiator::setSampleRate(float newSampleRate) |
||||
{ |
||||
if (newSampleRate != sampleRate) { |
||||
clock.setSampleRate(newSampleRate); |
||||
sampleRate = newSampleRate; |
||||
} |
||||
} |
||||
|
||||
void Arpeggiator::setSyncMode(int mode) |
||||
{ |
||||
|
||||
switch (mode) |
||||
{ |
||||
case FREE_RUNNING: |
||||
clock.setSyncMode(FREE_RUNNING); |
||||
quantizedStart = false; |
||||
break; |
||||
case HOST_BPM_SYNC: |
||||
clock.setSyncMode(HOST_BPM_SYNC); |
||||
quantizedStart = false; |
||||
break; |
||||
case HOST_QUANTIZED_SYNC: |
||||
clock.setSyncMode(HOST_QUANTIZED_SYNC); |
||||
quantizedStart = true; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
void Arpeggiator::setBpm(double newBpm) |
||||
{ |
||||
if (newBpm != bpm) { |
||||
clock.setInternalBpmValue(static_cast<float>(newBpm)); |
||||
bpm = newBpm; |
||||
} |
||||
} |
||||
|
||||
void Arpeggiator::setDivision(int newDivision) |
||||
{ |
||||
if (newDivision != division) { |
||||
clock.setDivision(newDivision); |
||||
division = newDivision; |
||||
} |
||||
} |
||||
|
||||
void Arpeggiator::setVelocity(uint8_t velocity) |
||||
{ |
||||
this->velocity = velocity; |
||||
} |
||||
|
||||
void Arpeggiator::setNoteLength(float noteLength) |
||||
{ |
||||
this->noteLength = noteLength; |
||||
} |
||||
|
||||
void Arpeggiator::setOctaveSpread(int octaveSpread) |
||||
{ |
||||
this->octaveSpread = octaveSpread; |
||||
} |
||||
|
||||
void Arpeggiator::setArpMode(int arpMode) |
||||
{ |
||||
arpPattern[arpMode]->setStep(arpPattern[this->arpMode]->getStep()); |
||||
arpPattern[arpMode]->setDirection(arpPattern[this->arpMode]->getDirection()); |
||||
|
||||
this->arpMode = arpMode; |
||||
} |
||||
|
||||
void Arpeggiator::setOctaveMode(int octaveMode) |
||||
{ |
||||
octavePattern[octaveMode]->setStep(octavePattern[this->octaveMode]->getStep()); |
||||
octavePattern[octaveMode]->setDirection(octavePattern[this->octaveMode]->getDirection()); |
||||
|
||||
this->octaveMode = octaveMode; |
||||
} |
||||
|
||||
void Arpeggiator::setPanic(bool panic) |
||||
{ |
||||
this->panic = panic; |
||||
} |
||||
|
||||
bool Arpeggiator::getArpEnabled() const |
||||
{ |
||||
return arpEnabled; |
||||
} |
||||
|
||||
bool Arpeggiator::getLatchMode() const |
||||
{ |
||||
return latchMode; |
||||
} |
||||
|
||||
float Arpeggiator::getSampleRate() const |
||||
{ |
||||
return clock.getSampleRate(); |
||||
} |
||||
|
||||
int Arpeggiator::getSyncMode() const |
||||
{ |
||||
return clock.getSyncMode(); |
||||
} |
||||
|
||||
float Arpeggiator::getBpm() const |
||||
{ |
||||
return clock.getInternalBpmValue(); |
||||
} |
||||
|
||||
int Arpeggiator::getDivision() const |
||||
{ |
||||
return clock.getDivision(); |
||||
} |
||||
|
||||
uint8_t Arpeggiator::getVelocity() const |
||||
{ |
||||
return velocity; |
||||
} |
||||
|
||||
float Arpeggiator::getNoteLength() const |
||||
{ |
||||
return noteLength; |
||||
} |
||||
|
||||
int Arpeggiator::getOctaveSpread() const |
||||
{ |
||||
return octaveSpread; |
||||
} |
||||
|
||||
int Arpeggiator::getArpMode() const |
||||
{ |
||||
return arpMode; |
||||
} |
||||
|
||||
int Arpeggiator::getOctaveMode() const |
||||
{ |
||||
return octaveMode; |
||||
} |
||||
|
||||
bool Arpeggiator::getPanic() const |
||||
{ |
||||
return panic; |
||||
} |
||||
|
||||
void Arpeggiator::transmitHostInfo(const bool playing, const float beatsPerBar, |
||||
const int beat, const float barBeat, const double bpm) |
||||
{ |
||||
clock.transmitHostInfo(playing, beatsPerBar, beat, barBeat, bpm); |
||||
this->barBeat = barBeat; |
||||
} |
||||
|
||||
void Arpeggiator::reset() |
||||
{ |
||||
clock.reset(); |
||||
clock.setNumBarsElapsed(0); |
||||
|
||||
for (unsigned a = 0; a < NUM_ARP_MODES; a++) { |
||||
arpPattern[arpMode]->reset(); |
||||
} |
||||
for (unsigned o = 0; o < NUM_OCTAVE_MODES; o++) { |
||||
octavePattern[o]->reset(); |
||||
} |
||||
|
||||
activeNotesIndex = 0; |
||||
firstNoteTimer = 0; |
||||
notePlayed = 0; |
||||
activeNotes = 0; |
||||
notesPressed = 0; |
||||
activeNotesBypassed = 0; |
||||
latchPlaying = false; |
||||
firstNote = false; |
||||
first = true; |
||||
|
||||
for (unsigned i = 0; i < NUM_VOICES; i++) { |
||||
midiNotes[i][MIDI_NOTE] = EMPTY_SLOT; |
||||
midiNotes[i][MIDI_CHANNEL] = 0; |
||||
} |
||||
} |
||||
|
||||
void Arpeggiator::emptyMidiBuffer() |
||||
{ |
||||
midiHandler.emptyMidiBuffer(); |
||||
} |
||||
|
||||
void Arpeggiator::allNotesOff() |
||||
{ |
||||
for (unsigned i = 0; i < NUM_VOICES; i++) { |
||||
midiNotesBypassed[i] = EMPTY_SLOT; |
||||
} |
||||
notesPressed = 0; |
||||
activeNotes = 0; |
||||
reset(); |
||||
} |
||||
|
||||
struct MidiBuffer Arpeggiator::getMidiBuffer() |
||||
{ |
||||
return midiHandler.getMidiBuffer(); |
||||
} |
||||
|
||||
void Arpeggiator::process(const MidiEvent* events, uint32_t eventCount, uint32_t n_frames) |
||||
{ |
||||
struct MidiEvent midiEvent; |
||||
struct MidiEvent midiThroughEvent; |
||||
|
||||
if (!arpEnabled && !latchMode) { |
||||
|
||||
reset(); |
||||
|
||||
for (unsigned clear_notes = 0; clear_notes < NUM_VOICES; clear_notes++) { |
||||
midiNotes[clear_notes][MIDI_NOTE] = EMPTY_SLOT; |
||||
midiNotes[clear_notes][MIDI_CHANNEL] = 0; |
||||
} |
||||
} |
||||
|
||||
if (!latchMode && previousLatch && notesPressed <= 0) { |
||||
reset(); |
||||
} |
||||
if (latchMode != previousLatch) { |
||||
previousLatch = latchMode; |
||||
} |
||||
|
||||
if (panic) { |
||||
reset(); |
||||
panic = false; |
||||
} |
||||
|
||||
for (uint32_t i=0; i<eventCount; ++i) { |
||||
|
||||
uint8_t status = events[i].data[0] & 0xF0; |
||||
|
||||
uint8_t midiNote = events[i].data[1]; |
||||
uint8_t noteToFind; |
||||
uint8_t foundNote; |
||||
size_t searchNote; |
||||
|
||||
if (arpEnabled) { |
||||
|
||||
if (!latchPlaying && (midiNote == 0x7b && events[i].size == 3)) { |
||||
allNotesOff(); |
||||
} |
||||
|
||||
midiNotesCopied = false; |
||||
|
||||
bool voiceFound; |
||||
bool pitchFound; |
||||
bool noteOffFoundInBuffer; |
||||
size_t findFreeVoice; |
||||
size_t findActivePitch; |
||||
|
||||
uint8_t channel = events[i].data[0] & 0x0F; |
||||
|
||||
switch(status) { |
||||
case MIDI_NOTEON: |
||||
if (activeNotes > NUM_VOICES - 1) { |
||||
reset(); |
||||
} else { |
||||
if (first) { |
||||
firstNote = true; |
||||
} |
||||
if (notesPressed == 0) { |
||||
if (!latchPlaying) { //TODO check if there needs to be an exception when using sync
|
||||
octavePattern[octaveMode]->reset(); |
||||
clock.reset(); |
||||
notePlayed = 0; |
||||
} |
||||
if (latchMode) { |
||||
latchPlaying = true; |
||||
activeNotes = 0; |
||||
for (unsigned i = 0; i < NUM_VOICES; i++) { |
||||
midiNotes[i][MIDI_NOTE] = EMPTY_SLOT; |
||||
midiNotes[i][MIDI_CHANNEL] = 0; |
||||
} |
||||
} |
||||
resetPattern = true; |
||||
} |
||||
|
||||
findFreeVoice = 0; |
||||
findActivePitch = 0; |
||||
voiceFound = false; |
||||
pitchFound = false; |
||||
|
||||
while (findActivePitch < NUM_VOICES && !pitchFound) |
||||
{ |
||||
if (midiNotes[findActivePitch][MIDI_NOTE] == (uint32_t)midiNote) { |
||||
pitchFound = true; |
||||
} |
||||
findActivePitch++; |
||||
} |
||||
|
||||
if (!pitchFound) { |
||||
while (findFreeVoice < NUM_VOICES && !voiceFound) |
||||
{ |
||||
if (midiNotes[findFreeVoice][MIDI_NOTE] == EMPTY_SLOT) { |
||||
midiNotes[findFreeVoice][MIDI_NOTE] = midiNote; |
||||
midiNotes[findFreeVoice][MIDI_CHANNEL] = channel; |
||||
voiceFound = true; |
||||
} |
||||
findFreeVoice++; |
||||
} |
||||
notesPressed++; |
||||
activeNotes++; |
||||
} |
||||
|
||||
if (arpMode != ARP_PLAYED) |
||||
utils.quicksort(midiNotes, 0, NUM_VOICES - 1); |
||||
if (midiNote < midiNotes[notePlayed - 1][MIDI_NOTE] && notePlayed > 0) { |
||||
notePlayed++; |
||||
} |
||||
} |
||||
break; |
||||
case MIDI_NOTEOFF: |
||||
searchNote = 0; |
||||
foundNote = 0; |
||||
noteOffFoundInBuffer = false; |
||||
noteToFind = midiNote; |
||||
|
||||
if (!latchMode) { |
||||
latchPlaying = false; |
||||
} else { |
||||
latchPlaying = true; |
||||
} |
||||
|
||||
while (searchNote < NUM_VOICES) |
||||
{ |
||||
if (midiNotes[searchNote][MIDI_NOTE] == noteToFind) |
||||
{ |
||||
foundNote = searchNote; |
||||
noteOffFoundInBuffer = true; |
||||
searchNote = NUM_VOICES; |
||||
} |
||||
searchNote++; |
||||
} |
||||
|
||||
if (noteOffFoundInBuffer) { |
||||
|
||||
notesPressed = (notesPressed > 0) ? notesPressed - 1 : 0; |
||||
|
||||
if (!latchPlaying) { |
||||
activeNotes = notesPressed; |
||||
} |
||||
|
||||
if (!latchMode) { |
||||
midiNotes[foundNote][MIDI_NOTE] = EMPTY_SLOT; |
||||
midiNotes[foundNote][MIDI_CHANNEL] = 0; |
||||
if (arpMode != ARP_PLAYED) |
||||
utils.quicksort(midiNotes, 0, NUM_VOICES - 1); |
||||
} |
||||
} else { |
||||
midiThroughEvent.frame = events[i].frame; |
||||
midiThroughEvent.size = events[i].size; |
||||
for (unsigned d = 0; d < midiThroughEvent.size; d++) { |
||||
midiThroughEvent.data[d] = events[i].data[d]; |
||||
} |
||||
midiHandler.appendMidiThroughMessage(midiThroughEvent); |
||||
} |
||||
if (activeNotes == 0 && !latchPlaying && !latchMode) { |
||||
reset(); |
||||
} |
||||
break; |
||||
default: |
||||
midiThroughEvent.frame = events[i].frame; |
||||
midiThroughEvent.size = events[i].size; |
||||
for (unsigned d = 0; d < midiThroughEvent.size; d++) { |
||||
midiThroughEvent.data[d] = events[i].data[d]; |
||||
} |
||||
midiHandler.appendMidiThroughMessage(midiThroughEvent); |
||||
break; |
||||
} |
||||
} else { //if arpeggiator is off
|
||||
|
||||
if (!midiNotesCopied) { |
||||
for (unsigned b = 0; b < NUM_VOICES; b++) { |
||||
midiNotesBypassed[b] = midiNotes[b][MIDI_NOTE]; |
||||
} |
||||
midiNotesCopied = true; |
||||
} |
||||
|
||||
if (latchMode) { |
||||
|
||||
uint8_t noteToFind = midiNote; |
||||
size_t searchNote = 0; |
||||
|
||||
switch (status) |
||||
{ |
||||
case MIDI_NOTEOFF: |
||||
while (searchNote < NUM_VOICES) |
||||
{ |
||||
if (midiNotesBypassed[searchNote] == noteToFind) { |
||||
midiNotesBypassed[searchNote] = EMPTY_SLOT; |
||||
searchNote = NUM_VOICES; |
||||
notesPressed = (notesPressed > 0) ? notesPressed - 1 : 0; |
||||
} |
||||
searchNote++; |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if (midiNote == 0x7b && events[i].size == 3) { |
||||
allNotesOff(); |
||||
} |
||||
//send MIDI message through
|
||||
midiHandler.appendMidiThroughMessage(events[i]); |
||||
first = true; |
||||
} |
||||
} |
||||
|
||||
arpPattern[arpMode]->setPatternSize(activeNotes); |
||||
|
||||
int patternSize; |
||||
|
||||
switch (arpMode) |
||||
{ |
||||
case ARP_UP_DOWN: |
||||
patternSize = (activeNotes >= 3) ? activeNotes + (activeNotes - 2) : activeNotes; |
||||
break; |
||||
case ARP_UP_DOWN_ALT: |
||||
patternSize = (activeNotes >= 3) ? activeNotes * 2 : activeNotes; |
||||
break; |
||||
default: |
||||
patternSize = activeNotes; |
||||
break; |
||||
} |
||||
|
||||
switch (octaveMode) |
||||
{ |
||||
case ONE_OCT_UP_PER_CYCLE: |
||||
octavePattern[octaveMode]->setPatternSize(patternSize); |
||||
octavePattern[octaveMode]->setCycleRange(octaveSpread); |
||||
break; |
||||
default: |
||||
octavePattern[octaveMode]->setPatternSize(octaveSpread); |
||||
break; |
||||
} |
||||
|
||||
for (unsigned s = 0; s < n_frames; s++) { |
||||
|
||||
bool timeOut = (firstNoteTimer > (int)timeOutTime) ? false : true; |
||||
|
||||
if (firstNote) { |
||||
clock.closeGate(); //close gate to prevent opening before timeOut
|
||||
firstNoteTimer++; |
||||
} |
||||
|
||||
if (clock.getSyncMode() <= 1 && first) { |
||||
clock.setPos(0); |
||||
clock.reset(); |
||||
} |
||||
|
||||
clock.tick(); |
||||
|
||||
if ((clock.getGate() && !timeOut)) { |
||||
|
||||
if (arpEnabled) { |
||||
|
||||
if (resetPattern) { |
||||
octavePattern[octaveMode]->reset(); |
||||
if (octaveMode == ARP_DOWN) { |
||||
octavePattern[octaveMode]->setStep(activeNotes - 1); //TODO maybe put this in reset()
|
||||
} |
||||
|
||||
arpPattern[arpMode]->reset(); |
||||
if (arpMode == ARP_DOWN) { |
||||
arpPattern[arpMode]->setStep(activeNotes - 1); |
||||
} |
||||
|
||||
resetPattern = false; |
||||
|
||||
notePlayed = arpPattern[arpMode]->getStep(); |
||||
} |
||||
|
||||
if (first) { |
||||
//send all notes off, on current active MIDI channel
|
||||
midiEvent.size = 3; |
||||
midiEvent.data[2] = 0; |
||||
|
||||
midiEvent.frame = s; |
||||
midiEvent.data[0] = 0xb0 | midiNotes[notePlayed][MIDI_CHANNEL]; |
||||
midiEvent.data[1] = 0x40; // sustain pedal
|
||||
midiHandler.appendMidiMessage(midiEvent); |
||||
midiEvent.data[1] = 0x7b; // all notes off
|
||||
midiHandler.appendMidiMessage(midiEvent); |
||||
|
||||
first = false; |
||||
} |
||||
} |
||||
|
||||
size_t searchedVoices = 0; |
||||
bool noteFound = false; |
||||
|
||||
while (!noteFound && searchedVoices < NUM_VOICES && activeNotes > 0 && arpEnabled) |
||||
{ |
||||
notePlayed = (notePlayed < 0) ? 0 : notePlayed; |
||||
|
||||
if (midiNotes[notePlayed][MIDI_NOTE] > 0 |
||||
&& midiNotes[notePlayed][MIDI_NOTE] < 128) |
||||
{ |
||||
//create MIDI note on message
|
||||
uint8_t midiNote = midiNotes[notePlayed][MIDI_NOTE]; |
||||
uint8_t channel = midiNotes[notePlayed][MIDI_CHANNEL]; |
||||
|
||||
if (arpEnabled) { |
||||
|
||||
uint8_t octave = octavePattern[octaveMode]->getStep() * 12; |
||||
octavePattern[octaveMode]->goToNextStep(); |
||||
|
||||
midiNote = midiNote + octave; |
||||
|
||||
midiEvent.frame = s; |
||||
midiEvent.size = 3; |
||||
midiEvent.data[0] = MIDI_NOTEON | channel; |
||||
midiEvent.data[1] = midiNote; |
||||
midiEvent.data[2] = velocity; |
||||
|
||||
midiHandler.appendMidiMessage(midiEvent); |
||||
|
||||
noteOffBuffer[activeNotesIndex][MIDI_NOTE] = (uint32_t)midiNote; |
||||
noteOffBuffer[activeNotesIndex][MIDI_CHANNEL] = (uint32_t)channel; |
||||
activeNotesIndex = (activeNotesIndex + 1) % NUM_NOTE_OFF_SLOTS; |
||||
noteFound = true; |
||||
firstNote = false; |
||||
} |
||||
} |
||||
arpPattern[arpMode]->goToNextStep(); |
||||
notePlayed = arpPattern[arpMode]->getStep(); |
||||
searchedVoices++; |
||||
} |
||||
clock.closeGate(); |
||||
} |
||||
|
||||
for (size_t i = 0; i < NUM_NOTE_OFF_SLOTS; i++) { |
||||
if (noteOffBuffer[i][MIDI_NOTE] != EMPTY_SLOT) { |
||||
noteOffBuffer[i][TIMER] += 1; |
||||
if (noteOffBuffer[i][TIMER] > static_cast<uint32_t>(clock.getPeriod() * noteLength)) { |
||||
midiEvent.frame = s; |
||||
midiEvent.size = 3; |
||||
midiEvent.data[0] = MIDI_NOTEOFF | noteOffBuffer[i][MIDI_CHANNEL]; |
||||
midiEvent.data[1] = static_cast<uint8_t>(noteOffBuffer[i][MIDI_NOTE]); |
||||
midiEvent.data[2] = 0; |
||||
|
||||
midiHandler.appendMidiMessage(midiEvent); |
||||
|
||||
noteOffBuffer[i][MIDI_NOTE] = EMPTY_SLOT; |
||||
noteOffBuffer[i][MIDI_CHANNEL] = 0; |
||||
noteOffBuffer[i][TIMER] = 0; |
||||
|
||||
} |
||||
} |
||||
} |
||||
} |
||||
midiHandler.mergeBuffers(); |
||||
} |
||||
@ -0,0 +1,122 @@ |
||||
#ifndef _H_ARPEGGIATOR_ |
||||
#define _H_ARPEGGIATOR_ |
||||
|
||||
#include <cstdint> |
||||
|
||||
#include "common/commons.h" |
||||
#include "common/clock.hpp" |
||||
#include "common/pattern.hpp" |
||||
#include "common/midiHandler.hpp" |
||||
#include "utils.hpp" |
||||
|
||||
#define NUM_VOICES 32 |
||||
#define NUM_NOTE_OFF_SLOTS 32 |
||||
#define PLUGIN_URI "http://moddevices.com/plugins/mod-devel/arpeggiator"
|
||||
|
||||
#define MIDI_NOTEOFF 0x80 |
||||
#define MIDI_NOTEON 0x90 |
||||
|
||||
#define MIDI_NOTE 0 |
||||
#define MIDI_CHANNEL 1 |
||||
#define TIMER 2 |
||||
|
||||
#define NUM_ARP_MODES 6 |
||||
#define NUM_OCTAVE_MODES 5 |
||||
|
||||
#define NUM_MIDI_CHANNELS 16 |
||||
|
||||
#define ONE_OCT_UP_PER_CYCLE 4 |
||||
|
||||
class Arpeggiator { |
||||
public: |
||||
enum ArpModes { |
||||
ARP_UP = 0, |
||||
ARP_DOWN, |
||||
ARP_UP_DOWN, |
||||
ARP_UP_DOWN_ALT, |
||||
ARP_PLAYED, |
||||
ARP_RANDOM |
||||
}; |
||||
Arpeggiator(); |
||||
~Arpeggiator(); |
||||
void setArpEnabled(bool arpEnabled); |
||||
void setLatchMode(bool latchMode); |
||||
void setSampleRate(float sampleRate); |
||||
void setSyncMode(int mode); |
||||
void setBpm(double bpm); |
||||
void setDivision(int division); |
||||
void setVelocity(uint8_t velocity); |
||||
void setNoteLength(float noteLength); |
||||
void setOctaveSpread(int octaveSpread); |
||||
void setArpMode(int arpMode); |
||||
void setOctaveMode(int octaveMode); |
||||
void setPanic(bool panic); |
||||
bool getArpEnabled() const; |
||||
bool getLatchMode() const; |
||||
float getSampleRate() const; |
||||
int getSyncMode() const; |
||||
float getBpm() const; |
||||
int getDivision() const; |
||||
uint8_t getVelocity() const; |
||||
float getNoteLength() const; |
||||
int getOctaveSpread() const; |
||||
int getArpMode() const; |
||||
int getOctaveMode() const; |
||||
bool getPanic() const; |
||||
void transmitHostInfo(const bool playing, const float beatsPerBar, |
||||
const int beat, const float barBeat, const double bpm); |
||||
void reset(); |
||||
void emptyMidiBuffer(); |
||||
void allNotesOff(); |
||||
struct MidiBuffer getMidiBuffer(); |
||||
void process(const MidiEvent* event, uint32_t eventCount, uint32_t n_frames); |
||||
private: |
||||
uint8_t midiNotes[NUM_VOICES][2]; |
||||
uint8_t midiNotesBypassed[NUM_VOICES]; |
||||
uint32_t noteOffBuffer[NUM_NOTE_OFF_SLOTS][3]; |
||||
|
||||
int notesPressed; |
||||
int activeNotes; |
||||
int notePlayed; |
||||
|
||||
int octaveMode; |
||||
int octaveSpread; |
||||
int arpMode; |
||||
|
||||
float noteLength; |
||||
|
||||
uint8_t pitch; |
||||
uint8_t previousMidiNote; |
||||
uint8_t velocity; |
||||
int previousSyncMode; |
||||
int activeNotesIndex; |
||||
int activeNotesBypassed; |
||||
int timeOutTime; |
||||
int firstNoteTimer; |
||||
float barBeat; |
||||
|
||||
bool pluginEnabled; |
||||
bool first; |
||||
bool arpEnabled; |
||||
bool latchMode; |
||||
bool previousLatch; |
||||
bool latchPlaying; |
||||
bool trigger; |
||||
bool firstNote; |
||||
bool quantizedStart; |
||||
bool resetPattern; |
||||
bool midiNotesCopied; |
||||
bool panic; |
||||
|
||||
int division; |
||||
float sampleRate; |
||||
double bpm; |
||||
|
||||
ArpUtils utils; |
||||
Pattern **arpPattern; |
||||
Pattern **octavePattern; |
||||
MidiHandler midiHandler; |
||||
PluginClock clock; |
||||
}; |
||||
|
||||
#endif //_H_ARPEGGIATOR_
|
||||
@ -0,0 +1,241 @@ |
||||
#include "clock.hpp" |
||||
|
||||
PluginClock::PluginClock() : |
||||
gate(false), |
||||
trigger(false), |
||||
beatSync(true), |
||||
phaseReset(false), |
||||
playing(false), |
||||
previousPlaying(false), |
||||
endOfBar(false), |
||||
init(false), |
||||
period(0), |
||||
halfWavelength(0), |
||||
quarterWaveLength(0), |
||||
pos(0), |
||||
beatsPerBar(1.0), |
||||
bpm(120.0), |
||||
internalBpm(120.0), |
||||
previousBpm(0), |
||||
sampleRate(48000.0), |
||||
division(1), |
||||
hostBarBeat(0.0), |
||||
beatTick(0.0), |
||||
syncMode(1), |
||||
previousSyncMode(0), |
||||
hostTick(0), |
||||
hostBeat(0), |
||||
barLength(4), |
||||
numBarsElapsed(0), |
||||
previousBeat(0), |
||||
arpMode(0) |
||||
{ |
||||
} |
||||
|
||||
PluginClock::~PluginClock() |
||||
{ |
||||
} |
||||
|
||||
void PluginClock::transmitHostInfo(const bool playing, const float beatsPerBar, |
||||
const int hostBeat, const float hostBarBeat, const float hostBpm) |
||||
{ |
||||
this->beatsPerBar = beatsPerBar; |
||||
this->hostBeat = hostBeat; |
||||
this->hostBarBeat = hostBarBeat; |
||||
this->hostBpm = hostBpm; |
||||
this->playing = playing; |
||||
|
||||
if (playing && !previousPlaying && beatSync) { |
||||
syncClock(); |
||||
} |
||||
if (playing != previousPlaying) { |
||||
previousPlaying = playing; |
||||
} |
||||
|
||||
if (!init) { |
||||
calcPeriod(); |
||||
init = true; |
||||
} |
||||
} |
||||
|
||||
void PluginClock::setSyncMode(int mode) |
||||
{ |
||||
switch (mode) |
||||
{ |
||||
case FREE_RUNNING: |
||||
beatSync = false; |
||||
break; |
||||
case HOST_BPM_SYNC: |
||||
beatSync = false; |
||||
break; |
||||
case HOST_QUANTIZED_SYNC: |
||||
beatSync = true; |
||||
break; |
||||
} |
||||
|
||||
this->syncMode = mode; |
||||
} |
||||
|
||||
void PluginClock::setInternalBpmValue(float internalBpm) |
||||
{ |
||||
this->internalBpm = internalBpm; |
||||
} |
||||
|
||||
void PluginClock::setBpm(float bpm) |
||||
{ |
||||
this->bpm = bpm; |
||||
calcPeriod(); |
||||
} |
||||
|
||||
void PluginClock::setSampleRate(float sampleRate) |
||||
{ |
||||
this->sampleRate = sampleRate; |
||||
calcPeriod(); |
||||
} |
||||
|
||||
void PluginClock::setDivision(int setDivision) |
||||
{ |
||||
this->division = setDivision; |
||||
this->divisionValue = divisionValues[setDivision]; |
||||
|
||||
calcPeriod(); |
||||
} |
||||
|
||||
void PluginClock::syncClock() |
||||
{ |
||||
pos = static_cast<uint32_t>(fmod(sampleRate * (60.0f / bpm) * (hostBarBeat + (numBarsElapsed * beatsPerBar)), sampleRate * (60.0f / (bpm * (divisionValue / 2.0f))))); |
||||
} |
||||
|
||||
void PluginClock::setPos(uint32_t pos) |
||||
{ |
||||
this->pos = pos; |
||||
} |
||||
|
||||
void PluginClock::setNumBarsElapsed(uint32_t numBarsElapsed) |
||||
{ |
||||
this->numBarsElapsed = numBarsElapsed; |
||||
} |
||||
|
||||
void PluginClock::calcPeriod() |
||||
{ |
||||
period = static_cast<uint32_t>(sampleRate * (60.0f / (bpm * (divisionValue / 2.0f)))); |
||||
halfWavelength = static_cast<uint32_t>(period / 2.0f); |
||||
quarterWaveLength = static_cast<uint32_t>(halfWavelength / 2.0f); |
||||
period = (period <= 0) ? 1 : period; |
||||
} |
||||
|
||||
void PluginClock::closeGate() |
||||
{ |
||||
gate = false; |
||||
} |
||||
|
||||
void PluginClock::reset() |
||||
{ |
||||
trigger = false; |
||||
} |
||||
|
||||
float PluginClock::getSampleRate() const |
||||
{ |
||||
return sampleRate; |
||||
} |
||||
|
||||
bool PluginClock::getGate() const |
||||
{ |
||||
return gate; |
||||
} |
||||
|
||||
int PluginClock::getSyncMode() const |
||||
{ |
||||
return syncMode; |
||||
} |
||||
|
||||
float PluginClock::getInternalBpmValue() const |
||||
{ |
||||
return internalBpm; |
||||
} |
||||
|
||||
int PluginClock::getDivision() const |
||||
{ |
||||
return division; |
||||
} |
||||
|
||||
uint32_t PluginClock::getPeriod() const |
||||
{ |
||||
return period; |
||||
} |
||||
|
||||
uint32_t PluginClock::getPos() const |
||||
{ |
||||
return pos; |
||||
} |
||||
|
||||
void PluginClock::tick() |
||||
{ |
||||
int beat = static_cast<int>(hostBarBeat); |
||||
|
||||
if (beatsPerBar <= 1) { |
||||
if (hostBarBeat > 0.99 && !endOfBar) { |
||||
endOfBar = true; |
||||
} |
||||
else if (hostBarBeat < 0.1 && endOfBar) { |
||||
numBarsElapsed++; |
||||
endOfBar = false; |
||||
} |
||||
} else { |
||||
if (beat != previousBeat) { |
||||
numBarsElapsed = (beat == 0) ? numBarsElapsed + 1 : numBarsElapsed; |
||||
previousBeat = beat; |
||||
} |
||||
} |
||||
|
||||
float threshold = 0.009; //TODO might not be needed
|
||||
|
||||
switch (syncMode) |
||||
{ |
||||
case FREE_RUNNING: |
||||
if ((internalBpm != previousBpm) || (syncMode != previousSyncMode)) { |
||||
setBpm(internalBpm); |
||||
previousBpm = internalBpm; |
||||
previousSyncMode = syncMode; |
||||
} |
||||
break; |
||||
case HOST_BPM_SYNC: |
||||
if ((hostBpm != previousBpm && (fabs(previousBpm - hostBpm) > threshold)) || (syncMode != previousSyncMode)) { |
||||
setBpm(hostBpm); |
||||
previousBpm = hostBpm; |
||||
previousSyncMode = syncMode; |
||||
} |
||||
break; |
||||
case HOST_QUANTIZED_SYNC: //TODO fix this duplicate
|
||||
if ((hostBpm != previousBpm && (fabs(previousBpm - hostBpm) > threshold)) || (syncMode != previousSyncMode)) { |
||||
setBpm(hostBpm); |
||||
if (playing) { |
||||
syncClock(); |
||||
} |
||||
previousBpm = hostBpm; |
||||
previousSyncMode = syncMode; |
||||
} |
||||
break; |
||||
} |
||||
|
||||
if (pos > period) { |
||||
pos = 0; |
||||
} |
||||
|
||||
if (pos < quarterWaveLength && !trigger) { |
||||
gate = true; |
||||
trigger = true; |
||||
} else if (pos > halfWavelength && trigger) { |
||||
if (playing && beatSync) { |
||||
syncClock(); |
||||
} |
||||
trigger = false; |
||||
} |
||||
|
||||
if (playing && beatSync) { |
||||
syncClock(); //hard-sync to host position
|
||||
} |
||||
else if (!beatSync) { |
||||
pos++; |
||||
} |
||||
} |
||||
@ -0,0 +1,80 @@ |
||||
#ifndef _H_CLOCK_ |
||||
#define _H_CLOCK_ |
||||
|
||||
#include <cstdint> |
||||
#include <math.h> |
||||
|
||||
enum SyncMode { |
||||
FREE_RUNNING = 0, |
||||
HOST_BPM_SYNC, |
||||
HOST_QUANTIZED_SYNC |
||||
}; |
||||
|
||||
class PluginClock { |
||||
public: |
||||
PluginClock(); |
||||
~PluginClock(); |
||||
void transmitHostInfo(const bool playing, const float beatstPerBar, |
||||
const int hostBeat, const float hostBarBeat, const float hostBpm); |
||||
void setSampleRate(float sampleRate); |
||||
void setSyncMode(int mode); |
||||
void setInternalBpmValue(float internalBpm); |
||||
void setDivision(int division); |
||||
void syncClock(); |
||||
void setPos(uint32_t pos); |
||||
void setNumBarsElapsed(uint32_t numBarsElapsed); |
||||
void calcPeriod(); |
||||
void closeGate(); |
||||
void reset(); |
||||
bool getGate() const; |
||||
float getSampleRate() const; |
||||
int getSyncMode() const; |
||||
float getInternalBpmValue() const; |
||||
int getDivision() const; |
||||
uint32_t getPeriod() const; |
||||
uint32_t getPos() const; |
||||
void tick(); |
||||
|
||||
private: |
||||
void setBpm(float bpm); |
||||
|
||||
bool gate; |
||||
bool trigger; |
||||
bool beatSync; |
||||
bool phaseReset; |
||||
bool playing; |
||||
bool previousPlaying; |
||||
bool endOfBar; |
||||
bool init; |
||||
|
||||
uint32_t period; |
||||
uint32_t halfWavelength; |
||||
uint32_t quarterWaveLength; |
||||
uint32_t pos; |
||||
|
||||
float beatsPerBar; |
||||
float bpm; |
||||
float internalBpm; |
||||
float hostBpm; |
||||
float previousBpm; |
||||
float sampleRate; |
||||
int division; |
||||
float divisionValue; |
||||
|
||||
float hostBarBeat; |
||||
float beatTick; |
||||
int syncMode; |
||||
int previousSyncMode; |
||||
int hostTick; |
||||
int hostBeat; |
||||
int barLength; |
||||
int numBarsElapsed; |
||||
int previousBeat; |
||||
|
||||
int arpMode; |
||||
|
||||
// "1/1" "1/2" "1/3" "1/4" "1/4." "1/4T" "1/8" "1/8." "1/8T" "1/16" "1/16." "1/16T" "1/32"
|
||||
float divisionValues[13] {0.5, 1, 1.5, 2.0, 2.66666, 3.0, 4.0, 5.33333, 6.0, 8.0, 10.66666, 12.0, 16.0}; |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,33 @@ |
||||
#ifndef _H_COMMONS_ |
||||
#define _H_COMMONS_ |
||||
|
||||
#include <stdint.h> |
||||
|
||||
/**
|
||||
MIDI event. |
||||
*/ |
||||
struct MidiEvent { |
||||
/**
|
||||
Size of internal data. |
||||
*/ |
||||
static const uint32_t kDataSize = 4; |
||||
|
||||
/**
|
||||
Time offset in frames. |
||||
*/ |
||||
uint32_t frame; |
||||
|
||||
/**
|
||||
Number of bytes used. |
||||
*/ |
||||
uint32_t size; |
||||
|
||||
/**
|
||||
MIDI data.@n |
||||
If size > kDataSize, dataExt is used (otherwise null). |
||||
*/ |
||||
uint8_t data[kDataSize]; |
||||
const uint8_t* dataExt; |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,65 @@ |
||||
#include "midiHandler.hpp" |
||||
#include <stdio.h> |
||||
|
||||
MidiHandler::MidiHandler() |
||||
{ |
||||
printf("MidiHandler constructor\n"); |
||||
printf("MidiEvent size: %d\n", sizeof(MidiEvent)); |
||||
fflush(NULL); |
||||
/*
|
||||
memset(buffer.bufferedEvents, 0, MIDI_BUFFER_SIZE * sizeof(MidiEvent)); |
||||
memset(buffer.bufferedMidiThroughEvents, 0, MIDI_BUFFER_SIZE * sizeof(MidiEvent)); |
||||
memset(buffer.midiOutputBuffer, 0, MIDI_BUFFER_SIZE * sizeof(MidiEvent)); |
||||
*/ |
||||
for (unsigned i = 0; i < MIDI_BUFFER_SIZE; i++) { |
||||
printf("i: %d\n", i); |
||||
fflush(NULL); |
||||
for (unsigned x = 0; x < buffer.bufferedEvents[i].kDataSize; i++) { |
||||
printf("x: %d\n", x); |
||||
fflush(NULL); |
||||
/*
|
||||
buffer.bufferedEvents[i].data[x] = 0; |
||||
buffer.bufferedMidiThroughEvents[i].data[x] = 0; |
||||
buffer.midiOutputBuffer[i].data[x] = 0; |
||||
*/ |
||||
} |
||||
} |
||||
emptyMidiBuffer(); |
||||
//printf("buffer.bufferedEvents: %d\n", buffer.bufferedEvents[0].data);
|
||||
//fflush(NULL);
|
||||
} |
||||
|
||||
MidiHandler::~MidiHandler() |
||||
{ |
||||
} |
||||
|
||||
void MidiHandler::emptyMidiBuffer() |
||||
{ |
||||
buffer.numBufferedEvents = 0; |
||||
buffer.numBufferedThroughEvents = 0; |
||||
} |
||||
|
||||
void MidiHandler::appendMidiMessage(MidiEvent event) |
||||
{ |
||||
buffer.bufferedEvents[buffer.numBufferedEvents] = event; |
||||
buffer.numBufferedEvents = (buffer.numBufferedEvents + 1) % buffer.maxBufferSize; |
||||
} |
||||
|
||||
void MidiHandler::appendMidiThroughMessage(MidiEvent event) |
||||
{ |
||||
buffer.bufferedMidiThroughEvents[buffer.numBufferedThroughEvents] = event; |
||||
buffer.numBufferedThroughEvents = (buffer.numBufferedThroughEvents + 1) % buffer.maxBufferSize; |
||||
} |
||||
|
||||
void MidiHandler::mergeBuffers() |
||||
{ |
||||
for (unsigned e = 0; e < buffer.numBufferedThroughEvents; e++) { |
||||
buffer.bufferedEvents[e + buffer.numBufferedEvents] = buffer.bufferedMidiThroughEvents[e]; |
||||
} |
||||
} |
||||
|
||||
struct MidiBuffer MidiHandler::getMidiBuffer() |
||||
{ |
||||
mergeBuffers(); |
||||
return buffer; |
||||
} |
||||
@ -0,0 +1,60 @@ |
||||
#ifndef _H_MIDI_HANDLER_ |
||||
#define _H_MIDI_HANDLER_ |
||||
|
||||
#include "commons.h" |
||||
|
||||
#include <arm_math.h> |
||||
#include <cstdint> |
||||
|
||||
#define MIDI_BUFFER_SIZE 2048 |
||||
#define EMPTY_SLOT 200 |
||||
|
||||
#define MIDI_NOTEOFF 0x80 |
||||
#define MIDI_NOTEON 0x90 |
||||
#define MIDI_SYSTEM_EXCLUSIVE 0xF0 |
||||
#define MIDI_MTC_QUARTER_FRAME 0xF1 |
||||
#define MIDI_SONG_POSITION_POINTER 0xF2 |
||||
#define MIDI_SONG_SELECT 0xF3 |
||||
#define MIDI_UNDEFINED_F4 0xF4 |
||||
#define MIDI_UNDEFINED_F5 0xF5 |
||||
#define MIDI_TUNE_REQUEST 0xF6 |
||||
#define MIDI_END_OF_EXCLUSIVE 0xF7 |
||||
#define MIDI_TIMING_CLOCK 0xF8 |
||||
#define MIDI_UNDEFINED_F9 0xF9 |
||||
#define MIDI_START 0xFA |
||||
#define MIDI_CONTINUE 0xFB |
||||
#define MIDI_STOP 0xFC |
||||
#define MIDI_UNDEFINED_FD 0xFD |
||||
#define MIDI_ACTIVE_SENSING 0xFE |
||||
#define MIDI_SYSTEM_RESET 0xFF |
||||
|
||||
struct MidiBuffer { |
||||
unsigned maxBufferSize = MIDI_BUFFER_SIZE; |
||||
|
||||
MidiEvent bufferedEvents[MIDI_BUFFER_SIZE]; |
||||
unsigned numBufferedEvents; |
||||
|
||||
MidiEvent bufferedMidiThroughEvents[MIDI_BUFFER_SIZE]; |
||||
unsigned numBufferedThroughEvents; |
||||
|
||||
MidiEvent midiOutputBuffer[MIDI_BUFFER_SIZE]; |
||||
unsigned numOutputEvents; |
||||
}; |
||||
|
||||
class MidiHandler { |
||||
public: |
||||
MidiHandler(); |
||||
~MidiHandler(); |
||||
void emptyMidiBuffer(); |
||||
void appendMidiMessage(MidiEvent event); |
||||
void appendMidiThroughMessage(MidiEvent event); |
||||
void resetBuffer(); |
||||
int getNumEvents(); |
||||
void mergeBuffers(); |
||||
MidiEvent getMidiEvent(int index); |
||||
struct MidiBuffer getMidiBuffer(); |
||||
private: |
||||
MidiBuffer buffer; |
||||
}; |
||||
|
||||
#endif //_H_MIDI_HANDLER_
|
||||
@ -0,0 +1,242 @@ |
||||
#include "pattern.hpp" |
||||
|
||||
Pattern::Pattern() : size(1), step(0), range(1) |
||||
{ |
||||
} |
||||
|
||||
Pattern::~Pattern() |
||||
{ |
||||
} |
||||
|
||||
void Pattern::setPatternSize(int size) |
||||
{ |
||||
this->size = size; |
||||
} |
||||
|
||||
void Pattern::setStep(int step) |
||||
{ |
||||
this->step = step; |
||||
} |
||||
|
||||
void Pattern::setCycleRange(int range) |
||||
{ |
||||
this->range = range; |
||||
} |
||||
|
||||
int Pattern::getSize() |
||||
{ |
||||
return size; |
||||
} |
||||
|
||||
int Pattern::getStep() |
||||
{ |
||||
return step; |
||||
} |
||||
|
||||
int Pattern::getDirection() |
||||
{ |
||||
return direction; |
||||
} |
||||
|
||||
PatternUp::PatternUp() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternUp::~PatternUp() |
||||
{ |
||||
} |
||||
|
||||
void PatternUp::setDirection(int direction) |
||||
{ |
||||
this->direction = abs(direction); |
||||
} |
||||
|
||||
void PatternUp::reset() |
||||
{ |
||||
step = 0; |
||||
direction = 1; |
||||
} |
||||
|
||||
void PatternUp::goToNextStep() |
||||
{ |
||||
if (size > 0) { |
||||
step = (step + 1) % size; |
||||
} else { |
||||
step = 0; |
||||
} |
||||
} |
||||
|
||||
PatternDown::PatternDown() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternDown::~PatternDown() |
||||
{ |
||||
} |
||||
|
||||
void PatternDown::setDirection(int direction) |
||||
{ |
||||
this->direction = abs(direction) * -1; |
||||
} |
||||
|
||||
void PatternDown::reset() |
||||
{ |
||||
step = 0; |
||||
direction = -1; |
||||
} |
||||
|
||||
void PatternDown::goToNextStep() |
||||
{ |
||||
if (size > 0) { |
||||
step = (step + direction < 0) ? size - 1 : step + direction; |
||||
} else { |
||||
step = 0; |
||||
} |
||||
} |
||||
|
||||
PatternUpDown::PatternUpDown() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternUpDown::~PatternUpDown() |
||||
{ |
||||
} |
||||
|
||||
void PatternUpDown::setDirection(int direction) |
||||
{ |
||||
this->direction = direction; |
||||
} |
||||
|
||||
void PatternUpDown::reset() |
||||
{ |
||||
step = 0; |
||||
direction = 1; |
||||
} |
||||
|
||||
void PatternUpDown::goToNextStep() |
||||
{ |
||||
if (size > 1) { |
||||
int nextStep = step + direction; |
||||
direction = (nextStep >= size) ? -1 : direction; |
||||
direction = (nextStep < 0) ? 1 : direction; |
||||
step += direction; |
||||
} else { |
||||
step = 0; |
||||
} |
||||
} |
||||
|
||||
PatternUpDownAlt::PatternUpDownAlt() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternUpDownAlt::~PatternUpDownAlt() |
||||
{ |
||||
} |
||||
|
||||
void PatternUpDownAlt::setDirection(int direction) |
||||
{ |
||||
this->direction = direction; |
||||
} |
||||
|
||||
void PatternUpDownAlt::reset() |
||||
{ |
||||
step = 0; |
||||
direction = 1; |
||||
checked = false; |
||||
skip = false; |
||||
} |
||||
|
||||
void PatternUpDownAlt::goToNextStep() |
||||
{ |
||||
if (size > 1) { |
||||
int nextStep = step + direction; |
||||
|
||||
if (!checked) { |
||||
if (nextStep >= size) { |
||||
direction = -1; |
||||
skip = true; |
||||
checked = true; |
||||
} |
||||
if (nextStep < 0) { |
||||
direction = 1; |
||||
skip = true; |
||||
checked = true; |
||||
} |
||||
} |
||||
|
||||
if (!skip) { |
||||
step += direction; |
||||
checked = false; |
||||
} |
||||
skip = false; |
||||
} else { |
||||
step = 0; |
||||
//TODO init other values
|
||||
} |
||||
} |
||||
|
||||
PatternRandom::PatternRandom() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternRandom::~PatternRandom() |
||||
{ |
||||
} |
||||
|
||||
void PatternRandom::setDirection(int direction) |
||||
{ |
||||
this->direction = direction; |
||||
} |
||||
|
||||
void PatternRandom::reset() |
||||
{ |
||||
goToNextStep(); |
||||
} |
||||
|
||||
void PatternRandom::goToNextStep() |
||||
{ |
||||
step = rand() % size; |
||||
} |
||||
|
||||
PatternCycle::PatternCycle() |
||||
{ |
||||
reset(); |
||||
} |
||||
|
||||
PatternCycle::~PatternCycle() |
||||
{ |
||||
} |
||||
|
||||
void PatternCycle::setDirection(int direction) |
||||
{ |
||||
this->direction = abs(direction); |
||||
} |
||||
|
||||
void PatternCycle::reset() |
||||
{ |
||||
step = 0; |
||||
tempStep = 0; |
||||
direction = 1; |
||||
} |
||||
|
||||
void PatternCycle::goToNextStep() |
||||
{ |
||||
if (size >= 1) { |
||||
int nextStep = tempStep + direction; |
||||
|
||||
if (range > 0 && size > 0) { |
||||
if (nextStep >= size) { |
||||
step = (step + 1) % range; |
||||
} |
||||
tempStep = (tempStep + direction) % size; |
||||
} |
||||
} else { |
||||
step = 0; |
||||
tempStep = 0; |
||||
} |
||||
} |
||||
@ -0,0 +1,93 @@ |
||||
#ifndef _H_PATTERN_ |
||||
#define _H_PATTERN_ |
||||
|
||||
#include <stdlib.h> |
||||
#include <time.h> |
||||
|
||||
class Pattern { |
||||
|
||||
enum { |
||||
ARP_UP = 0, |
||||
ARP_DOWN |
||||
}; |
||||
|
||||
public: |
||||
Pattern(); |
||||
virtual ~Pattern(); |
||||
void setPatternSize(int size); |
||||
void setStep(int step); |
||||
void setCycleRange(int range); |
||||
int getSize(); |
||||
int getStepSize(); |
||||
int getStep(); |
||||
int getDirection(); |
||||
virtual void setDirection(int direction) = 0; |
||||
virtual void reset() = 0; |
||||
virtual void goToNextStep() = 0; |
||||
protected: |
||||
int size; |
||||
int step; |
||||
int direction; |
||||
int range; |
||||
}; |
||||
|
||||
class PatternUp : public Pattern { |
||||
public: |
||||
PatternUp(); |
||||
~PatternUp(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
}; |
||||
|
||||
class PatternDown : public Pattern { |
||||
public: |
||||
PatternDown(); |
||||
~PatternDown(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
}; |
||||
|
||||
class PatternUpDown : public Pattern { |
||||
public: |
||||
PatternUpDown(); |
||||
~PatternUpDown(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
}; |
||||
|
||||
class PatternUpDownAlt : public Pattern { |
||||
public: |
||||
PatternUpDownAlt(); |
||||
~PatternUpDownAlt(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
private: |
||||
bool checked; |
||||
bool skip; |
||||
}; |
||||
|
||||
class PatternRandom : public Pattern { |
||||
public: |
||||
PatternRandom(); |
||||
~PatternRandom(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
}; |
||||
|
||||
class PatternCycle : public Pattern { |
||||
public: |
||||
PatternCycle(); |
||||
~PatternCycle(); |
||||
void setDirection(int direction) override; |
||||
void reset() override; |
||||
void goToNextStep() override; |
||||
private: |
||||
int tempStep; |
||||
}; |
||||
|
||||
#endif // _H_PATTERN_
|
||||
@ -0,0 +1,339 @@ |
||||
#include "plugin.hpp" |
||||
|
||||
START_NAMESPACE_DISTRHO |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
PluginArpeggiator::PluginArpeggiator() : |
||||
Plugin(paramCount, 0, 0), // paramCount params, 0 program(s), 0 states
|
||||
syncMode(1) |
||||
{ |
||||
arpeggiator.transmitHostInfo(0, 4, 1, 1, 120.0); |
||||
arpeggiator.setSampleRate(static_cast<float>(getSampleRate())); |
||||
arpeggiator.setDivision(7); |
||||
} |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Init
|
||||
|
||||
void PluginArpeggiator::initParameter(uint32_t index, Parameter& parameter) |
||||
{ |
||||
if (index >= paramCount) return; |
||||
|
||||
switch (index) { |
||||
case paramSyncMode: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Sync"; |
||||
parameter.symbol = "sync"; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 2; |
||||
parameter.enumValues.count = 3; |
||||
parameter.enumValues.restrictedMode = true; |
||||
{ |
||||
ParameterEnumerationValue* const channels = new ParameterEnumerationValue[13]; |
||||
parameter.enumValues.values = channels; |
||||
channels[0].label = "Free Running"; |
||||
channels[0].value = 0; |
||||
channels[1].label = "Host Sync"; |
||||
channels[1].value = 1; |
||||
channels[2].label = "Host Sync (Quantized Start)"; |
||||
channels[2].value = 2; |
||||
} |
||||
break; |
||||
case paramBpm: |
||||
parameter.hints = kParameterIsAutomable; |
||||
parameter.name = "Bpm"; |
||||
parameter.symbol = "Bpm"; |
||||
parameter.ranges.def = 120.f; |
||||
parameter.ranges.min = 20.f; |
||||
parameter.ranges.max = 280.f; |
||||
break; |
||||
case paramDivision: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Divison"; |
||||
parameter.symbol = "Divisons"; |
||||
parameter.ranges.def = 9; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 12; |
||||
parameter.enumValues.count = 13; |
||||
parameter.enumValues.restrictedMode = true; |
||||
{ |
||||
ParameterEnumerationValue* const channels = new ParameterEnumerationValue[13]; |
||||
parameter.enumValues.values = channels; |
||||
channels[0].label = "1/1"; |
||||
channels[0].value = 0; |
||||
channels[1].label = "1/2"; |
||||
channels[1].value = 1; |
||||
channels[2].label = "1/3"; |
||||
channels[2].value = 2; |
||||
channels[3].label = "1/4"; |
||||
channels[3].value = 3; |
||||
channels[4].label = "1/4."; |
||||
channels[4].value = 4; |
||||
channels[5].label = "1/4T"; |
||||
channels[5].value = 5; |
||||
channels[6].label = "1/8"; |
||||
channels[6].value = 6; |
||||
channels[7].label = "1/8."; |
||||
channels[7].value = 7; |
||||
channels[8].label = "1/8T"; |
||||
channels[8].value = 8; |
||||
channels[9].label = "1/16"; |
||||
channels[9].value = 9; |
||||
channels[10].label = "1/16."; |
||||
channels[10].value = 10; |
||||
channels[11].label = "1/16T"; |
||||
channels[11].value = 11; |
||||
channels[12].label = "1/32"; |
||||
channels[12].value = 12; |
||||
} |
||||
break; |
||||
case paramVelocity: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Velocity"; |
||||
parameter.symbol = "velocity"; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 127; |
||||
break; |
||||
case paramNoteLength: |
||||
parameter.hints = kParameterIsAutomable; |
||||
parameter.name = "Note Length"; |
||||
parameter.symbol = "noteLength"; |
||||
parameter.unit = ""; |
||||
parameter.ranges.def = 0.f; |
||||
parameter.ranges.min = 0.f; |
||||
parameter.ranges.max = 1.f; |
||||
break; |
||||
case paramOctaveSpread: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Octave Spread"; |
||||
parameter.symbol = "octaveSpread"; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 3; |
||||
parameter.enumValues.count = 4; |
||||
parameter.enumValues.restrictedMode = true; |
||||
{ |
||||
ParameterEnumerationValue* const channels = new ParameterEnumerationValue[4]; |
||||
parameter.enumValues.values = channels; |
||||
channels[0].label = "1 oct"; |
||||
channels[0].value = 0; |
||||
channels[1].label = "2 oct"; |
||||
channels[1].value = 1; |
||||
channels[2].label = "3 oct"; |
||||
channels[2].value = 2; |
||||
channels[3].label = "4 oct"; |
||||
channels[3].value = 3; |
||||
} |
||||
break; |
||||
case paramArpMode: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Arp Mode"; |
||||
parameter.symbol = "arpMode"; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 5; |
||||
parameter.enumValues.count = 6; |
||||
parameter.enumValues.restrictedMode = true; |
||||
{ |
||||
ParameterEnumerationValue* const channels = new ParameterEnumerationValue[6]; |
||||
parameter.enumValues.values = channels; |
||||
channels[0].label = "Up"; |
||||
channels[0].value = 0; |
||||
channels[1].label = "Down"; |
||||
channels[1].value = 1; |
||||
channels[2].label = "Up-Down"; |
||||
channels[2].value = 2; |
||||
channels[3].label = "Up-Down (alt)"; |
||||
channels[3].value = 3; |
||||
channels[4].label = "Played"; |
||||
channels[4].value = 4; |
||||
channels[5].label = "Random"; |
||||
channels[5].value = 5; |
||||
} |
||||
break; |
||||
case paramOctaveMode: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsInteger; |
||||
parameter.name = "Octave Mode"; |
||||
parameter.symbol = "octaveMode"; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 4; |
||||
parameter.enumValues.count = 5; |
||||
parameter.enumValues.restrictedMode = true; |
||||
{ |
||||
ParameterEnumerationValue* const channels = new ParameterEnumerationValue[5]; |
||||
parameter.enumValues.values = channels; |
||||
channels[0].label = "Up"; |
||||
channels[0].value = 0; |
||||
channels[1].label = "Down"; |
||||
channels[1].value = 1; |
||||
channels[2].label = "Up-Down"; |
||||
channels[2].value = 2; |
||||
channels[3].label = "Down-up"; |
||||
channels[3].value = 3; |
||||
channels[4].label = "1 Up / Cycle"; |
||||
channels[4].value = 4; |
||||
} |
||||
break; |
||||
case paramLatch: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsBoolean; |
||||
parameter.name = "Latch"; |
||||
parameter.symbol = "latch"; |
||||
parameter.unit = ""; |
||||
parameter.ranges.def = 0.f; |
||||
parameter.ranges.min = 0.f; |
||||
parameter.ranges.max = 1.f; |
||||
break; |
||||
case paramPanic: |
||||
parameter.hints = kParameterIsAutomable | kParameterIsTrigger; |
||||
parameter.name = "Panic"; |
||||
parameter.symbol = "Panic"; |
||||
parameter.unit = ""; |
||||
parameter.ranges.def = 0; |
||||
parameter.ranges.min = 0; |
||||
parameter.ranges.max = 1; |
||||
break; |
||||
case paramEnabled: |
||||
parameter.hints = kParameterIsBoolean; |
||||
parameter.name = "Enabled"; |
||||
parameter.symbol = "enabled"; |
||||
parameter.unit = ""; |
||||
parameter.ranges.def = 1.f; |
||||
parameter.ranges.min = 0.f; |
||||
parameter.ranges.max = 1.f; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Internal data
|
||||
|
||||
/**
|
||||
Optional callback to inform the plugin about a sample rate change. |
||||
*/ |
||||
void PluginArpeggiator::sampleRateChanged(double newSampleRate) |
||||
{ |
||||
(void) newSampleRate; |
||||
|
||||
arpeggiator.setSampleRate(static_cast<float>(newSampleRate)); |
||||
} |
||||
|
||||
/**
|
||||
Get the current value of a parameter. |
||||
*/ |
||||
float PluginArpeggiator::getParameterValue(uint32_t index) const |
||||
{ |
||||
switch (index) |
||||
{ |
||||
case paramSyncMode: |
||||
return arpeggiator.getSyncMode(); |
||||
case paramBpm: |
||||
return arpeggiator.getBpm(); |
||||
case paramDivision: |
||||
return arpeggiator.getDivision(); |
||||
case paramVelocity: |
||||
return arpeggiator.getVelocity(); |
||||
case paramNoteLength: |
||||
return arpeggiator.getNoteLength(); |
||||
case paramOctaveSpread: |
||||
return arpeggiator.getOctaveSpread(); |
||||
case paramArpMode: |
||||
return arpeggiator.getArpMode(); |
||||
case paramOctaveMode: |
||||
return arpeggiator.getOctaveMode(); |
||||
case paramLatch: |
||||
return arpeggiator.getLatchMode(); |
||||
case paramPanic: |
||||
return arpeggiator.getPanic(); |
||||
case paramEnabled: |
||||
return arpeggiator.getArpEnabled(); |
||||
} |
||||
} |
||||
|
||||
/**
|
||||
Change a parameter value. |
||||
*/ |
||||
void PluginArpeggiator::setParameterValue(uint32_t index, float value) |
||||
{ |
||||
switch (index) |
||||
{ |
||||
case paramSyncMode: |
||||
syncMode = static_cast<int>(value); |
||||
break; |
||||
case paramBpm: |
||||
arpeggiator.setBpm(value); |
||||
break; |
||||
case paramDivision: |
||||
arpeggiator.setDivision(static_cast<int>(value)); |
||||
break; |
||||
case paramVelocity: |
||||
arpeggiator.setVelocity(static_cast<int>(value)); |
||||
break; |
||||
case paramNoteLength: |
||||
arpeggiator.setNoteLength(value); |
||||
break; |
||||
case paramOctaveSpread: |
||||
arpeggiator.setOctaveSpread(static_cast<int>(value)); |
||||
break; |
||||
case paramArpMode: |
||||
arpeggiator.setArpMode(static_cast<int>(value)); |
||||
break; |
||||
case paramOctaveMode: |
||||
arpeggiator.setOctaveMode(static_cast<int>(value)); |
||||
break; |
||||
case paramLatch: |
||||
arpeggiator.setLatchMode(static_cast<bool>(value)); |
||||
break; |
||||
case paramPanic: |
||||
arpeggiator.setPanic(static_cast<bool>(value)); |
||||
break; |
||||
case paramEnabled: |
||||
arpeggiator.setArpEnabled(static_cast<bool>(value)); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// Process
|
||||
|
||||
void PluginArpeggiator::activate() |
||||
{ |
||||
// plugin is activated
|
||||
} |
||||
|
||||
void PluginArpeggiator::run(const float**, float**, uint32_t n_frames, |
||||
const MidiEvent* events, uint32_t eventCount) |
||||
{ |
||||
arpeggiator.emptyMidiBuffer(); |
||||
|
||||
// Check if host supports Bar-Beat-Tick position
|
||||
const TimePosition& position = getTimePosition(); |
||||
if (!position.bbt.valid) { |
||||
// set-arpeggiator in free running mode
|
||||
arpeggiator.setSyncMode(0); |
||||
} else { |
||||
arpeggiator.setSyncMode(syncMode); |
||||
arpeggiator.transmitHostInfo(position.playing, position.bbt.beatsPerBar, position.bbt.beat, position.bbt.barBeat, static_cast<float>(position.bbt.beatsPerMinute)); |
||||
} |
||||
|
||||
arpeggiator.process(events, eventCount, n_frames); |
||||
|
||||
struct MidiBuffer buffer = arpeggiator.getMidiBuffer(); |
||||
for (unsigned x = 0; x < buffer.numBufferedEvents + buffer.numBufferedThroughEvents; x++) { |
||||
writeMidiEvent(buffer.bufferedEvents[x]); //needs to be one struct or array?
|
||||
} |
||||
} |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
Plugin* createPlugin() |
||||
{ |
||||
return new PluginArpeggiator(); |
||||
} |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
END_NAMESPACE_DISTRHO |
||||
@ -0,0 +1,104 @@ |
||||
#ifndef _H_PLUGIN_ARPEGGIATOR_ |
||||
#define _H_PLUGIN_ARPEGGIATOR_ |
||||
|
||||
#include "arpeggiator.hpp" |
||||
#include "common/commons.h" |
||||
#include "common/clock.hpp" |
||||
#include "common/pattern.hpp" |
||||
|
||||
START_NAMESPACE_DISTRHO |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
class PluginArpeggiator : public Plugin { |
||||
public: |
||||
enum Parameters { |
||||
paramSyncMode = 0, |
||||
paramBpm, |
||||
paramDivision, |
||||
paramVelocity, |
||||
paramNoteLength, |
||||
paramOctaveSpread, |
||||
paramArpMode, |
||||
paramOctaveMode, |
||||
paramLatch, |
||||
paramPanic, |
||||
paramEnabled, |
||||
paramCount |
||||
}; |
||||
|
||||
PluginArpeggiator(); |
||||
|
||||
protected: |
||||
// -------------------------------------------------------------------
|
||||
// Information
|
||||
|
||||
const char* getLabel() const noexcept override { |
||||
return "Arpeggiator"; |
||||
} |
||||
|
||||
const char* getDescription() const override { |
||||
return "A MIDI arpeggiator"; |
||||
} |
||||
|
||||
const char* getMaker() const noexcept override { |
||||
return "MOD"; |
||||
} |
||||
|
||||
const char* getHomePage() const override { |
||||
return ""; |
||||
} |
||||
|
||||
const char* getLicense() const noexcept override { |
||||
return "https://spdx.org/licenses/GPL-2.0-or-later"; |
||||
} |
||||
|
||||
uint32_t getVersion() const noexcept override { |
||||
return d_version(1, 1, 2); |
||||
} |
||||
|
||||
int64_t getUniqueId() const noexcept override { |
||||
return d_cconst('M', 'O', 'A', 'P'); |
||||
} |
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Init
|
||||
|
||||
void initParameter(uint32_t index, Parameter& parameter) override; |
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Internal data
|
||||
|
||||
float getParameterValue(uint32_t index) const override; |
||||
void setParameterValue(uint32_t index, float value) override; |
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Optional
|
||||
|
||||
// Optional callback to inform the plugin about a sample rate change.
|
||||
void sampleRateChanged(double newSampleRate) override; |
||||
|
||||
// -------------------------------------------------------------------
|
||||
// Process
|
||||
|
||||
void activate() override; |
||||
|
||||
void run(const float**, float**, uint32_t, |
||||
const MidiEvent* midiEvents, uint32_t midiEventCount) override; |
||||
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
private: |
||||
Arpeggiator arpeggiator; |
||||
float fParams[paramCount]; |
||||
int syncMode; |
||||
|
||||
DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PluginArpeggiator) |
||||
}; |
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
END_NAMESPACE_DISTRHO |
||||
|
||||
#endif //_H_PLUGIN_ARPEGGIATOR_
|
||||
@ -0,0 +1,43 @@ |
||||
#include "utils.hpp" |
||||
|
||||
ArpUtils::ArpUtils() |
||||
{ |
||||
|
||||
} |
||||
|
||||
ArpUtils::~ArpUtils() |
||||
{ |
||||
|
||||
} |
||||
|
||||
void ArpUtils::swap(uint8_t *a, uint8_t *b) |
||||
{ |
||||
int temp = *a; |
||||
*a = *b; |
||||
*b = temp; |
||||
} |
||||
|
||||
//got the code for the quick sort algorithm here https://medium.com/human-in-a-machine-world/quicksort-the-best-sorting-algorithm-6ab461b5a9d0
|
||||
void ArpUtils::quicksort(uint8_t arr[][2], int l, int r) |
||||
{ |
||||
if (l >= r) |
||||
{ |
||||
return; |
||||
} |
||||
|
||||
int pivot = arr[r][0]; |
||||
|
||||
int cnt = l; |
||||
|
||||
for (int i = l; i <= r; i++) |
||||
{ |
||||
if (arr[i][0] <= pivot) |
||||
{ |
||||
swap(&arr[cnt][0], &arr[i][0]); |
||||
swap(&arr[cnt][1], &arr[i][1]); |
||||
cnt++; |
||||
} |
||||
} |
||||
quicksort(arr, l, cnt-2); |
||||
quicksort(arr, cnt, r); |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
#ifndef _H_UTILS_ |
||||
#define _H_UTILS_ |
||||
|
||||
#include <cstdint> |
||||
|
||||
class ArpUtils { |
||||
public: |
||||
ArpUtils(); |
||||
~ArpUtils(); |
||||
void quicksort(uint8_t arr[][2], int l, int r); |
||||
private: |
||||
void swap(uint8_t *a, uint8_t *b); |
||||
}; |
||||
|
||||
#endif //_H_UTILS_
|
||||
Loading…
Reference in new issue