339 lines
9.3 KiB
C++
339 lines
9.3 KiB
C++
/**
|
|
* Copyright (c) 2021 Enzien Audio, Ltd.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions, and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the phrase "powered by heavy",
|
|
* the heavy logo, and a hyperlink to https://enzienaudio.com, all in a visible
|
|
* form.
|
|
*
|
|
* 2.1 If the Application is distributed in a store system (for example,
|
|
* the Apple "App Store" or "Google Play"), the phrase "powered by heavy"
|
|
* shall be included in the app description or the copyright text as well as
|
|
* the in the app itself. The heavy logo will shall be visible in the app
|
|
* itself as well.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include "HeavyDPF_dpf_midi_thru.hpp"
|
|
|
|
|
|
#define HV_LV2_NUM_PARAMETERS 0
|
|
|
|
#define HV_HASH_NOTEIN 0x67e37ca3
|
|
#define HV_HASH_CTLIN 0x41be0f9c
|
|
#define HV_HASH_PGMIN 0x2e1ea03d
|
|
#define HV_HASH_TOUCHIN 0x553925bd
|
|
#define HV_HASH_BENDIN 0x3083f0f7
|
|
#define HV_HASH_MIDIIN 0x149631be
|
|
|
|
#define HV_HASH_NOTEOUT 0xd1d4ac2
|
|
#define HV_HASH_CTLOUT 0xe5e2a040
|
|
#define HV_HASH_PGMOUT 0x8753e39e
|
|
#define HV_HASH_TOUCHOUT 0x476d4387
|
|
#define HV_HASH_BENDOUT 0xe8458013
|
|
#define HV_HASH_MIDIOUT 0x6511de55
|
|
|
|
|
|
START_NAMESPACE_DISTRHO
|
|
|
|
static void hvSendHookFunc(HeavyContextInterface *c, const char *sendName, uint32_t sendHash, const HvMessage *m)
|
|
{
|
|
HeavyDPF_dpf_midi_thru* plugin = (HeavyDPF_dpf_midi_thru*)c->getUserData();
|
|
if (plugin != nullptr)
|
|
{
|
|
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
|
|
plugin->handleMidiSend(sendHash, m);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void hvPrintHookFunc(HeavyContextInterface *c, const char *printLabel, const char *msgString, const HvMessage *m)
|
|
{
|
|
char buf[64];
|
|
char* dst = buf;
|
|
int len = strnlen(printLabel, 48);
|
|
dst = stpncpy(dst, printLabel, len);
|
|
dst = stpcpy(dst, " ");
|
|
dst = stpncpy(dst, msgString, 63-len);
|
|
printf("> %s \n", buf);
|
|
}
|
|
|
|
HeavyDPF_dpf_midi_thru::HeavyDPF_dpf_midi_thru()
|
|
: Plugin(HV_LV2_NUM_PARAMETERS, 0, 0)
|
|
{
|
|
|
|
|
|
_context = new Heavy_dpf_midi_thru(getSampleRate(), 10, 2, 5);
|
|
_context->setUserData(this);
|
|
_context->setSendHook(&hvSendHookFunc);
|
|
_context->setPrintHook(&hvPrintHookFunc);
|
|
|
|
|
|
}
|
|
|
|
HeavyDPF_dpf_midi_thru::~HeavyDPF_dpf_midi_thru() {
|
|
delete _context;
|
|
}
|
|
|
|
void HeavyDPF_dpf_midi_thru::initParameter(uint32_t index, Parameter& parameter)
|
|
{
|
|
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
// Internal data
|
|
|
|
float HeavyDPF_dpf_midi_thru::getParameterValue(uint32_t index) const
|
|
{
|
|
|
|
return 0.0f;
|
|
|
|
}
|
|
|
|
void HeavyDPF_dpf_midi_thru::setParameterValue(uint32_t index, float value)
|
|
{
|
|
|
|
// nothing to do
|
|
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Process
|
|
|
|
// void HeavyDPF_dpf_midi_thru::activate()
|
|
// {
|
|
|
|
// }
|
|
|
|
// void HeavyDPF_dpf_midi_thru::deactivate()
|
|
// {
|
|
|
|
// }
|
|
|
|
#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
|
|
void HeavyDPF_dpf_midi_thru::handleMidiInput(uint32_t curEventIndex, const MidiEvent* midiEvents)
|
|
{
|
|
int status = midiEvents[curEventIndex].data[0];
|
|
int command = status & 0xF0;
|
|
int channel = status & 0x0F;
|
|
int data1 = midiEvents[curEventIndex].data[1];
|
|
int data2 = midiEvents[curEventIndex].data[2];
|
|
|
|
// raw [midiin] messages
|
|
_context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
|
|
(float) status,
|
|
(float) channel);
|
|
|
|
_context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
|
|
(float) data1,
|
|
(float) channel);
|
|
|
|
_context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
|
|
(float) data2,
|
|
(float) channel);
|
|
|
|
switch (command) {
|
|
case 0x80: { // note off
|
|
_context->sendMessageToReceiverV(HV_HASH_NOTEIN, 0, "fff",
|
|
(float) data1, // pitch
|
|
(float) 0, // velocity
|
|
(float) channel);
|
|
break;
|
|
}
|
|
case 0x90: { // note on
|
|
_context->sendMessageToReceiverV(HV_HASH_NOTEIN, 0, "fff",
|
|
(float) data1, // pitch
|
|
(float) data2, // velocity
|
|
(float) channel);
|
|
break;
|
|
}
|
|
case 0xB0: { // control change
|
|
_context->sendMessageToReceiverV(HV_HASH_CTLIN, 0, "fff",
|
|
(float) data2, // value
|
|
(float) data1, // cc number
|
|
(float) channel);
|
|
break;
|
|
}
|
|
case 0xC0: { // program change
|
|
_context->sendMessageToReceiverV(HV_HASH_PGMIN, 0, "ff",
|
|
(float) data1,
|
|
(float) channel);
|
|
break;
|
|
}
|
|
case 0xD0: { // aftertouch
|
|
_context->sendMessageToReceiverV(HV_HASH_TOUCHIN, 0, "ff",
|
|
(float) data1,
|
|
(float) channel);
|
|
break;
|
|
}
|
|
case 0xE0: { // pitch bend
|
|
// combine 7bit lsb and msb into 32bit int
|
|
hv_uint32_t value = (((hv_uint32_t) data2) << 7) | ((hv_uint32_t) data1);
|
|
_context->sendMessageToReceiverV(HV_HASH_BENDIN, 0, "ff",
|
|
(float) value,
|
|
(float) channel);
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
|
|
void HeavyDPF_dpf_midi_thru::handleMidiSend(uint32_t sendHash, const HvMessage *m)
|
|
{
|
|
MidiEvent midiSendEvent;
|
|
midiSendEvent.frame = 0;
|
|
midiSendEvent.dataExt = nullptr;
|
|
|
|
switch(sendHash){
|
|
case HV_HASH_NOTEOUT: // __hv_noteout
|
|
{
|
|
uint8_t note = hv_msg_getFloat(m, 0);
|
|
uint8_t velocity = hv_msg_getFloat(m, 1);
|
|
uint8_t ch = hv_msg_getFloat(m, 2);
|
|
|
|
midiSendEvent.size = 3;
|
|
if (velocity > 0){
|
|
midiSendEvent.data[0] = 0x90 | ch; // noteon
|
|
} else {
|
|
midiSendEvent.data[0] = 0x80 | ch; // noteoff
|
|
}
|
|
midiSendEvent.data[1] = note;
|
|
midiSendEvent.data[2] = velocity;
|
|
|
|
writeMidiEvent(midiSendEvent);
|
|
break;
|
|
}
|
|
case HV_HASH_CTLOUT:
|
|
{
|
|
uint8_t value = hv_msg_getFloat(m, 0);
|
|
uint8_t cc = hv_msg_getFloat(m, 1);
|
|
uint8_t ch = hv_msg_getFloat(m, 2);
|
|
|
|
midiSendEvent.size = 3;
|
|
midiSendEvent.data[0] = 0xB0 | ch; // send CC
|
|
midiSendEvent.data[1] = cc;
|
|
midiSendEvent.data[2] = value;
|
|
|
|
writeMidiEvent(midiSendEvent);
|
|
break;
|
|
}
|
|
case HV_HASH_PGMOUT:
|
|
{
|
|
uint8_t pgm = hv_msg_getFloat(m, 0);
|
|
uint8_t ch = hv_msg_getFloat(m, 1);
|
|
|
|
midiSendEvent.size = 2;
|
|
midiSendEvent.data[0] = 0xC0 | ch; // send Program Change
|
|
midiSendEvent.data[1] = pgm;
|
|
|
|
writeMidiEvent(midiSendEvent);
|
|
break;
|
|
}
|
|
case HV_HASH_TOUCHOUT:
|
|
{
|
|
uint8_t value = hv_msg_getFloat(m, 0);
|
|
uint8_t ch = hv_msg_getFloat(m, 1);
|
|
|
|
midiSendEvent.size = 2;
|
|
midiSendEvent.data[0] = 0xD0 | ch; // send Touch
|
|
midiSendEvent.data[1] = value;
|
|
|
|
writeMidiEvent(midiSendEvent);
|
|
break;
|
|
}
|
|
case HV_HASH_BENDOUT:
|
|
{
|
|
uint16_t value = hv_msg_getFloat(m, 0);
|
|
uint8_t lsb = value & 0x7F;
|
|
uint8_t msb = (value >> 7) & 0x7F;
|
|
uint8_t ch = hv_msg_getFloat(m, 1);
|
|
|
|
midiSendEvent.size = 3;
|
|
midiSendEvent.data[0] = 0xE0 | ch; // send Bend
|
|
midiSendEvent.data[1] = lsb;
|
|
midiSendEvent.data[2] = msb;
|
|
|
|
writeMidiEvent(midiSendEvent);
|
|
break;
|
|
}
|
|
// case HV_HASH_MIDIOUT: // __hv_midiout
|
|
// {
|
|
// midiSendEvent.size = m->numElements;
|
|
// // midiSendEvent.dataExt = (const uint8_t *) m->elem->data;
|
|
|
|
// const char* rawdata = new const char[m->numElements];
|
|
|
|
// for (int i = 0; i < m->numElements; ++i) {
|
|
// rawdata[i] = hv_msg_getFloat(m, i);
|
|
// }
|
|
// midiSendEvent.dataExt = (const uint8_t *) rawdata;
|
|
|
|
// writeMidiEvent(midiSendEvent);
|
|
// }
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
|
|
void HeavyDPF_dpf_midi_thru::run(const float** inputs, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount)
|
|
{
|
|
for (uint32_t i=0; i < midiEventCount; ++i)
|
|
{
|
|
handleMidiInput(i, midiEvents);
|
|
}
|
|
#else
|
|
void HeavyDPF_dpf_midi_thru::run(const float** inputs, float** outputs, uint32_t frames)
|
|
{
|
|
#endif
|
|
|
|
_context->process((float**)inputs, outputs, frames);
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
// Callbacks
|
|
|
|
void HeavyDPF_dpf_midi_thru::sampleRateChanged(double newSampleRate)
|
|
{
|
|
delete _context;
|
|
|
|
_context = new Heavy_dpf_midi_thru(newSampleRate, 10, 2, 5);
|
|
_context->setUserData(this);
|
|
_context->setSendHook(&hvSendHookFunc);
|
|
_context->setPrintHook(&hvPrintHookFunc);
|
|
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
/* Plugin entry point, called by DPF to create a new plugin instance. */
|
|
|
|
Plugin* createPlugin()
|
|
{
|
|
return new HeavyDPF_dpf_midi_thru();
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
|
|
END_NAMESPACE_DISTRHO |