dreamer/example_hvcc2dpf
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
fb21d89dbd
example_hvcc2dpf/distrho/source/Heavy_arp_delay_env.cpp
dreamer fb21d89dbd example hvcc2dpf
2021-03-23 22:07:32 +01:00

778 lines
30 KiB
C++
Raw Blame History

/**
* 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 "Heavy_arp_delay_env.hpp"
#define Context(_c) reinterpret_cast<Heavy_arp_delay_env *>(_c)
/*
* C Functions
*/
extern "C" {
HV_EXPORT HeavyContextInterface *hv_arp_delay_env_new(double sampleRate) {
return new Heavy_arp_delay_env(sampleRate);
}
HV_EXPORT HeavyContextInterface *hv_arp_delay_env_new_with_options(double sampleRate,
int poolKb, int inQueueKb, int outQueueKb) {
return new Heavy_arp_delay_env(sampleRate, poolKb, inQueueKb, outQueueKb);
}
} // extern "C"
/*
* Class Functions
*/
Heavy_arp_delay_env::Heavy_arp_delay_env(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
: HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
numBytes += sLine_init(&sLine_5Jrovr0w);
numBytes += sTabhead_init(&sTabhead_5flIzcsR, &hTable_RQkgAERq);
numBytes += sTabread_init(&sTabread_3ztnQBI7, &hTable_RQkgAERq, false);
numBytes += sTabread_init(&sTabread_Va5jECJY, &hTable_RQkgAERq, false);
numBytes += sPhasor_k_init(&sPhasor_deMq4ELY, 220.0f, sampleRate);
numBytes += sLine_init(&sLine_tLkWSR92);
numBytes += sTabwrite_init(&sTabwrite_lra5KFKD, &hTable_RQkgAERq);
numBytes += cVar_init_f(&cVar_QpNfcxTV, 0.0f);
numBytes += cDelay_init(this, &cDelay_TiC320ze, 0.0f);
numBytes += cVar_init_f(&cVar_BG8d1bMD, 300.0f);
numBytes += cBinop_init(&cBinop_aL2oj1zg, 0.0f); // __mul
numBytes += cDelay_init(this, &cDelay_XSmTcSC1, 0.0f);
numBytes += cDelay_init(this, &cDelay_pDIGPhjJ, 0.0f);
numBytes += hTable_init(&hTable_RQkgAERq, 256);
numBytes += cVar_init_f(&cVar_SEZ4VjpC, 0.0f);
numBytes += cVar_init_f(&cVar_W0akXWRy, 0.0f);
numBytes += cVar_init_f(&cVar_fQgeYZ23, 0.0f);
numBytes += cVar_init_f(&cVar_VnBDaCLo, 0.0f);
numBytes += cVar_init_s(&cVar_XMZRreVm, "del-del");
numBytes += sVarf_init(&sVarf_1XPUT766, 0.0f, 0.0f, false);
numBytes += sVarf_init(&sVarf_Puoj2QPe, 0.0f, 0.0f, false);
numBytes += sVarf_init(&sVarf_b7By7QIh, 0.0f, 0.0f, false);
numBytes += cVar_init_f(&cVar_wcCP0NJi, 1.0f);
numBytes += cSlice_init(&cSlice_Fw1uajNs, 2, 1);
numBytes += cSlice_init(&cSlice_YW3QKnTq, 1, 1);
numBytes += cSlice_init(&cSlice_AfFvCgf9, 0, 1);
numBytes += cBinop_init(&cBinop_oimVaEsO, 1.0f); // __pow
numBytes += cBinop_init(&cBinop_hesyA8Yg, 0.0f); // __add
numBytes += sVarf_init(&sVarf_7lIBPjgU, 0.3f, 0.0f, false);
// schedule a message to trigger all loadbangs via the __hv_init receiver
scheduleMessageForReceiver(0xCE5CC65B, msg_initWithBang(HV_MESSAGE_ON_STACK(1), 0));
}
Heavy_arp_delay_env::~Heavy_arp_delay_env() {
hTable_free(&hTable_RQkgAERq);
}
HvTable *Heavy_arp_delay_env::getTableForHash(hv_uint32_t tableHash) {switch (tableHash) {
case 0x7BAC8768: return &hTable_RQkgAERq; // del-del
default: return nullptr;
}
}
void Heavy_arp_delay_env::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
switch (receiverHash) {
case 0x40ADE322: { // Arp_Pitch
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_XUCgPiDD_sendMessage);
break;
}
case 0x234E72EF: { // Arp_Speed
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_EcfMX78P_sendMessage);
break;
}
case 0x53767352: { // Delay_Repeats
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_GkgEZDwE_sendMessage);
break;
}
case 0xEE78D101: { // Delay_Time
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_4Kzf4FZT_sendMessage);
break;
}
case 0xCE5CC65B: { // __hv_init
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_mK4YUsJl_sendMessage);
break;
}
case 0x67E37CA3: { // __hv_notein
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_eXrF3UlG_sendMessage);
break;
}
default: return;
}
}
int Heavy_arp_delay_env::getParameterInfo(int index, HvParameterInfo *info) {
if (info != nullptr) {
switch (index) {
case 0: {
info->name = "Arp_Pitch";
info->hash = 0x40ADE322;
info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
info->minVal = 0.0f;
info->maxVal = 1.0f;
info->defaultVal = 0.5f;
break;
}
case 1: {
info->name = "Arp_Speed";
info->hash = 0x234E72EF;
info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
info->minVal = 0.0f;
info->maxVal = 1.0f;
info->defaultVal = 0.5f;
break;
}
case 2: {
info->name = "Delay_Repeats";
info->hash = 0x53767352;
info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
info->minVal = 0.0f;
info->maxVal = 1.0f;
info->defaultVal = 0.5f;
break;
}
case 3: {
info->name = "Delay_Time";
info->hash = 0xEE78D101;
info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
info->minVal = 0.0f;
info->maxVal = 1.0f;
info->defaultVal = 0.5f;
break;
}
default: {
info->name = "invalid parameter index";
info->hash = 0;
info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
info->minVal = 0.0f;
info->maxVal = 0.0f;
info->defaultVal = 0.0f;
break;
}
}
}
return 4;
}
/*
* Send Function Implementations
*/
void Heavy_arp_delay_env::cVar_QpNfcxTV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_hesyA8Yg, HV_BINOP_ADD, 1, m, &cBinop_hesyA8Yg_sendMessage);
}
void Heavy_arp_delay_env::cSwitchcase_JEjQ8389_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x3F800000: { // "1.0"
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_zerZuBAj_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_arp_delay_env::cCast_zerZuBAj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_A0C5qwHZ_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cSwitchcase_MAHWLSLi_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cMsg_EIFIlHRW_sendMessage(_c, 0, m);
break;
}
case 0x7A5B032D: { // "stop"
cMsg_EIFIlHRW_sendMessage(_c, 0, m);
break;
}
default: {
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_hpcdUgv0_sendMessage);
break;
}
}
}
void Heavy_arp_delay_env::cDelay_TiC320ze_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_TiC320ze, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
cMsg_qVR4M6qt_sendMessage(_c, 0, m);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_79XmGDKd_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_xyQ6QCqj_sendMessage);
}
void Heavy_arp_delay_env::cCast_hpcdUgv0_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_EIFIlHRW_sendMessage(_c, 0, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
cMsg_qVR4M6qt_sendMessage(_c, 0, m);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_79XmGDKd_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_xyQ6QCqj_sendMessage);
}
void Heavy_arp_delay_env::cMsg_nEreHrAN_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setSymbol(m, 0, "samplerate");
cSystem_onMessage(_c, NULL, 0, m, &cSystem_f2BGea9a_sendMessage);
}
void Heavy_arp_delay_env::cSystem_f2BGea9a_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_IvE42sSb_sendMessage);
}
void Heavy_arp_delay_env::cVar_BG8d1bMD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_aL2oj1zg, HV_BINOP_MULTIPLY, 0, m, &cBinop_aL2oj1zg_sendMessage);
}
void Heavy_arp_delay_env::cMsg_EIFIlHRW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setSymbol(m, 0, "clear");
cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
}
void Heavy_arp_delay_env::cBinop_N9H9NawL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 2, m, &cDelay_TiC320ze_sendMessage);
}
void Heavy_arp_delay_env::cBinop_IvE42sSb_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_aL2oj1zg, HV_BINOP_MULTIPLY, 1, m, &cBinop_aL2oj1zg_sendMessage);
}
void Heavy_arp_delay_env::cBinop_aL2oj1zg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 1.0f, 0, m, &cBinop_N9H9NawL_sendMessage);
}
void Heavy_arp_delay_env::cMsg_fVpsf0EY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setSymbol(m, 0, "samplerate");
cSystem_onMessage(_c, NULL, 0, m, &cSystem_qdiBBSrT_sendMessage);
}
void Heavy_arp_delay_env::cSystem_qdiBBSrT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_D578FYDj_sendMessage);
}
void Heavy_arp_delay_env::cDelay_XSmTcSC1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_XSmTcSC1, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_pDIGPhjJ, 0, m, &cDelay_pDIGPhjJ_sendMessage);
cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 0, m, &cDelay_XSmTcSC1_sendMessage);
sTabwrite_onMessage(_c, &Context(_c)->sTabwrite_lra5KFKD, 1, m, NULL);
}
void Heavy_arp_delay_env::cDelay_pDIGPhjJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_pDIGPhjJ, m);
cMsg_8Jd91u4J_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cBinop_a6xP9f6r_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_L8kmBApX_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::hTable_RQkgAERq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_jjqDeWpg_sendMessage(_c, 0, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 2, m, &cDelay_XSmTcSC1_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_TyQ72s6o_sendMessage);
}
void Heavy_arp_delay_env::cMsg_L8kmBApX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(2);
msg_init(m, 2, msg_getTimestamp(n));
msg_setSymbol(m, 0, "resize");
msg_setElementToFrom(m, 1, n, 0);
hTable_onMessage(_c, &Context(_c)->hTable_RQkgAERq, 0, m, &hTable_RQkgAERq_sendMessage);
}
void Heavy_arp_delay_env::cBinop_D578FYDj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_a6xP9f6r_sendMessage);
}
void Heavy_arp_delay_env::cMsg_8Jd91u4J_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setSymbol(m, 0, "mirror");
hTable_onMessage(_c, &Context(_c)->hTable_RQkgAERq, 0, m, &hTable_RQkgAERq_sendMessage);
}
void Heavy_arp_delay_env::cCast_TyQ72s6o_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 0, m, &cDelay_XSmTcSC1_sendMessage);
}
void Heavy_arp_delay_env::cMsg_jjqDeWpg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, static_cast<float>(HV_N_SIMD));
cDelay_onMessage(_c, &Context(_c)->cDelay_pDIGPhjJ, 2, m, &cDelay_pDIGPhjJ_sendMessage);
}
void Heavy_arp_delay_env::cVar_SEZ4VjpC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}
void Heavy_arp_delay_env::cVar_W0akXWRy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_86yU2trO_sendMessage);
}
void Heavy_arp_delay_env::cVar_fQgeYZ23_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_b7c8uTvL_sendMessage);
}
void Heavy_arp_delay_env::cVar_VnBDaCLo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}
void Heavy_arp_delay_env::cMsg_AusRai4k_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setSymbol(m, 0, "samplerate");
cSystem_onMessage(_c, NULL, 0, m, &cSystem_1GtyEzxF_sendMessage);
}
void Heavy_arp_delay_env::cSystem_1GtyEzxF_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_D7aI6oLJ_sendMessage);
}
void Heavy_arp_delay_env::cVar_XMZRreVm_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_u7DQ67Ug_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cSystem_NStX9wYa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 1.0f, 0, m, &cBinop_dhfHyNRX_sendMessage);
sVarf_onMessage(_c, &Context(_c)->sVarf_1XPUT766, m);
}
void Heavy_arp_delay_env::cBinop_D7aI6oLJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_Puoj2QPe, m);
}
void Heavy_arp_delay_env::cMsg_u7DQ67Ug_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(3);
msg_init(m, 3, msg_getTimestamp(n));
msg_setSymbol(m, 0, "table");
msg_setElementToFrom(m, 1, n, 0);
msg_setSymbol(m, 2, "size");
cSystem_onMessage(_c, NULL, 0, m, &cSystem_NStX9wYa_sendMessage);
}
void Heavy_arp_delay_env::cBinop_dhfHyNRX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_b7By7QIh, m);
}
void Heavy_arp_delay_env::cVar_wcCP0NJi_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sLine_onMessage(_c, &Context(_c)->sLine_tLkWSR92, 0, m, NULL);
}
void Heavy_arp_delay_env::cSlice_Fw1uajNs_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_arp_delay_env::cSlice_YW3QKnTq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_arp_delay_env::cSlice_AfFvCgf9_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 69.0f, 0, m, &cBinop_Pt69l6DW_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_arp_delay_env::cBinop_BY849OFM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sPhasor_k_onMessage(_c, &Context(_c)->sPhasor_deMq4ELY, 0, m);
}
void Heavy_arp_delay_env::cBinop_Pt69l6DW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 12.0f, 0, m, &cBinop_x27TkP5A_sendMessage);
}
void Heavy_arp_delay_env::cBinop_x27TkP5A_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_oimVaEsO, HV_BINOP_POW, 1, m, &cBinop_oimVaEsO_sendMessage);
cMsg_Y0D08wrf_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cBinop_oimVaEsO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_BY849OFM_sendMessage);
}
void Heavy_arp_delay_env::cMsg_Y0D08wrf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 2.0f);
cBinop_onMessage(_c, &Context(_c)->cBinop_oimVaEsO, HV_BINOP_POW, 0, m, &cBinop_oimVaEsO_sendMessage);
}
void Heavy_arp_delay_env::cBinop_hesyA8Yg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_QpNfcxTV, 0, m, &cVar_QpNfcxTV_sendMessage);
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 4.0f, 0, m, &cBinop_QamkPGUu_sendMessage);
}
void Heavy_arp_delay_env::cMsg_qVR4M6qt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 1.0f);
cBinop_onMessage(_c, &Context(_c)->cBinop_hesyA8Yg, HV_BINOP_ADD, 0, m, &cBinop_hesyA8Yg_sendMessage);
}
void Heavy_arp_delay_env::cMsg_A0C5qwHZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 0.0f);
cVar_onMessage(_c, &Context(_c)->cVar_QpNfcxTV, 0, m, &cVar_QpNfcxTV_sendMessage);
}
void Heavy_arp_delay_env::cMsg_6yCKZYJD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 1.0f);
cSwitchcase_MAHWLSLi_onMessage(_c, NULL, 0, m, NULL);
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}
void Heavy_arp_delay_env::cMsg_fDDSBI42_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 0.3f);
sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}
void Heavy_arp_delay_env::cBinop_86yU2trO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
}
void Heavy_arp_delay_env::cMsg_XJFOKNQO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 440.0f);
}
void Heavy_arp_delay_env::cMsg_g5DX3UAM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(1);
msg_init(m, 1, msg_getTimestamp(n));
msg_setFloat(m, 0, 220.0f);
cMsg_5K6Ff69g_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cBinop_b7c8uTvL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_ADD, 20.0f, 0, m, &cBinop_exCKzhjC_sendMessage);
}
void Heavy_arp_delay_env::cBinop_exCKzhjC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_5K6Ff69g_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cBinop_QamkPGUu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSwitchcase_JEjQ8389_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_arp_delay_env::cBinop_rnkTCEOE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_BG8d1bMD, 0, m, &cVar_BG8d1bMD_sendMessage);
}
void Heavy_arp_delay_env::cMsg_5K6Ff69g_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(2);
msg_init(m, 2, msg_getTimestamp(n));
msg_setElementToFrom(m, 0, n, 0);
msg_setFloat(m, 1, 20.0f);
sLine_onMessage(_c, &Context(_c)->sLine_5Jrovr0w, 0, m, NULL);
}
void Heavy_arp_delay_env::cMsg_T2Vn5l1r_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
HvMessage *m = nullptr;
m = HV_MESSAGE_ON_STACK(2);
msg_init(m, 2, msg_getTimestamp(n));
msg_setFloat(m, 0, 0.0f);
msg_setFloat(m, 1, 300.0f);
sLine_onMessage(_c, &Context(_c)->sLine_tLkWSR92, 0, m, NULL);
}
void Heavy_arp_delay_env::cCast_xyQ6QCqj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_T2Vn5l1r_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cCast_79XmGDKd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_wcCP0NJi, 0, m, &cVar_wcCP0NJi_sendMessage);
}
void Heavy_arp_delay_env::cReceive_mK4YUsJl_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_nEreHrAN_sendMessage(_c, 0, m);
cVar_onMessage(_c, &Context(_c)->cVar_BG8d1bMD, 0, m, &cVar_BG8d1bMD_sendMessage);
cMsg_fVpsf0EY_sendMessage(_c, 0, m);
cMsg_6yCKZYJD_sendMessage(_c, 0, m);
cMsg_fDDSBI42_sendMessage(_c, 0, m);
cMsg_XJFOKNQO_sendMessage(_c, 0, m);
cMsg_g5DX3UAM_sendMessage(_c, 0, m);
cVar_onMessage(_c, &Context(_c)->cVar_XMZRreVm, 0, m, &cVar_XMZRreVm_sendMessage);
cMsg_AusRai4k_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env::cReceive_eXrF3UlG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_Fw1uajNs, 0, m, &cSlice_Fw1uajNs_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_YW3QKnTq, 0, m, &cSlice_YW3QKnTq_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_AfFvCgf9, 0, m, &cSlice_AfFvCgf9_sendMessage);
}
void Heavy_arp_delay_env::cReceive_GkgEZDwE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}
void Heavy_arp_delay_env::cReceive_XUCgPiDD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_86yU2trO_sendMessage);
}
void Heavy_arp_delay_env::cReceive_EcfMX78P_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}
void Heavy_arp_delay_env::cReceive_4Kzf4FZT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_b7c8uTvL_sendMessage);
}
/*
* Context Process Implementation
*/
int Heavy_arp_delay_env::process(float **inputBuffers, float **outputBuffers, int n) {
while (hLp_hasData(&inQueue)) {
hv_uint32_t numBytes = 0;
ReceiverMessagePair *p = reinterpret_cast<ReceiverMessagePair *>(hLp_getReadBuffer(&inQueue, &numBytes));
hv_assert(numBytes >= sizeof(ReceiverMessagePair));
scheduleMessageForReceiver(p->receiverHash, &p->msg);
hLp_consume(&inQueue);
}
const int n4 = n & ~HV_N_SIMD_MASK; // ensure that the block size is a multiple of HV_N_SIMD
// temporary signal vars
hv_bufferf_t Bf0, Bf1, Bf2, Bf3, Bf4, Bf5, Bf6;
hv_bufferi_t Bi0, Bi1;
// input and output vars
hv_bufferf_t O0, O1;
// declare and init the zero buffer
hv_bufferf_t ZERO; __hv_zero_f(VOf(ZERO));
hv_uint32_t nextBlock = blockStartTimestamp;
for (int n = 0; n < n4; n += HV_N_SIMD) {
// process all of the messages for this block
nextBlock += HV_N_SIMD;
while (mq_hasMessageBefore(&mq, nextBlock)) {
MessageNode *const node = mq_peek(&mq);
node->sendMessage(this, node->let, node->m);
mq_pop(&mq);
}
// zero output buffers
__hv_zero_f(VOf(O0));
__hv_zero_f(VOf(O1));
// process all signal functions
__hv_line_f(&sLine_5Jrovr0w, VOf(Bf0));
__hv_tabhead_f(&sTabhead_5flIzcsR, VOf(Bf1));
__hv_var_k_f_r(VOf(Bf2), -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, -6.0f, -7.0f, -8.0f);
__hv_add_f(VIf(Bf1), VIf(Bf2), VOf(Bf2));
__hv_varread_f(&sVarf_Puoj2QPe, VOf(Bf1));
__hv_mul_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
__hv_varread_f(&sVarf_b7By7QIh, VOf(Bf0));
__hv_min_f(VIf(Bf1), VIf(Bf0), VOf(Bf0));
__hv_zero_f(VOf(Bf1));
__hv_max_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
__hv_sub_f(VIf(Bf2), VIf(Bf1), VOf(Bf1));
__hv_floor_f(VIf(Bf1), VOf(Bf2));
__hv_varread_f(&sVarf_1XPUT766, VOf(Bf0));
__hv_zero_f(VOf(Bf3));
__hv_lt_f(VIf(Bf2), VIf(Bf3), VOf(Bf3));
__hv_and_f(VIf(Bf0), VIf(Bf3), VOf(Bf3));
__hv_add_f(VIf(Bf2), VIf(Bf3), VOf(Bf3));
__hv_cast_fi(VIf(Bf3), VOi(Bi0));
__hv_var_k_i(VOi(Bi1), 1, 1, 1, 1, 1, 1, 1, 1);
__hv_add_i(VIi(Bi0), VIi(Bi1), VOi(Bi1));
__hv_tabread_if(&sTabread_3ztnQBI7, VIi(Bi1), VOf(Bf3));
__hv_tabread_if(&sTabread_Va5jECJY, VIi(Bi0), VOf(Bf0));
__hv_sub_f(VIf(Bf3), VIf(Bf0), VOf(Bf3));
__hv_sub_f(VIf(Bf1), VIf(Bf2), VOf(Bf2));
__hv_fma_f(VIf(Bf3), VIf(Bf2), VIf(Bf0), VOf(Bf0));
__hv_varread_f(&sVarf_7lIBPjgU, VOf(Bf2));
__hv_phasor_k_f(&sPhasor_deMq4ELY, VOf(Bf3));
__hv_var_k_f(VOf(Bf1), 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f);
__hv_sub_f(VIf(Bf3), VIf(Bf1), VOf(Bf1));
__hv_abs_f(VIf(Bf1), VOf(Bf1));
__hv_var_k_f(VOf(Bf3), 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f);
__hv_sub_f(VIf(Bf1), VIf(Bf3), VOf(Bf3));
__hv_var_k_f(VOf(Bf1), 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f);
__hv_mul_f(VIf(Bf3), VIf(Bf1), VOf(Bf1));
__hv_mul_f(VIf(Bf1), VIf(Bf1), VOf(Bf3));
__hv_mul_f(VIf(Bf1), VIf(Bf3), VOf(Bf4));
__hv_mul_f(VIf(Bf4), VIf(Bf3), VOf(Bf3));
__hv_var_k_f(VOf(Bf5), 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f);
__hv_var_k_f(VOf(Bf6), -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f);
__hv_fma_f(VIf(Bf4), VIf(Bf6), VIf(Bf1), VOf(Bf1));
__hv_fma_f(VIf(Bf3), VIf(Bf5), VIf(Bf1), VOf(Bf1));
__hv_line_f(&sLine_tLkWSR92, VOf(Bf5));
__hv_mul_f(VIf(Bf1), VIf(Bf5), VOf(Bf5));
__hv_fma_f(VIf(Bf0), VIf(Bf2), VIf(Bf5), VOf(Bf2));
__hv_tabwrite_f(&sTabwrite_lra5KFKD, VIf(Bf2));
__hv_add_f(VIf(Bf5), VIf(Bf0), VOf(Bf0));
__hv_var_k_f(VOf(Bf5), 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f);
__hv_mul_f(VIf(Bf0), VIf(Bf5), VOf(Bf5));
__hv_add_f(VIf(Bf5), VIf(O1), VOf(O1));
__hv_add_f(VIf(Bf5), VIf(O0), VOf(O0));
// save output vars to output buffer
__hv_store_f(outputBuffers[0]+n, VIf(O0));
__hv_store_f(outputBuffers[1]+n, VIf(O1));
}
blockStartTimestamp = nextBlock;
return n4; // return the number of frames processed
}
int Heavy_arp_delay_env::processInline(float *inputBuffers, float *outputBuffers, int n4) {
hv_assert(!(n4 & HV_N_SIMD_MASK)); // ensure that n4 is a multiple of HV_N_SIMD
// define the heavy input buffer for 0 channel(s)
float **const bIn = NULL;
// define the heavy output buffer for 2 channel(s)
float **const bOut = reinterpret_cast<float **>(hv_alloca(2*sizeof(float *)));
bOut[0] = outputBuffers+(0*n4);
bOut[1] = outputBuffers+(1*n4);
int n = process(bIn, bOut, n4);
return n;
}
int Heavy_arp_delay_env::processInlineInterleaved(float *inputBuffers, float *outputBuffers, int n4) {
hv_assert(n4 & ~HV_N_SIMD_MASK); // ensure that n4 is a multiple of HV_N_SIMD
// define the heavy input buffer for 0 channel(s), uninterleave
float *const bIn = NULL;
// define the heavy output buffer for 2 channel(s)
float *const bOut = reinterpret_cast<float *>(hv_alloca(2*n4*sizeof(float)));
int n = processInline(bIn, bOut, n4);
// interleave the heavy output into the output buffer
#if HV_SIMD_AVX
for (int i = 0, j = 0; j < n4; j += 8, i += 16) {
__m256 x = _mm256_load_ps(bOut+j); // LLLLLLLL
__m256 y = _mm256_load_ps(bOut+n4+j); // RRRRRRRR
__m256 a = _mm256_unpacklo_ps(x, y); // LRLRLRLR
__m256 b = _mm256_unpackhi_ps(x, y); // LRLRLRLR
_mm256_store_ps(outputBuffers+i, a);
_mm256_store_ps(outputBuffers+8+i, b);
}
#elif HV_SIMD_SSE
for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
__m128 x = _mm_load_ps(bOut+j); // LLLL
__m128 y = _mm_load_ps(bOut+n4+j); // RRRR
__m128 a = _mm_unpacklo_ps(x, y); // LRLR
__m128 b = _mm_unpackhi_ps(x, y); // LRLR
_mm_store_ps(outputBuffers+i, a);
_mm_store_ps(outputBuffers+4+i, b);
}
#elif HV_SIMD_NEON
// https://community.arm.com/groups/processors/blog/2012/03/13/coding-for-neon--part-5-rearranging-vectors
for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
float32x4_t x = vld1q_f32(bOut+j);
float32x4_t y = vld1q_f32(bOut+n4+j);
float32x4x2_t z = {x, y};
vst2q_f32(outputBuffers+i, z); // interleave and store
}
#else // HV_SIMD_NONE
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < n4; ++j) {
outputBuffers[i+2*j] = bOut[i*n4+j];
}
}
#endif
return n;
}
Reference in New Issue View Git Blame Copy Permalink