dreamer/heavydpf_midi_thru
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
d8e316e7d6
heavydpf_midi_thru/plugin/source/Heavy_dpf_example.cpp
dreamer 1eaf19a0c3 stuff
2021-10-17 23:09:30 +02:00

1179 lines
41 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_dpf_example.hpp"
#define Context(_c) reinterpret_cast<Heavy_dpf_example *>(_c)
/*
* C Functions
*/
extern "C" {
HV_EXPORT HeavyContextInterface *hv_dpf_example_new(double sampleRate) {
return new Heavy_dpf_example(sampleRate);
}
HV_EXPORT HeavyContextInterface *hv_dpf_example_new_with_options(double sampleRate,
int poolKb, int inQueueKb, int outQueueKb) {
return new Heavy_dpf_example(sampleRate, poolKb, inQueueKb, outQueueKb);
}
} // extern "C"
/*
* Class Functions
*/
Heavy_dpf_example::Heavy_dpf_example(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
: HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
numBytes += cSlice_init(&cSlice_hl5vBHNp, 2, 1);
numBytes += cSlice_init(&cSlice_ylXDwJcZ, 1, 1);
numBytes += cSlice_init(&cSlice_bA5ci4H6, 0, 1);
numBytes += cSlice_init(&cSlice_KT31W2w3, 1, -1);
numBytes += cVar_init_f(&cVar_m8VtMpGk, 0.0f);
numBytes += cIf_init(&cIf_CQoRGL7B, false);
numBytes += cIf_init(&cIf_Mb5nw3DR, false);
numBytes += cPack_init(&cPack_xwUoHsSo, 3, 0.0f, 0.0f, 0.0f);
numBytes += cVar_init_f(&cVar_W4DWXLFV, 0.0f);
numBytes += cSlice_init(&cSlice_6cAn7djG, 2, 1);
numBytes += cSlice_init(&cSlice_jUcgx0L6, 1, 1);
numBytes += cSlice_init(&cSlice_i8dZoItn, 0, 1);
numBytes += cSlice_init(&cSlice_3nFIGCtx, 1, -1);
numBytes += cSlice_init(&cSlice_i4juEjjd, 1, -1);
numBytes += cVar_init_f(&cVar_swFwKkwC, 0.0f);
numBytes += cIf_init(&cIf_eWHRwUey, false);
numBytes += cVar_init_f(&cVar_7mHmXbxO, 0.0f);
numBytes += cIf_init(&cIf_8cRMzv7p, false);
numBytes += cIf_init(&cIf_25Ghd0z7, false);
numBytes += cIf_init(&cIf_rmHI0lBi, false);
numBytes += cIf_init(&cIf_KcEtbwfw, false);
numBytes += cIf_init(&cIf_GAmmKtJo, false);
numBytes += cPack_init(&cPack_jPoKLiUE, 3, 0.0f, 0.0f, 0.0f);
numBytes += cVar_init_f(&cVar_XEUhnXhV, 0.0f);
numBytes += cVar_init_f(&cVar_yGByT1dq, 0.0f);
numBytes += cSlice_init(&cSlice_Cc4ftweA, 1, 1);
numBytes += cSlice_init(&cSlice_GKnbdSF1, 0, 1);
numBytes += cSlice_init(&cSlice_yK1ct3x5, 1, -1);
numBytes += cVar_init_f(&cVar_SbPekxvo, 0.0f);
numBytes += cIf_init(&cIf_WYWMmIs9, false);
numBytes += cIf_init(&cIf_l8AZ77OB, false);
numBytes += cPack_init(&cPack_f54JIHyD, 2, 0.0f, 0.0f);
numBytes += cVar_init_f(&cVar_vEfKjFKM, 0.0f);
numBytes += cSlice_init(&cSlice_r8i8uTTJ, 1, 1);
numBytes += cSlice_init(&cSlice_g3GkHEW8, 0, 1);
numBytes += cSlice_init(&cSlice_VIdlDx7S, 1, -1);
numBytes += cVar_init_f(&cVar_ZORELtLf, 0.0f);
numBytes += cIf_init(&cIf_m5nYTOgK, false);
numBytes += cIf_init(&cIf_2ICJGthl, false);
numBytes += cPack_init(&cPack_BGYVIlrL, 2, 0.0f, 0.0f);
numBytes += cVar_init_f(&cVar_DpRyqxcF, 0.0f);
numBytes += cSlice_init(&cSlice_9FMBZIKf, 1, 1);
numBytes += cSlice_init(&cSlice_ddagGoys, 0, 1);
numBytes += cSlice_init(&cSlice_080d2kLN, 1, -1);
numBytes += cVar_init_f(&cVar_vpyngHC3, 0.0f);
numBytes += cIf_init(&cIf_lBbDQQni, false);
numBytes += cIf_init(&cIf_NK7rKLSJ, false);
numBytes += cPack_init(&cPack_WGvA9xup, 2, 0.0f, 0.0f);
numBytes += cVar_init_f(&cVar_9A6YAgfU, 0.0f);
// schedule a message to trigger all loadbangs via the __hv_init receiver
scheduleMessageForReceiver(0xCE5CC65B, msg_initWithBang(HV_MESSAGE_ON_STACK(1), 0));
}
Heavy_dpf_example::~Heavy_dpf_example() {
cPack_free(&cPack_xwUoHsSo);
cPack_free(&cPack_jPoKLiUE);
cPack_free(&cPack_f54JIHyD);
cPack_free(&cPack_BGYVIlrL);
cPack_free(&cPack_WGvA9xup);
}
HvTable *Heavy_dpf_example::getTableForHash(hv_uint32_t tableHash) {
return nullptr;
}
void Heavy_dpf_example::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
switch (receiverHash) {
case 0x3083F0F7: { // __hv_bendin
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_tGY9yEQM_sendMessage);
break;
}
case 0x41BE0F9C: { // __hv_ctlin
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_wAZjctal_sendMessage);
break;
}
case 0xCE5CC65B: { // __hv_init
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_Wuo5XOXF_sendMessage);
break;
}
case 0x67E37CA3: { // __hv_notein
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_0NTHfNka_sendMessage);
break;
}
case 0x2E1EA03D: { // __hv_pgmin
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_bvhtEEQP_sendMessage);
break;
}
case 0x553925BD: { // __hv_touchin
mq_addMessageByTimestamp(&mq, m, 0, &cReceive_tzc2vC0H_sendMessage);
break;
}
default: return;
}
}
int Heavy_dpf_example::getParameterInfo(int index, HvParameterInfo *info) {
if (info != nullptr) {
switch (index) {
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 0;
}
/*
* Send Function Implementations
*/
void Heavy_dpf_example::cSlice_hl5vBHNp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cVar_onMessage(_c, &Context(_c)->cVar_W4DWXLFV, 0, m, &cVar_W4DWXLFV_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_ylXDwJcZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_xwUoHsSo, 1, m, &cPack_xwUoHsSo_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_bA5ci4H6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cIf_onMessage(_c, &Context(_c)->cIf_Mb5nw3DR, 0, m, &cIf_Mb5nw3DR_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_YpS7vvRv_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_KT31W2w3, 0, m, &cSlice_KT31W2w3_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_dpf_example::cSlice_KT31W2w3_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_xwUoHsSo, 0, m, &cPack_xwUoHsSo_sendMessage);
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_xwUoHsSo, 0, m, &cPack_xwUoHsSo_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cVar_m8VtMpGk_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_ssJSCDrK_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_CQoRGL7B, 0, m, &cIf_CQoRGL7B_sendMessage);
}
void Heavy_dpf_example::cUnop_KPV1AFob_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_wtFYxgtx_sendMessage);
}
void Heavy_dpf_example::cUnop_5qtccESG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_wtFYxgtx_sendMessage);
}
void Heavy_dpf_example::cIf_CQoRGL7B_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_5qtccESG_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_KPV1AFob_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_ssJSCDrK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_CQoRGL7B, 1, m, &cIf_CQoRGL7B_sendMessage);
}
void Heavy_dpf_example::cIf_Mb5nw3DR_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_xwUoHsSo, 0, m, &cPack_xwUoHsSo_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_wtFYxgtx_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_Mb5nw3DR, 1, m, &cIf_Mb5nw3DR_sendMessage);
}
void Heavy_dpf_example::cMsg_F0kRSmkI_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, 2);
msg_setElementToFrom(m, 1, n, 0);
cSwitchcase_YpS7vvRv_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_dpf_example::cPack_xwUoHsSo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSend_GVz3gDe4_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cVar_W4DWXLFV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 1.0f, 0, m, &cBinop_8dz52u9Z_sendMessage);
}
void Heavy_dpf_example::cSend_GVz3gDe4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_noteout", 0xD1D4AC2, m);
}
void Heavy_dpf_example::cBinop_8dz52u9Z_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_xwUoHsSo, 2, m, &cPack_xwUoHsSo_sendMessage);
}
void Heavy_dpf_example::cSlice_6cAn7djG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cVar_onMessage(_c, &Context(_c)->cVar_XEUhnXhV, 0, m, &cVar_XEUhnXhV_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_25Ghd0z7, 0, m, &cIf_25Ghd0z7_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_jUcgx0L6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cIf_onMessage(_c, &Context(_c)->cIf_GAmmKtJo, 0, m, &cIf_GAmmKtJo_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_i8dZoItn_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_1qqhhVNk_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_3nFIGCtx, 0, m, &cSlice_3nFIGCtx_sendMessage);
break;
}
default: {
cMsg_FHnSu2lH_sendMessage(_c, 0, m);
break;
}
}
}
void Heavy_dpf_example::cSlice_3nFIGCtx_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cSwitchcase_Uzt46vxw_onMessage(_c, NULL, 0, m, NULL);
break;
}
case 1: {
cSwitchcase_Uzt46vxw_onMessage(_c, NULL, 0, m, NULL);
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_Uzt46vxw_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_i4juEjjd, 0, m, &cSlice_i4juEjjd_sendMessage);
break;
}
default: {
cMsg_1FJi2rmv_sendMessage(_c, 0, m);
break;
}
}
}
void Heavy_dpf_example::cSlice_i4juEjjd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 0, m, &cPack_jPoKLiUE_sendMessage);
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 0, m, &cPack_jPoKLiUE_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cVar_swFwKkwC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_w5s8nkUb_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_eWHRwUey, 0, m, &cIf_eWHRwUey_sendMessage);
}
void Heavy_dpf_example::cUnop_YauMmchA_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_ifB8ELD8_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_25Ghd0z7, 1, m, &cIf_25Ghd0z7_sendMessage);
}
void Heavy_dpf_example::cUnop_7t2J2MlL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_ifB8ELD8_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_25Ghd0z7, 1, m, &cIf_25Ghd0z7_sendMessage);
}
void Heavy_dpf_example::cIf_eWHRwUey_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_7t2J2MlL_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_YauMmchA_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_w5s8nkUb_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_eWHRwUey, 1, m, &cIf_eWHRwUey_sendMessage);
}
void Heavy_dpf_example::cVar_7mHmXbxO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_j08aQBwd_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_8cRMzv7p, 0, m, &cIf_8cRMzv7p_sendMessage);
}
void Heavy_dpf_example::cUnop_pQd76iAK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_9hzM89gj_sendMessage);
}
void Heavy_dpf_example::cUnop_a0YamcX6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_9hzM89gj_sendMessage);
}
void Heavy_dpf_example::cIf_8cRMzv7p_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_a0YamcX6_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_pQd76iAK_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_j08aQBwd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_8cRMzv7p, 1, m, &cIf_8cRMzv7p_sendMessage);
}
void Heavy_dpf_example::cIf_25Ghd0z7_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cVar_onMessage(_c, &Context(_c)->cVar_yGByT1dq, 0, m, &cVar_yGByT1dq_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cIf_rmHI0lBi_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 0, m, &cPack_jPoKLiUE_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cIf_KcEtbwfw_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 0, m, &cPack_jPoKLiUE_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cIf_GAmmKtJo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cVar_onMessage(_c, &Context(_c)->cVar_yGByT1dq, 0, m, &cVar_yGByT1dq_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_9hzM89gj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_rmHI0lBi, 1, m, &cIf_rmHI0lBi_sendMessage);
}
void Heavy_dpf_example::cBinop_ifB8ELD8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_KcEtbwfw, 1, m, &cIf_KcEtbwfw_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_GAmmKtJo, 1, m, &cIf_GAmmKtJo_sendMessage);
}
void Heavy_dpf_example::cMsg_39hkaBKJ_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_setElementToFrom(m, 0, n, 1);
msg_setElementToFrom(m, 1, n, 2);
msg_setElementToFrom(m, 2, n, 0);
cSwitchcase_1qqhhVNk_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_dpf_example::cMsg_FHnSu2lH_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_setElementToFrom(m, 0, n, 2);
cIf_onMessage(_c, &Context(_c)->cIf_KcEtbwfw, 0, m, &cIf_KcEtbwfw_sendMessage);
}
void Heavy_dpf_example::cMsg_1FJi2rmv_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_setElementToFrom(m, 0, n, 1);
cIf_onMessage(_c, &Context(_c)->cIf_rmHI0lBi, 0, m, &cIf_rmHI0lBi_sendMessage);
}
void Heavy_dpf_example::cPack_jPoKLiUE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSend_t1ai4h05_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cVar_XEUhnXhV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_f7eAJCMh_sendMessage);
}
void Heavy_dpf_example::cBinop_f7eAJCMh_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_SgVfJxeG_sendMessage);
}
void Heavy_dpf_example::cBinop_SgVfJxeG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 2, m, &cPack_jPoKLiUE_sendMessage);
}
void Heavy_dpf_example::cVar_yGByT1dq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_jPoKLiUE, 1, m, &cPack_jPoKLiUE_sendMessage);
}
void Heavy_dpf_example::cSend_t1ai4h05_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_ctlout", 0xE5E2A040, m);
}
void Heavy_dpf_example::cCast_2OB6tAv4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_XEUhnXhV, 0, m, &cVar_XEUhnXhV_sendMessage);
}
void Heavy_dpf_example::cCast_b036gMRu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_yGByT1dq, 0, m, &cVar_yGByT1dq_sendMessage);
}
void Heavy_dpf_example::cSlice_Cc4ftweA_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cVar_onMessage(_c, &Context(_c)->cVar_vEfKjFKM, 0, m, &cVar_vEfKjFKM_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_GKnbdSF1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cIf_onMessage(_c, &Context(_c)->cIf_l8AZ77OB, 0, m, &cIf_l8AZ77OB_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_W4uhJJ2G_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_yK1ct3x5, 0, m, &cSlice_yK1ct3x5_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_dpf_example::cSlice_yK1ct3x5_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_f54JIHyD, 0, m, &cPack_f54JIHyD_sendMessage);
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_f54JIHyD, 0, m, &cPack_f54JIHyD_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cVar_SbPekxvo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_vTozANTw_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_WYWMmIs9, 0, m, &cIf_WYWMmIs9_sendMessage);
}
void Heavy_dpf_example::cUnop_4JLyScHf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_xuHfc1he_sendMessage);
}
void Heavy_dpf_example::cUnop_tsfDRNiI_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_xuHfc1he_sendMessage);
}
void Heavy_dpf_example::cIf_WYWMmIs9_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_tsfDRNiI_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_4JLyScHf_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_vTozANTw_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_WYWMmIs9, 1, m, &cIf_WYWMmIs9_sendMessage);
}
void Heavy_dpf_example::cIf_l8AZ77OB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_f54JIHyD, 0, m, &cPack_f54JIHyD_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_xuHfc1he_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_l8AZ77OB, 1, m, &cIf_l8AZ77OB_sendMessage);
}
void Heavy_dpf_example::cMsg_GL5voH3F_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, 1);
msg_setElementToFrom(m, 1, n, 0);
cSwitchcase_W4uhJJ2G_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_dpf_example::cPack_f54JIHyD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSend_OJH8drg2_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cVar_vEfKjFKM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_8p3mmzET_sendMessage);
}
void Heavy_dpf_example::cBinop_8p3mmzET_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_CmTrkmSZ_sendMessage);
}
void Heavy_dpf_example::cBinop_CmTrkmSZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_f54JIHyD, 1, m, &cPack_f54JIHyD_sendMessage);
}
void Heavy_dpf_example::cSend_OJH8drg2_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_touchout", 0x476D4387, m);
}
void Heavy_dpf_example::cSlice_r8i8uTTJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cVar_onMessage(_c, &Context(_c)->cVar_DpRyqxcF, 0, m, &cVar_DpRyqxcF_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_g3GkHEW8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cIf_onMessage(_c, &Context(_c)->cIf_2ICJGthl, 0, m, &cIf_2ICJGthl_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_wonxMsw1_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_VIdlDx7S, 0, m, &cSlice_VIdlDx7S_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_dpf_example::cSlice_VIdlDx7S_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_BGYVIlrL, 0, m, &cPack_BGYVIlrL_sendMessage);
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_BGYVIlrL, 0, m, &cPack_BGYVIlrL_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cVar_ZORELtLf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_hItQJlwU_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_m5nYTOgK, 0, m, &cIf_m5nYTOgK_sendMessage);
}
void Heavy_dpf_example::cUnop_LUQUpduS_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_KWQRN4xC_sendMessage);
}
void Heavy_dpf_example::cUnop_ODG9pQm4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_KWQRN4xC_sendMessage);
}
void Heavy_dpf_example::cIf_m5nYTOgK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_ODG9pQm4_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_LUQUpduS_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_hItQJlwU_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_m5nYTOgK, 1, m, &cIf_m5nYTOgK_sendMessage);
}
void Heavy_dpf_example::cIf_2ICJGthl_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_BGYVIlrL, 0, m, &cPack_BGYVIlrL_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_KWQRN4xC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_2ICJGthl, 1, m, &cIf_2ICJGthl_sendMessage);
}
void Heavy_dpf_example::cMsg_JBZMNuTp_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, 1);
msg_setElementToFrom(m, 1, n, 0);
cSwitchcase_wonxMsw1_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_dpf_example::cPack_BGYVIlrL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSend_e54fafHj_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cVar_DpRyqxcF_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_Ekh87tB4_sendMessage);
}
void Heavy_dpf_example::cBinop_Ekh87tB4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_HRmhjbVl_sendMessage);
}
void Heavy_dpf_example::cBinop_HRmhjbVl_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_BGYVIlrL, 1, m, &cPack_BGYVIlrL_sendMessage);
}
void Heavy_dpf_example::cSend_e54fafHj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_bendout", 0xE8458013, m);
}
void Heavy_dpf_example::cSlice_9FMBZIKf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cVar_onMessage(_c, &Context(_c)->cVar_9A6YAgfU, 0, m, &cVar_9A6YAgfU_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSlice_ddagGoys_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cIf_onMessage(_c, &Context(_c)->cIf_NK7rKLSJ, 0, m, &cIf_NK7rKLSJ_sendMessage);
break;
}
case 1: {
break;
}
default: return;
}
}
void Heavy_dpf_example::cSwitchcase_bBtIwvu9_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
switch (msg_getHash(m, 0)) {
case 0x0: { // "0.0"
cSlice_onMessage(_c, &Context(_c)->cSlice_080d2kLN, 0, m, &cSlice_080d2kLN_sendMessage);
break;
}
default: {
break;
}
}
}
void Heavy_dpf_example::cSlice_080d2kLN_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cPack_onMessage(_c, &Context(_c)->cPack_WGvA9xup, 0, m, &cPack_WGvA9xup_sendMessage);
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_WGvA9xup, 0, m, &cPack_WGvA9xup_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cVar_vpyngHC3_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_Va4CkqG9_sendMessage);
cIf_onMessage(_c, &Context(_c)->cIf_lBbDQQni, 0, m, &cIf_lBbDQQni_sendMessage);
}
void Heavy_dpf_example::cUnop_ZWe2idI6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_yeTyIvOZ_sendMessage);
}
void Heavy_dpf_example::cUnop_boUTQzQ6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_yeTyIvOZ_sendMessage);
}
void Heavy_dpf_example::cIf_lBbDQQni_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_boUTQzQ6_sendMessage);
break;
}
case 1: {
cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_ZWe2idI6_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_Va4CkqG9_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_lBbDQQni, 1, m, &cIf_lBbDQQni_sendMessage);
}
void Heavy_dpf_example::cIf_NK7rKLSJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
switch (letIn) {
case 0: {
break;
}
case 1: {
cPack_onMessage(_c, &Context(_c)->cPack_WGvA9xup, 0, m, &cPack_WGvA9xup_sendMessage);
break;
}
default: return;
}
}
void Heavy_dpf_example::cBinop_yeTyIvOZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cIf_onMessage(_c, &Context(_c)->cIf_NK7rKLSJ, 1, m, &cIf_NK7rKLSJ_sendMessage);
}
void Heavy_dpf_example::cMsg_yS3IPMwu_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, 1);
msg_setElementToFrom(m, 1, n, 0);
cSwitchcase_bBtIwvu9_onMessage(_c, NULL, 0, m, NULL);
}
void Heavy_dpf_example::cPack_WGvA9xup_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSend_Pp644YiG_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cVar_9A6YAgfU_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_CBsf5JlD_sendMessage);
}
void Heavy_dpf_example::cBinop_CBsf5JlD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_siElkYOO_sendMessage);
}
void Heavy_dpf_example::cBinop_siElkYOO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cPack_onMessage(_c, &Context(_c)->cPack_WGvA9xup, 1, m, &cPack_WGvA9xup_sendMessage);
}
void Heavy_dpf_example::cSend_Pp644YiG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_pgmout", 0x8753E39E, m);
}
void Heavy_dpf_example::cReceive_Wuo5XOXF_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cVar_onMessage(_c, &Context(_c)->cVar_m8VtMpGk, 0, m, &cVar_m8VtMpGk_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_W4DWXLFV, 0, m, &cVar_W4DWXLFV_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_swFwKkwC, 0, m, &cVar_swFwKkwC_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_7mHmXbxO, 0, m, &cVar_7mHmXbxO_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_2OB6tAv4_sendMessage);
cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_b036gMRu_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_SbPekxvo, 0, m, &cVar_SbPekxvo_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_vEfKjFKM, 0, m, &cVar_vEfKjFKM_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_ZORELtLf, 0, m, &cVar_ZORELtLf_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_DpRyqxcF, 0, m, &cVar_DpRyqxcF_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_vpyngHC3, 0, m, &cVar_vpyngHC3_sendMessage);
cVar_onMessage(_c, &Context(_c)->cVar_9A6YAgfU, 0, m, &cVar_9A6YAgfU_sendMessage);
}
void Heavy_dpf_example::cReceive_0NTHfNka_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_hl5vBHNp, 0, m, &cSlice_hl5vBHNp_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_ylXDwJcZ, 0, m, &cSlice_ylXDwJcZ_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_bA5ci4H6, 0, m, &cSlice_bA5ci4H6_sendMessage);
cMsg_F0kRSmkI_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cReceive_wAZjctal_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_6cAn7djG, 0, m, &cSlice_6cAn7djG_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_jUcgx0L6, 0, m, &cSlice_jUcgx0L6_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_i8dZoItn, 0, m, &cSlice_i8dZoItn_sendMessage);
cMsg_39hkaBKJ_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cReceive_tzc2vC0H_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_Cc4ftweA, 0, m, &cSlice_Cc4ftweA_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_GKnbdSF1, 0, m, &cSlice_GKnbdSF1_sendMessage);
cMsg_GL5voH3F_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cReceive_tGY9yEQM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_r8i8uTTJ, 0, m, &cSlice_r8i8uTTJ_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_g3GkHEW8, 0, m, &cSlice_g3GkHEW8_sendMessage);
cMsg_JBZMNuTp_sendMessage(_c, 0, m);
}
void Heavy_dpf_example::cReceive_bvhtEEQP_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
cSlice_onMessage(_c, &Context(_c)->cSlice_9FMBZIKf, 0, m, &cSlice_9FMBZIKf_sendMessage);
cSlice_onMessage(_c, &Context(_c)->cSlice_ddagGoys, 0, m, &cSlice_ddagGoys_sendMessage);
cMsg_yS3IPMwu_sendMessage(_c, 0, m);
}
/*
* Context Process Implementation
*/
int Heavy_dpf_example::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
// input and output vars
hv_bufferf_t O0, O1;
hv_bufferf_t I0, I1;
// 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);
}
// load input buffers
__hv_load_f(inputBuffers[0]+n, VOf(I0));
__hv_load_f(inputBuffers[1]+n, VOf(I1));
// zero output buffers
__hv_zero_f(VOf(O0));
__hv_zero_f(VOf(O1));
// process all signal functions
__hv_add_f(VIf(I0), VIf(O0), VOf(O0));
__hv_add_f(VIf(I1), 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_dpf_example::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 2 channel(s)
float **const bIn = reinterpret_cast<float **>(hv_alloca(2*sizeof(float *)));
bIn[0] = inputBuffers+(0*n4);
bIn[1] = inputBuffers+(1*n4);
// 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_dpf_example::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 2 channel(s), uninterleave
float *const bIn = reinterpret_cast<float *>(hv_alloca(2*n4*sizeof(float)));
#if HV_SIMD_SSE || HV_SIMD_AVX
for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
__m128 a = _mm_load_ps(inputBuffers+i); // LRLR
__m128 b = _mm_load_ps(inputBuffers+4+i); // LRLR
__m128 x = _mm_shuffle_ps(a, b, _MM_SHUFFLE(2,0,2,0)); // LLLL
__m128 y = _mm_shuffle_ps(a, b, _MM_SHUFFLE(3,1,3,1)); // RRRR
_mm_store_ps(bIn+j, x);
_mm_store_ps(bIn+n4+j, y);
}
#elif HV_SIMD_NEON
for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
float32x4x2_t a = vld2q_f32(inputBuffers+i); // load and uninterleave
vst1q_f32(bIn+j, a.val[0]);
vst1q_f32(bIn+n4+j, a.val[1]);
}
#else // HV_SIMD_NONE
for (int j = 0; j < n4; ++j) {
bIn[0*n4+j] = inputBuffers[0+2*j];
bIn[1*n4+j] = inputBuffers[1+2*j];
}
#endif
// 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