/** * Copyright (c) 2022 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_delay_simple.hpp" #include #define Context(_c) static_cast(_c) /* * C Functions */ extern "C" { HV_EXPORT HeavyContextInterface *hv_delay_simple_new(double sampleRate) { // allocate aligned memory void *ptr = hv_malloc(sizeof(Heavy_delay_simple)); // ensure non-null if (!ptr) return nullptr; // call constructor new(ptr) Heavy_delay_simple(sampleRate); return Context(ptr); } HV_EXPORT HeavyContextInterface *hv_delay_simple_new_with_options(double sampleRate, int poolKb, int inQueueKb, int outQueueKb) { // allocate aligned memory void *ptr = hv_malloc(sizeof(Heavy_delay_simple)); // ensure non-null if (!ptr) return nullptr; // call constructor new(ptr) Heavy_delay_simple(sampleRate, poolKb, inQueueKb, outQueueKb); return Context(ptr); } HV_EXPORT void hv_delay_simple_free(HeavyContextInterface *instance) { // call destructor Context(instance)->~Heavy_delay_simple(); // free memory hv_free(instance); } } // extern "C" /* * Class Functions */ Heavy_delay_simple::Heavy_delay_simple(double sampleRate, int poolKb, int inQueueKb, int outQueueKb) : HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) { numBytes += sTabread_init(&sTabread_OJVVdLuf, &hTable_TFqOKFso, true); numBytes += sTabwrite_init(&sTabwrite_kTfJPrs1, &hTable_TFqOKFso); numBytes += cVar_init_f(&cVar_4cpXTaBY, 0.0f); numBytes += cVar_init_f(&cVar_fRPZcVCt, 0.0f); numBytes += cVar_init_f(&cVar_Om7ifKfd, 0.0f); numBytes += cVar_init_f(&cVar_LnHfGF8V, 0.0f); numBytes += cVar_init_f(&cVar_mOyup5ir, 0.0f); numBytes += cDelay_init(this, &cDelay_OFD5iAqe, 0.0f); numBytes += cDelay_init(this, &cDelay_EI4kKdvf, 0.0f); numBytes += hTable_init(&hTable_TFqOKFso, 256); numBytes += cTabhead_init(&cTabhead_zhu6BFdy, &hTable_TFqOKFso); numBytes += cVar_init_s(&cVar_nONxuBGP, "del-delay1012"); numBytes += cDelay_init(this, &cDelay_FTWI9Lbr, 0.0f); numBytes += cDelay_init(this, &cDelay_4Y58Ksfn, 0.0f); numBytes += cBinop_init(&cBinop_kd9uMvnd, 0.0f); // __mul numBytes += cBinop_init(&cBinop_99kJjPmN, 0.0f); // __sub numBytes += cBinop_init(&cBinop_khIQbSXe, 0.0f); // __max numBytes += cBinop_init(&cBinop_HsqyfMPx, 0.0f); // __sub numBytes += sVarf_init(&sVarf_DXN3F4mN, 0.0f, 0.0f, false); numBytes += sVarf_init(&sVarf_o7lB6W7R, 0.0f, 0.0f, false); numBytes += sVarf_init(&sVarf_4RDRwlaL, 0.0f, 0.0f, false); numBytes += sVarf_init(&sVarf_vL8TEPN9, 0.0f, 0.0f, false); numBytes += sVarf_init(&sVarf_eLw9NCKn, 0.0f, 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_delay_simple::~Heavy_delay_simple() { hTable_free(&hTable_TFqOKFso); } HvTable *Heavy_delay_simple::getTableForHash(hv_uint32_t tableHash) {switch (tableHash) { case 0x4678FF81: return &hTable_TFqOKFso; // del-delay1012 default: return nullptr; } } void Heavy_delay_simple::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) { switch (receiverHash) { case 0x36377AA9: { // Delay_Feedback mq_addMessageByTimestamp(&mq, m, 0, &cReceive_LQwqfjMo_sendMessage); break; } case 0xEE78D101: { // Delay_Time mq_addMessageByTimestamp(&mq, m, 0, &cReceive_UQL9KHRi_sendMessage); break; } case 0x5EFB46D2: { // Dry_Volume mq_addMessageByTimestamp(&mq, m, 0, &cReceive_SIoX2X2C_sendMessage); break; } case 0x677821DA: { // Gain mq_addMessageByTimestamp(&mq, m, 0, &cReceive_eGza5oBR_sendMessage); break; } case 0xEA49B5A: { // Wet_Volume mq_addMessageByTimestamp(&mq, m, 0, &cReceive_ex2b75Oc_sendMessage); break; } case 0xCE5CC65B: { // __hv_init mq_addMessageByTimestamp(&mq, m, 0, &cReceive_AJBhI0kX_sendMessage); break; } case 0xD8A3CB65: { // dfeed1 mq_addMessageByTimestamp(&mq, m, 0, &cReceive_iG7Q7Uzr_sendMessage); break; } case 0xAEFD47D3: { // dryvol mq_addMessageByTimestamp(&mq, m, 0, &cReceive_kJYDDgog_sendMessage); break; } case 0x37BBAC62: { // dtime1 mq_addMessageByTimestamp(&mq, m, 0, &cReceive_kE9u8lIG_sendMessage); break; } case 0xCA9AE94A: { // dvol1 mq_addMessageByTimestamp(&mq, m, 0, &cReceive_pzAN0z6v_sendMessage); break; } default: return; } } int Heavy_delay_simple::getParameterInfo(int index, HvParameterInfo *info) { if (info != nullptr) { switch (index) { case 0: { info->name = "Delay_Feedback"; info->hash = 0x36377AA9; info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN; info->minVal = 0.0f; info->maxVal = 1.0f; info->defaultVal = 0.25f; break; } case 1: { info->name = "Delay_Time"; info->hash = 0xEE78D101; info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN; info->minVal = 0.0f; info->maxVal = 5000.0f; info->defaultVal = 500.0f; break; } case 2: { info->name = "Dry_Volume"; info->hash = 0x5EFB46D2; info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN; info->minVal = 0.0f; info->maxVal = 1.0f; info->defaultVal = 0.75f; break; } case 3: { info->name = "Gain"; info->hash = 0x677821DA; info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN; info->minVal = 0.0f; info->maxVal = 1.0f; info->defaultVal = 0.75f; break; } case 4: { info->name = "Wet_Volume"; info->hash = 0xEA49B5A; info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN; info->minVal = 0.0f; info->maxVal = 1.0f; info->defaultVal = 0.75f; 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 5; } /* * Send Function Implementations */ void Heavy_delay_simple::cVar_4cpXTaBY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cSend_wldZJDJM_sendMessage(_c, 0, m); } void Heavy_delay_simple::cVar_fRPZcVCt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cSend_dFhbvIPr_sendMessage(_c, 0, m); } void Heavy_delay_simple::cVar_Om7ifKfd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cSend_4A35hG1G_sendMessage(_c, 0, m); } void Heavy_delay_simple::cVar_LnHfGF8V_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { sVarf_onMessage(_c, &Context(_c)->sVarf_eLw9NCKn, m); } void Heavy_delay_simple::cVar_mOyup5ir_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cSend_jiugLxbD_sendMessage(_c, 0, m); } void Heavy_delay_simple::cMsg_hdrV3jKk_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_B288dglo_sendMessage); } void Heavy_delay_simple::cSystem_B288dglo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_NAf7xjjy_sendMessage); } void Heavy_delay_simple::cDelay_OFD5iAqe_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) { cDelay_clearExecutingMessage(&Context(_c)->cDelay_OFD5iAqe, m); cDelay_onMessage(_c, &Context(_c)->cDelay_EI4kKdvf, 0, m, &cDelay_EI4kKdvf_sendMessage); cDelay_onMessage(_c, &Context(_c)->cDelay_OFD5iAqe, 0, m, &cDelay_OFD5iAqe_sendMessage); sTabwrite_onMessage(_c, &Context(_c)->sTabwrite_kTfJPrs1, 1, m, NULL); } void Heavy_delay_simple::cDelay_EI4kKdvf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) { cDelay_clearExecutingMessage(&Context(_c)->cDelay_EI4kKdvf, m); cMsg_o1Fk4mWr_sendMessage(_c, 0, m); } void Heavy_delay_simple::cBinop_4MyuHNhK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cMsg_clwxczYs_sendMessage(_c, 0, m); } void Heavy_delay_simple::hTable_TFqOKFso_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cMsg_DlDeZMFB_sendMessage(_c, 0, m); cDelay_onMessage(_c, &Context(_c)->cDelay_OFD5iAqe, 2, m, &cDelay_OFD5iAqe_sendMessage); cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_g87DeymK_sendMessage); } void Heavy_delay_simple::cMsg_clwxczYs_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_TFqOKFso, 0, m, &hTable_TFqOKFso_sendMessage); } void Heavy_delay_simple::cBinop_NAf7xjjy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 5000.0f, 0, m, &cBinop_4MyuHNhK_sendMessage); } void Heavy_delay_simple::cMsg_o1Fk4mWr_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_TFqOKFso, 0, m, &hTable_TFqOKFso_sendMessage); } void Heavy_delay_simple::cCast_g87DeymK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cDelay_onMessage(_c, &Context(_c)->cDelay_OFD5iAqe, 0, m, &cDelay_OFD5iAqe_sendMessage); } void Heavy_delay_simple::cMsg_DlDeZMFB_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(HV_N_SIMD)); cDelay_onMessage(_c, &Context(_c)->cDelay_EI4kKdvf, 2, m, &cDelay_EI4kKdvf_sendMessage); } void Heavy_delay_simple::cTabhead_zhu6BFdy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_99kJjPmN, HV_BINOP_SUBTRACT, 0, m, &cBinop_99kJjPmN_sendMessage); } void Heavy_delay_simple::cMsg_c68iDIVD_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_LlBI3RTT_sendMessage); } void Heavy_delay_simple::cSystem_LlBI3RTT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_qp875S9R_sendMessage); } void Heavy_delay_simple::cVar_nONxuBGP_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cMsg_2Y6gSDxh_sendMessage(_c, 0, m); } void Heavy_delay_simple::cDelay_FTWI9Lbr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) { cDelay_clearExecutingMessage(&Context(_c)->cDelay_FTWI9Lbr, m); cDelay_onMessage(_c, &Context(_c)->cDelay_4Y58Ksfn, 0, m, &cDelay_4Y58Ksfn_sendMessage); sTabread_onMessage(_c, &Context(_c)->sTabread_OJVVdLuf, 0, m, &sTabread_OJVVdLuf_sendMessage); } void Heavy_delay_simple::cDelay_4Y58Ksfn_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) { cDelay_clearExecutingMessage(&Context(_c)->cDelay_4Y58Ksfn, m); sTabread_onMessage(_c, &Context(_c)->sTabread_OJVVdLuf, 0, m, &sTabread_OJVVdLuf_sendMessage); cDelay_onMessage(_c, &Context(_c)->cDelay_4Y58Ksfn, 0, m, &cDelay_4Y58Ksfn_sendMessage); } void Heavy_delay_simple::sTabread_OJVVdLuf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { switch (letIn) { case 0: { break; } case 1: { cBinop_onMessage(_c, &Context(_c)->cBinop_HsqyfMPx, HV_BINOP_SUBTRACT, 0, m, &cBinop_HsqyfMPx_sendMessage); break; } default: return; } } void Heavy_delay_simple::cBinop_kd9uMvnd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_khIQbSXe, HV_BINOP_MAX, 0, m, &cBinop_khIQbSXe_sendMessage); } void Heavy_delay_simple::cBinop_qp875S9R_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_kd9uMvnd, HV_BINOP_MULTIPLY, 0, m, &cBinop_kd9uMvnd_sendMessage); } void Heavy_delay_simple::cBinop_99kJjPmN_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cMsg_60hMCcpx_sendMessage(_c, 0, m); sTabread_onMessage(_c, &Context(_c)->sTabread_OJVVdLuf, 0, m, &sTabread_OJVVdLuf_sendMessage); cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_zoAHkSwC_sendMessage); } void Heavy_delay_simple::cSystem_kPqFOU4H_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_HsqyfMPx, HV_BINOP_SUBTRACT, 1, m, &cBinop_HsqyfMPx_sendMessage); cDelay_onMessage(_c, &Context(_c)->cDelay_4Y58Ksfn, 2, m, &cDelay_4Y58Ksfn_sendMessage); } void Heavy_delay_simple::cMsg_2Y6gSDxh_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_kPqFOU4H_sendMessage); } void Heavy_delay_simple::cMsg_60hMCcpx_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_FTWI9Lbr, 0, m, &cDelay_FTWI9Lbr_sendMessage); cDelay_onMessage(_c, &Context(_c)->cDelay_4Y58Ksfn, 0, m, &cDelay_4Y58Ksfn_sendMessage); } void Heavy_delay_simple::cMsg_2y7SxePc_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(HV_N_SIMD)); cBinop_onMessage(_c, &Context(_c)->cBinop_khIQbSXe, HV_BINOP_MAX, 1, m, &cBinop_khIQbSXe_sendMessage); } void Heavy_delay_simple::cBinop_khIQbSXe_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_99kJjPmN, HV_BINOP_SUBTRACT, 1, m, &cBinop_99kJjPmN_sendMessage); } void Heavy_delay_simple::cCast_zoAHkSwC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cDelay_onMessage(_c, &Context(_c)->cDelay_FTWI9Lbr, 0, m, &cDelay_FTWI9Lbr_sendMessage); } void Heavy_delay_simple::cBinop_H69XkGIL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cDelay_onMessage(_c, &Context(_c)->cDelay_FTWI9Lbr, 2, m, &cDelay_FTWI9Lbr_sendMessage); } void Heavy_delay_simple::cBinop_HsqyfMPx_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, -1.0f, 0, m, &cBinop_H69XkGIL_sendMessage); } void Heavy_delay_simple::cCast_spzeS2Y3_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_nONxuBGP, 0, m, &cVar_nONxuBGP_sendMessage); cMsg_c68iDIVD_sendMessage(_c, 0, m); cTabhead_onMessage(_c, &Context(_c)->cTabhead_zhu6BFdy, 0, m, &cTabhead_zhu6BFdy_sendMessage); } void Heavy_delay_simple::cSend_wldZJDJM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cReceive_kE9u8lIG_sendMessage(_c, 0, m); } void Heavy_delay_simple::cSend_dFhbvIPr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cReceive_pzAN0z6v_sendMessage(_c, 0, m); } void Heavy_delay_simple::cSend_4A35hG1G_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cReceive_iG7Q7Uzr_sendMessage(_c, 0, m); } void Heavy_delay_simple::cSend_jiugLxbD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cReceive_kJYDDgog_sendMessage(_c, 0, m); } void Heavy_delay_simple::cReceive_kE9u8lIG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cBinop_onMessage(_c, &Context(_c)->cBinop_kd9uMvnd, HV_BINOP_MULTIPLY, 1, m, &cBinop_kd9uMvnd_sendMessage); cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_spzeS2Y3_sendMessage); } void Heavy_delay_simple::cReceive_pzAN0z6v_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { sVarf_onMessage(_c, &Context(_c)->sVarf_o7lB6W7R, m); } void Heavy_delay_simple::cReceive_iG7Q7Uzr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { sVarf_onMessage(_c, &Context(_c)->sVarf_4RDRwlaL, m); } void Heavy_delay_simple::cReceive_kJYDDgog_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { sVarf_onMessage(_c, &Context(_c)->sVarf_vL8TEPN9, m); } void Heavy_delay_simple::cReceive_AJBhI0kX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cMsg_hdrV3jKk_sendMessage(_c, 0, m); cMsg_2y7SxePc_sendMessage(_c, 0, m); cVar_onMessage(_c, &Context(_c)->cVar_nONxuBGP, 0, m, &cVar_nONxuBGP_sendMessage); cMsg_c68iDIVD_sendMessage(_c, 0, m); cTabhead_onMessage(_c, &Context(_c)->cTabhead_zhu6BFdy, 0, m, &cTabhead_zhu6BFdy_sendMessage); } void Heavy_delay_simple::cReceive_eGza5oBR_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_LnHfGF8V, 0, m, &cVar_LnHfGF8V_sendMessage); } void Heavy_delay_simple::cReceive_SIoX2X2C_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_mOyup5ir, 0, m, &cVar_mOyup5ir_sendMessage); } void Heavy_delay_simple::cReceive_UQL9KHRi_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_4cpXTaBY, 0, m, &cVar_4cpXTaBY_sendMessage); } void Heavy_delay_simple::cReceive_ex2b75Oc_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_fRPZcVCt, 0, m, &cVar_fRPZcVCt_sendMessage); } void Heavy_delay_simple::cReceive_LQwqfjMo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) { cVar_onMessage(_c, &Context(_c)->cVar_Om7ifKfd, 0, m, &cVar_Om7ifKfd_sendMessage); } /* * Context Process Implementation */ int Heavy_delay_simple::process(float **inputBuffers, float **outputBuffers, int n) { while (hLp_hasData(&inQueue)) { hv_uint32_t numBytes = 0; ReceiverMessagePair *p = reinterpret_cast(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; // 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(I1), VOf(Bf0)); __hv_varread_f(&sVarf_eLw9NCKn, VOf(Bf1)); __hv_mul_f(VIf(Bf0), VIf(Bf1), VOf(Bf1)); __hv_tabread_f(&sTabread_OJVVdLuf, VOf(Bf0)); __hv_varread_f(&sVarf_o7lB6W7R, VOf(Bf2)); __hv_varread_f(&sVarf_vL8TEPN9, VOf(Bf3)); __hv_mul_f(VIf(Bf1), VIf(Bf3), VOf(Bf3)); __hv_fma_f(VIf(Bf0), VIf(Bf2), VIf(Bf3), VOf(Bf3)); __hv_varread_f(&sVarf_DXN3F4mN, VOf(Bf2)); __hv_add_f(VIf(Bf1), VIf(Bf2), VOf(Bf2)); __hv_tabwrite_f(&sTabwrite_kTfJPrs1, VIf(Bf2)); __hv_varread_f(&sVarf_4RDRwlaL, VOf(Bf2)); __hv_mul_f(VIf(Bf0), VIf(Bf2), VOf(Bf2)); __hv_varwrite_f(&sVarf_DXN3F4mN, VIf(Bf2)); __hv_add_f(VIf(Bf3), VIf(O0), VOf(O0)); __hv_add_f(VIf(Bf3), 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_delay_simple::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(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(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_delay_simple::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(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(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; }