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

710 lines
28 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_pd.hpp"
#define Context(_c) reinterpret_cast<Heavy_arp_delay_env_pd *>(_c)
/*
* C Functions
*/
extern "C" {
HV_EXPORT HeavyContextInterface *hv_arp_delay_env_pd_new(double sampleRate) {
return new Heavy_arp_delay_env_pd(sampleRate);
}
HV_EXPORT HeavyContextInterface *hv_arp_delay_env_pd_new_with_options(double sampleRate,
int poolKb, int inQueueKb, int outQueueKb) {
return new Heavy_arp_delay_env_pd(sampleRate, poolKb, inQueueKb, outQueueKb);
}
} // extern "C"
/*
* Class Functions
*/
Heavy_arp_delay_env_pd::Heavy_arp_delay_env_pd(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
: HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
numBytes += sLine_init(&sLine_CPk6VuuC);
numBytes += sTabhead_init(&sTabhead_Ccf3pWD1, &hTable_ncKDzzLt);
numBytes += sTabread_init(&sTabread_AIPPIP2p, &hTable_ncKDzzLt, false);
numBytes += sTabread_init(&sTabread_OR6AChVH, &hTable_ncKDzzLt, false);
numBytes += sPhasor_k_init(&sPhasor_p4d5TEqg, 220.0f, sampleRate);
numBytes += sLine_init(&sLine_GYQ4PLNT);
numBytes += sTabwrite_init(&sTabwrite_qOQtZKqp, &hTable_ncKDzzLt);
numBytes += cVar_init_f(&cVar_YvPEpnUh, 1.0f);
numBytes += cVar_init_f(&cVar_eHayjBv6, 0.0f);
numBytes += cDelay_init(this, &cDelay_DYnzHpic, 0.0f);
numBytes += cVar_init_f(&cVar_hj1UO5Xy, 300.0f);
numBytes += cBinop_init(&cBinop_sPNudZ6R, 0.0f); // __mul
numBytes += cVar_init_f(&cVar_XXw3dChu, 0.0f);
numBytes += cVar_init_f(&cVar_SLtg6rNc, 0.0f);
numBytes += cVar_init_f(&cVar_YIxdPCGV, 0.0f);
numBytes += cVar_init_s(&cVar_ssKQAxko, "del-del");
numBytes += sVarf_init(&sVarf_NKFEO8VS, 0.0f, 0.0f, false);
numBytes += sVarf_init(&sVarf_TJn8TVJj, 0.0f, 0.0f, false);
numBytes += sVarf_init(&sVarf_0ophamek, 0.0f, 0.0f, false);
numBytes += cDelay_init(this, &cDelay_X79tuCf2, 0.0f);
numBytes += cDelay_init(this, &cDelay_hlwCH2uT, 0.0f);
numBytes += hTable_init(&hTable_ncKDzzLt, 256);
numBytes += cVar_init_f(&cVar_AF7niKwq, 0.0f);
numBytes += cBinop_init(&cBinop_0qRwCHv8, 150.0f); // __mul
numBytes += sVarf_init(&sVarf_mi6YMKiN, 0.3f, 0.0f, false);
numBytes += cBinop_init(&cBinop_m5zjVpQA, 0.0f); // __add
// 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_pd::~Heavy_arp_delay_env_pd() {
hTable_free(&hTable_ncKDzzLt);
}
HvTable *Heavy_arp_delay_env_pd::getTableForHash(hv_uint32_t tableHash) {switch (tableHash) {
case 0x7BAC8768: return &hTable_ncKDzzLt; // del-del
default: return nullptr;
}
}
void Heavy_arp_delay_env_pd::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
switch (receiverHash) {
case 0x79853B03: { // Channel_A
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_dWWIm2kL_sendMessage);
break;
}
case 0xE16E1682: { // Channel_B
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_vkMNq8T0_sendMessage);
break;
}
case 0xE72718FC: { // Channel_C
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_LPnclThz_sendMessage);
break;
}
case 0x307C0274: { // Channel_D
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_9w5JwN59_sendMessage);
break;
}
case 0xCE5CC65B: { // __hv_init
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_E1RLP07b_sendMessage);
break;
}
default: return;
}
}
int Heavy_arp_delay_env_pd::getParameterInfo(int index, HvParameterInfo *info) {
if (info != nullptr) {
switch (index) {
case 0: {
info->name = "Channel_A";
info->hash = 0x79853B03;
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 = "Channel_B";
info->hash = 0xE16E1682;
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 = "Channel_C";
info->hash = 0xE72718FC;
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 = "Channel_D";
info->hash = 0x307C0274;
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_pd::cVar_YvPEpnUh_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sLine_onMessage(_c, &Context(_c)->sLine_GYQ4PLNT, 0, m, NULL);
}
void Heavy_arp_delay_env_pd::cVar_eHayjBv6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_CwzvBF2s_sendMessage);
}
void Heavy_arp_delay_env_pd::cDelay_DYnzHpic_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_DYnzHpic, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
cMsg_BQRg6jNP_sendMessage(_c, 0, m);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_GKFWiStO_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_0XRxEH1C_sendMessage);
}
void Heavy_arp_delay_env_pd::cSwitchcase_O5mYhl3b_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cMsg_E4Ec6do0_sendMessage(_c, 0, m);
break;
}
case 0x7A5B032D: { // "stop"
cMsg_E4Ec6do0_sendMessage(_c, 0, m);
break;
}
default: {
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_gzZa7okE_sendMessage);
break;
}
}
}
void Heavy_arp_delay_env_pd::cCast_gzZa7okE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_E4Ec6do0_sendMessage(_c, 0, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
cMsg_BQRg6jNP_sendMessage(_c, 0, m);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_GKFWiStO_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_0XRxEH1C_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_hj1UO5Xy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_sPNudZ6R, HV_BINOP_MULTIPLY, 0, m, &cBinop_sPNudZ6R_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_xUl3JuzU_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_pBUNmntT_sendMessage);
}
void Heavy_arp_delay_env_pd::cSystem_pBUNmntT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_d9vmQ0rR_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_sPNudZ6R_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 1.0f, 0, m, &cBinop_G3zRyasr_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_d9vmQ0rR_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_sPNudZ6R, HV_BINOP_MULTIPLY, 1, m, &cBinop_sPNudZ6R_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_G3zRyasr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 2, m, &cDelay_DYnzHpic_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_E4Ec6do0_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_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_XXw3dChu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_m5zjVpQA, HV_BINOP_ADD, 1, m, &cBinop_m5zjVpQA_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_SLtg6rNc_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_YIxdPCGV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_9OkU32H1_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_Zqip7Xkd_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_zehWpnU4_sendMessage);
}
void Heavy_arp_delay_env_pd::cSystem_zehWpnU4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_qGBikGct_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_ssKQAxko_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_qfTfqBM3_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cBinop_s01cENlp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_0ophamek, m);
}
void Heavy_arp_delay_env_pd::cBinop_qGBikGct_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_NKFEO8VS, m);
}
void Heavy_arp_delay_env_pd::cMsg_qfTfqBM3_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_4oKrr4xn_sendMessage);
}
void Heavy_arp_delay_env_pd::cSystem_4oKrr4xn_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 1.0f, 0, m, &cBinop_s01cENlp_sendMessage);
sVarf_onMessage(_c, &Context(_c)->sVarf_TJn8TVJj, m);
}
void Heavy_arp_delay_env_pd::cDelay_X79tuCf2_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_X79tuCf2, m);
cMsg_ae7TxKOA_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cDelay_hlwCH2uT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
cDelay_clearExecutingMessage(&Context(_c)->cDelay_hlwCH2uT, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_X79tuCf2, 0, m, &cDelay_X79tuCf2_sendMessage);
cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 0, m, &cDelay_hlwCH2uT_sendMessage);
sTabwrite_onMessage(_c, &Context(_c)->sTabwrite_qOQtZKqp, 1, m, NULL);
}
void Heavy_arp_delay_env_pd::cMsg_MxJmfWRW_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_rAf0fyDp_sendMessage);
}
void Heavy_arp_delay_env_pd::cSystem_rAf0fyDp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_8GCNF1V8_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_ET5EQCTg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_3up8OQvv_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cBinop_8GCNF1V8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_ET5EQCTg_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_3up8OQvv_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_ncKDzzLt, 0, m, &hTable_ncKDzzLt_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_icWX8ifl_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_X79tuCf2, 2, m, &cDelay_X79tuCf2_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_ae7TxKOA_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_ncKDzzLt, 0, m, &hTable_ncKDzzLt_sendMessage);
}
void Heavy_arp_delay_env_pd::hTable_ncKDzzLt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_icWX8ifl_sendMessage(_c, 0, m);
cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 2, m, &cDelay_hlwCH2uT_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_Wzlb1WzU_sendMessage);
}
void Heavy_arp_delay_env_pd::cCast_Wzlb1WzU_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 0, m, &cDelay_hlwCH2uT_sendMessage);
}
void Heavy_arp_delay_env_pd::cVar_AF7niKwq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_mi6YMKiN, m);
}
void Heavy_arp_delay_env_pd::cCast_zvxvkeYa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_5N2semj0_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cSwitchcase_mEf8Naqe_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_zvxvkeYa_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_arp_delay_env_pd::cBinop_0qRwCHv8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sPhasor_k_onMessage(_c, &Context(_c)->sPhasor_p4d5TEqg, 0, m);
}
void Heavy_arp_delay_env_pd::cBinop_CwzvBF2s_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 1, m, &cBinop_0qRwCHv8_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_9OkU32H1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_ADD, 20.0f, 0, m, &cBinop_vc0hK7tw_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_puVbRaHY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_hj1UO5Xy, 0, m, &cVar_hj1UO5Xy_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_m5zjVpQA_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_XXw3dChu, 0, m, &cVar_XXw3dChu_sendMessage);
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 4.0f, 0, m, &cBinop_GJqnOqJV_sendMessage);
cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 0, m, &cBinop_0qRwCHv8_sendMessage);
}
void Heavy_arp_delay_env_pd::cBinop_vc0hK7tw_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_tM3dKBd6_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cBinop_GJqnOqJV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSwitchcase_mEf8Naqe_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_arp_delay_env_pd::cMsg_0V4UPj7Z_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_GYQ4PLNT, 0, m, NULL);
}
void Heavy_arp_delay_env_pd::cMsg_jOD5Mj4Q_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_O5mYhl3b_onMessage(_c, NULL, 0, m, NULL);
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_dmrzMGJf_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_mi6YMKiN, m);
}
void Heavy_arp_delay_env_pd::cMsg_hPlGDhkM_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);
cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 1, m, &cBinop_0qRwCHv8_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_tM3dKBd6_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_CPk6VuuC, 0, m, NULL);
}
void Heavy_arp_delay_env_pd::cMsg_2SqJZJHs_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_tM3dKBd6_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cMsg_5N2semj0_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_XXw3dChu, 0, m, &cVar_XXw3dChu_sendMessage);
}
void Heavy_arp_delay_env_pd::cMsg_BQRg6jNP_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_m5zjVpQA, HV_BINOP_ADD, 0, m, &cBinop_m5zjVpQA_sendMessage);
}
void Heavy_arp_delay_env_pd::cCast_0XRxEH1C_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_0V4UPj7Z_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cCast_GKFWiStO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_YvPEpnUh, 0, m, &cVar_YvPEpnUh_sendMessage);
}
void Heavy_arp_delay_env_pd::cReceive_E1RLP07b_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cMsg_xUl3JuzU_sendMessage(_c, 0, m);
cVar_onMessage(_c, &Context(_c)->cVar_hj1UO5Xy, 0, m, &cVar_hj1UO5Xy_sendMessage);
cMsg_MxJmfWRW_sendMessage(_c, 0, m);
cMsg_jOD5Mj4Q_sendMessage(_c, 0, m);
cMsg_dmrzMGJf_sendMessage(_c, 0, m);
cMsg_hPlGDhkM_sendMessage(_c, 0, m);
cMsg_2SqJZJHs_sendMessage(_c, 0, m);
cVar_onMessage(_c, &Context(_c)->cVar_ssKQAxko, 0, m, &cVar_ssKQAxko_sendMessage);
cMsg_Zqip7Xkd_sendMessage(_c, 0, m);
}
void Heavy_arp_delay_env_pd::cReceive_LPnclThz_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_9OkU32H1_sendMessage);
}
void Heavy_arp_delay_env_pd::cReceive_dWWIm2kL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}
void Heavy_arp_delay_env_pd::cReceive_vkMNq8T0_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_CwzvBF2s_sendMessage);
}
void Heavy_arp_delay_env_pd::cReceive_9w5JwN59_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
sVarf_onMessage(_c, &Context(_c)->sVarf_mi6YMKiN, m);
}
/*
* Context Process Implementation
*/
int Heavy_arp_delay_env_pd::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_CPk6VuuC, VOf(Bf0));
__hv_tabhead_f(&sTabhead_Ccf3pWD1, 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_NKFEO8VS, VOf(Bf1));
__hv_mul_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
__hv_varread_f(&sVarf_0ophamek, 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_TJn8TVJj, 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_AIPPIP2p, VIi(Bi1), VOf(Bf3));
__hv_tabread_if(&sTabread_OR6AChVH, 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_mi6YMKiN, VOf(Bf2));
__hv_phasor_k_f(&sPhasor_p4d5TEqg, 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_GYQ4PLNT, 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_qOQtZKqp, 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(O0), VOf(O0));
__hv_add_f(VIf(Bf5), VIf(O1), VOf(O1));
// 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_pd::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_pd::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