/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-plugins-beat-breather * Created on: 14 авг 2023 г. * * lsp-plugins-beat-breather is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-plugins-beat-breather is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-plugins-beat-breather. If not, see . */ #include #include #include #include #include #include #include #include #include #include namespace lsp { namespace plugins { /* The size of temporary buffer for audio processing */ static constexpr size_t BUFFER_SIZE = 0x1000; //--------------------------------------------------------------------- // Plugin factory static const meta::plugin_t *plugins[] = { &meta::beat_breather_mono, &meta::beat_breather_stereo }; static plug::Module *plugin_factory(const meta::plugin_t *meta) { return new beat_breather(meta); } static plug::Factory factory(plugin_factory, plugins, 2); //--------------------------------------------------------------------- // Implementation beat_breather::beat_breather(const meta::plugin_t *meta): Module(meta) { nChannels = 1; if (!strcmp(meta->uid, meta::beat_breather_stereo.uid)) nChannels = 2; vChannels = NULL; bStereoSplit = false; fInGain = GAIN_AMP_0_DB; fDryGain = GAIN_AMP_M_INF_DB; fWetGain = GAIN_AMP_0_DB; fZoom = GAIN_AMP_0_DB; vAnalyze[0] = NULL; vAnalyze[1] = NULL; vAnalyze[2] = NULL; vAnalyze[3] = NULL; for (size_t i=0; inBandId = i + 1; s->fFrequency = 0.0f; s->bEnabled = false; s->pEnable = NULL; s->pFrequency = NULL; } vBuffer = NULL; vFftFreqs = NULL; vFftIndexes = NULL; vPdMesh = NULL; vPfMesh = NULL; vBpMesh = NULL; pBypass = NULL; pInGain = NULL; pDryGain = NULL; pWetGain = NULL; pDryWet = NULL; pOutGain = NULL; pStereoSplit = NULL; pFFTReactivity = NULL; pFFTShift = NULL; pZoom = NULL; pIDisplay = NULL; pData = NULL; } beat_breather::~beat_breather() { do_destroy(); } void beat_breather::destroy() { Module::destroy(); do_destroy(); } void beat_breather::do_destroy() { // Destroy channels if (vChannels != NULL) { for (size_t i=0; isBypass.destroy(); c->sCrossover.destroy(); c->sDelay.destroy(); c->sDryDelay.destroy(); for (size_t j=0; jvBands[j]; b->sDelay.destroy(); b->sPdLong.destroy(); b->sPdShort.destroy(); b->sPdDelay.destroy(); b->sPdMeter.destroy(); b->sPf.destroy(); b->sPfDelay.destroy(); b->sBp.destroy(); b->sBpScDelay.destroy(); b->sBpDelay.destroy(); } } vChannels = NULL; } // Destroy inline display buffer if (pIDisplay != NULL) { pIDisplay->destroy(); pIDisplay = NULL; } // Free previously allocated data chunk if (pData != NULL) { free_aligned(pData); pData = NULL; } } void beat_breather::init(plug::IWrapper *wrapper, plug::IPort **ports) { // Call parent class for initialization Module::init(wrapper, ports); // Initialize analyzer size_t an_cid = 0; if (!sAnalyzer.init(2*nChannels, meta::beat_breather::FFT_ANALYZER_RANK, MAX_SAMPLE_RATE, meta::beat_breather::FFT_ANALYZER_RATE)) return; sAnalyzer.set_rank(meta::beat_breather::FFT_ANALYZER_RANK); sAnalyzer.set_activity(false); sAnalyzer.set_envelope(dspu::envelope::WHITE_NOISE); sAnalyzer.set_window(meta::beat_breather::FFT_ANALYZER_WINDOW); sAnalyzer.set_rate(meta::beat_breather::FFT_ANALYZER_RATE); sCounter.set_frequency(meta::beat_breather::FFT_ANALYZER_RATE, true); // Allocate data const size_t szof_channels = align_size(sizeof(channel_t) * nChannels, DEFAULT_ALIGN); const size_t szof_buffer = align_size(sizeof(float) * BUFFER_SIZE, DEFAULT_ALIGN); const size_t szof_fft = align_size(sizeof(float) * meta::beat_breather::FFT_MESH_POINTS, DEFAULT_ALIGN); const size_t szof_ffti = align_size(sizeof(uint32_t) * meta::beat_breather::FFT_MESH_POINTS, DEFAULT_ALIGN); const size_t szof_curve = align_size(sizeof(float) * meta::beat_breather::CURVE_MESH_POINTS, DEFAULT_ALIGN); const size_t szof_time = align_size(sizeof(float) * meta::beat_breather::TIME_MESH_POINTS, DEFAULT_ALIGN); const size_t to_alloc = szof_channels + // vChannels szof_buffer + // vBuffer szof_fft + // vFftFreqs szof_ffti + // vFftIndexes szof_time + // vPdMesh szof_curve + // vPfMesh szof_curve + // vBpMesh nChannels * ( szof_buffer + // channel_t::vInData szof_buffer + // channel_t::vOutData szof_fft + // channel_t::vFreqChart meta::beat_breather::BANDS_MAX * ( szof_buffer + // band_t::vInData szof_buffer + // band_t::vPdData szof_buffer + // band_t::vPfData szof_buffer // band_t::vBpData ) ) + meta::beat_breather::BANDS_MAX * ( szof_fft + // band_t::vFreqChart (only for left channel) szof_curve + // band_t::vPfMesh (only for left channel) szof_curve // band_t::vBpMesh (only for left channel) ); uint8_t *ptr = alloc_aligned(pData, to_alloc); if (ptr == NULL) return; lsp_guard_assert(uint8_t *ptr_check = &ptr[to_alloc]); vChannels = advance_ptr_bytes(ptr, szof_channels); vBuffer = advance_ptr_bytes(ptr, szof_buffer); vFftFreqs = advance_ptr_bytes(ptr, szof_fft); vFftIndexes = advance_ptr_bytes(ptr, szof_ffti); vPdMesh = advance_ptr_bytes(ptr, szof_time); vPfMesh = advance_ptr_bytes(ptr, szof_curve); vBpMesh = advance_ptr_bytes(ptr, szof_curve); // Initialize channels for (size_t i=0; isBypass.construct(); c->sCrossover.construct(); c->sDelay.construct(); c->sDryDelay.construct(); for (size_t j=0; jvBands[j]; b->sDelay.construct(); b->sPdLong.construct(); if (!b->sPdLong.init(1, meta::beat_breather::PD_LONG_RMS_MAX)) return; b->sPdShort.construct(); if (!b->sPdShort.init(1, meta::beat_breather::PD_SHORT_RMS_MAX)) return; b->sPdDelay.construct(); b->sPdMeter.construct(); b->sPf.construct(); b->sPfDelay.construct(); b->sBp.construct(); b->sBpScDelay.construct(); b->sBpDelay.construct(); b->nOldMode = BAND_OFF; b->nMode = BAND_OFF; b->fGain = GAIN_AMP_0_DB; b->fInLevel = GAIN_AMP_M_INF_DB; b->fOutLevel = GAIN_AMP_M_INF_DB; b->fReduction = GAIN_AMP_0_DB; b->nSync = SYNC_ALL; b->fPdMakeup = GAIN_AMP_0_DB; b->fPdLevel = GAIN_AMP_M_INF_DB; b->fPfInGain = GAIN_AMP_M_INF_DB; b->fPfOutGain = GAIN_AMP_M_INF_DB; b->fPfReduction = GAIN_AMP_M_INF_DB; b->fBpMakeup = GAIN_AMP_0_DB; b->fBpInGain = GAIN_AMP_M_INF_DB; b->fBpOutGain = GAIN_AMP_M_INF_DB; b->fBpReduction = GAIN_AMP_M_INF_DB; b->vInData = advance_ptr_bytes(ptr, szof_buffer); b->vPdData = advance_ptr_bytes(ptr, szof_buffer); b->vPfData = advance_ptr_bytes(ptr, szof_buffer); b->vBpData = advance_ptr_bytes(ptr, szof_buffer); if (i == 0) { b->vFreqChart = advance_ptr_bytes(ptr, szof_fft); b->vPfMesh = advance_ptr_bytes(ptr, szof_curve); b->vBpMesh = advance_ptr_bytes(ptr, szof_curve); } else { b->vFreqChart = NULL; b->vPfMesh = NULL; b->vBpMesh = NULL; } b->pSolo = NULL; b->pMute = NULL; b->pListen = NULL; b->pLpfSlope = NULL; b->pHpfSlope = NULL; b->pFlatten = NULL; b->pOutGain = NULL; b->pFreqEnd = NULL; b->pFreqMesh = NULL; b->pInLevel = NULL; b->pOutLevel = NULL; b->pPdLongTime = NULL; b->pPdShortTime = NULL; b->pPdBias = NULL; b->pPdMakeup = NULL; b->pPdMesh = NULL; b->pPfLookahead = NULL; b->pPfAttack = NULL; b->pPfRelease = NULL; b->pPfThreshold = NULL; b->pPfReduction = NULL; b->pPfZone = NULL; b->pPfMesh = NULL; b->pPfEnvLevel = NULL; b->pPfCurveLevel = NULL; b->pPfGainLevel = NULL; b->pBpAttack = NULL; b->pBpRelease = NULL; b->pBpTimeShift = NULL; b->pBpThreshold = NULL; b->pBpRatio = NULL; b->pBpMaxGain = NULL; b->pBpMesh = NULL; b->pBpEnvLevel = NULL; b->pBpCurveLevel = NULL; b->pBpGainLevel = NULL; } c->nAnIn = an_cid++; c->nAnOut = an_cid++; c->fInLevel = GAIN_AMP_M_INF_DB; c->fOutLevel = GAIN_AMP_M_INF_DB; c->vIn = NULL; c->vOut = NULL; c->vInData = advance_ptr_bytes(ptr, szof_buffer); c->vOutData = advance_ptr_bytes(ptr, szof_buffer); c->vFreqChart = advance_ptr_bytes(ptr, szof_fft); vAnalyze[c->nAnIn] = c->vInData; vAnalyze[c->nAnOut] = c->vOutData; c->pIn = NULL; c->pOut = NULL; c->pInLevel = NULL; c->pOutLevel = NULL; c->pInFft = NULL; c->pOutFft = NULL; c->pInMesh = NULL; c->pOutMesh = NULL; c->pFreqMesh = NULL; } // Check bounds lsp_assert(ptr <= ptr_check); // Bind ports size_t port_id = 0; // Input ports lsp_trace("Binding input ports"); for (size_t i=0; i 1) BIND_PORT(pStereoSplit); // Channel meters lsp_trace("Binding channel meters"); for (size_t i=0; ipInLevel); BIND_PORT(c->pOutLevel); BIND_PORT(c->pInFft); BIND_PORT(c->pOutFft); BIND_PORT(c->pInMesh); BIND_PORT(c->pOutMesh); BIND_PORT(c->pFreqMesh); } // Splits lsp_trace("Binding split ports"); for (size_t i=0; ipEnable); BIND_PORT(s->pFrequency); } // Band controls lsp_trace("Binding band ports"); for (size_t i=0; ivBands[j]; if (i > 0) { band_t *sb = &vChannels[0].vBands[j]; b->pSolo = sb->pSolo; b->pMute = sb->pMute; b->pListen = sb->pListen; b->pLpfSlope = sb->pLpfSlope; b->pHpfSlope = sb->pHpfSlope; b->pFlatten = sb->pFlatten; b->pOutGain = sb->pOutGain; b->pFreqEnd = sb->pFreqEnd; b->pFreqMesh = NULL; b->pPdLongTime = sb->pPdLongTime; b->pPdShortTime = sb->pPdShortTime; b->pPdBias = sb->pPdBias; b->pPdMakeup = sb->pPdMakeup; b->pPfLookahead = sb->pPfLookahead; b->pPfAttack = sb->pPfAttack; b->pPfRelease = sb->pPfRelease; b->pPfThreshold = sb->pPfThreshold; b->pPfReduction = sb->pPfReduction; b->pPfZone = sb->pPfZone; b->pPfMesh = sb->pPfMesh; b->pBpAttack = sb->pBpAttack; b->pBpRelease = sb->pBpRelease; b->pBpTimeShift = sb->pBpTimeShift; b->pBpThreshold = sb->pBpThreshold; b->pBpRatio = sb->pBpRatio; b->pBpMaxGain = sb->pBpMaxGain; b->pBpMesh = sb->pBpMesh; } else { BIND_PORT(b->pSolo); BIND_PORT(b->pMute); BIND_PORT(b->pListen); BIND_PORT(b->pLpfSlope); BIND_PORT(b->pHpfSlope); BIND_PORT(b->pFlatten); BIND_PORT(b->pOutGain); BIND_PORT(b->pFreqEnd); BIND_PORT(b->pFreqMesh); BIND_PORT(b->pPdLongTime); BIND_PORT(b->pPdShortTime); BIND_PORT(b->pPdBias); BIND_PORT(b->pPdMakeup); BIND_PORT(b->pPfLookahead); BIND_PORT(b->pPfAttack); BIND_PORT(b->pPfRelease); BIND_PORT(b->pPfThreshold); BIND_PORT(b->pPfReduction); BIND_PORT(b->pPfZone); BIND_PORT(b->pPfMesh); BIND_PORT(b->pBpAttack); BIND_PORT(b->pBpRelease); BIND_PORT(b->pBpTimeShift); BIND_PORT(b->pBpThreshold); BIND_PORT(b->pBpRatio); BIND_PORT(b->pBpMaxGain); BIND_PORT(b->pBpMesh); } } } // Band meters lsp_trace("Binding band meters"); for (size_t i=0; ivBands[j]; BIND_PORT(b->pInLevel); BIND_PORT(b->pOutLevel); BIND_PORT(b->pPdMesh); BIND_PORT(b->pPfEnvLevel); BIND_PORT(b->pPfCurveLevel); BIND_PORT(b->pPfGainLevel); BIND_PORT(b->pBpEnvLevel); BIND_PORT(b->pBpCurveLevel); BIND_PORT(b->pBpGainLevel); } } float delta; // Initialize coordinates for Peak Detector mesh delta = meta::beat_breather::TIME_HISTORY_MAX / (meta::beat_breather::TIME_MESH_POINTS-1); for (size_t i=0; isBypass.init(sr); c->sDelay.init(max_delay_fft + max_delay_pd + max_delay_pf + max_delay_bp + BUFFER_SIZE); c->sDryDelay.init(max_delay_fft + max_delay_pd + max_delay_pf + max_delay_bp + BUFFER_SIZE); if (fft_rank != c->sCrossover.rank()) { c->sCrossover.init(fft_rank, meta::beat_breather::BANDS_MAX); for (size_t j=0; jsCrossover.set_handler(j, process_band, this, c); c->sCrossover.set_rank(fft_rank); c->sCrossover.set_phase(float(i) / float(nChannels)); } c->sCrossover.set_sample_rate(sr); for (size_t j=0; jvBands[j]; b->sDelay.init(max_delay_pd + max_delay_pf + max_delay_bp); b->sPdLong.set_sample_rate(sr); b->sPdShort.set_sample_rate(sr); b->sPdDelay.init(max_delay_pd); b->sPdMeter.init(meta::beat_breather::TIME_MESH_POINTS, samples_per_dot); b->sPf.set_sample_rate(sr); b->sPfDelay.init(max_delay_pf); b->sBp.set_sample_rate(sr); b->sBpScDelay.init(max_delay_bp); b->sBpDelay.init(max_delay_pd + max_delay_pf + max_delay_bp); } } // Commit sample rate to analyzer sAnalyzer.set_sample_rate(sr); } int beat_breather::compare_splits(const void *a1, const void *a2, void *data) { const split_t * const * s1 = reinterpret_cast(a1); const split_t * const * s2 = reinterpret_cast(a2); if ((*s1)->fFrequency < (*s2)->fFrequency) return -1; else if ((*s1)->fFrequency > (*s2)->fFrequency) return 1; return 0; } beat_breather::band_mode_t beat_breather::decode_band_mode(size_t mode) { switch (mode) { case meta::beat_breather::LISTEN_CROSSOVER: return BAND_BF; case meta::beat_breather::LISTEN_RMS: return BAND_PD; case meta::beat_breather::LISTEN_PUNCH: return BAND_PF; case meta::beat_breather::LISTEN_BEAT: return BAND_BP; default: break; } return BAND_OFF; } void beat_breather::update_settings() { // Configure global parameters float dry_gain = pDryGain->value(); float wet_gain = pWetGain->value(); float drywet = pDryWet->value() * 0.01f; float out_gain = pOutGain->value(); bStereoSplit = ((nChannels > 1) && (pStereoSplit != NULL)) ? pStereoSplit->value() >= 0.5f : false; fInGain = pInGain->value(); fDryGain = (dry_gain * drywet + 1.0f - drywet) * out_gain; fWetGain = wet_gain * drywet * out_gain; fZoom = pZoom->value(); size_t an_channels = 0; bool bypass = pBypass->value() >= 0.5f; bool sync = false; // Update analyzer settings for (size_t i=0; inAnIn, c->pInFft->value() >= 0.5f); sAnalyzer.enable_channel(c->nAnOut, c->pOutFft->value() >= 0.5f); if (sAnalyzer.channel_active(c->nAnIn)) an_channels ++; if (sAnalyzer.channel_active(c->nAnOut)) an_channels ++; } // Update analyzer parameters sAnalyzer.set_reactivity(pFFTReactivity->value()); if (pFFTShift != NULL) sAnalyzer.set_shift(dspu::db_to_gain(pFFTShift->value()) * 100.0f); sAnalyzer.set_activity(an_channels > 0); if (sAnalyzer.needs_reconfiguration()) { sAnalyzer.reconfigure(); sAnalyzer.get_frequencies( vFftFreqs, vFftIndexes, SPEC_FREQ_MIN, SPEC_FREQ_MAX, meta::beat_breather::FFT_MESH_POINTS); sync = true; } // Configure splits and their order size_t nsplits = 0; split_t *vsplits[meta::beat_breather::BANDS_MAX]; for (size_t i=0; inBandId = i + 1; sp->bEnabled = sp->pEnable->value() >= 0.5f; sp->fFrequency = sp->pFrequency->value(); if (sp->bEnabled) vsplits[nsplits++] = sp; } if (nsplits > 1) lsp::qsort_r(vsplits, nsplits, sizeof(split_t *), compare_splits, NULL); // Configure channels size_t max_band_latency = 0; for (size_t i=0; isBypass.set_bypass(bypass); // Form the list of bands for (size_t j=0; jvBands[j]; b->nOldMode = b->nMode; b->nMode = BAND_OFF; } // Configure active frequency bands for (size_t j=0; j<=nsplits; ++j) { size_t band_id = (j > 0) ? vsplits[j-1]->nBandId : 0; band_t *b = &c->vBands[band_id]; b->nMode = decode_band_mode(b->pListen->value()); // Configure hi-pass filter if (j > 0) { c->sCrossover.enable_hpf(band_id, true); c->sCrossover.set_hpf_frequency(band_id, vsplits[j-1]->fFrequency); c->sCrossover.set_hpf_slope(band_id, - b->pHpfSlope->value()); } else c->sCrossover.disable_hpf(band_id); // Configure lo-pass filter if (j < nsplits) { c->sCrossover.enable_lpf(band_id, true); c->sCrossover.set_lpf_frequency(band_id, vsplits[j]->fFrequency); c->sCrossover.set_lpf_slope(band_id, - b->pLpfSlope->value()); b->pFreqEnd->set_value(vsplits[j]->fFrequency); } else { c->sCrossover.disable_lpf(band_id); b->pFreqEnd->set_value(fSampleRate * 0.5f); } c->sCrossover.set_flatten(band_id, dspu::db_to_gain(-b->pFlatten->value())); // Check solo option if (b->pSolo->value() >= 0.5f) has_solo = true; } // Configure bands for (size_t j=0; jvBands[j]; bool solo = b->pSolo->value() >= 0.5f; bool mute = ((has_solo) && (!solo)) ? true : b->pMute->value() >= 0.5f; if ((mute) && (b->nMode != BAND_OFF)) b->nMode = BAND_MUTE; b->fGain = b->pOutGain->value(); // Do we have hi-pass filter? c->sCrossover.enable_band(j, b->nMode != BAND_OFF); // Update Peak detector configuration float pd_long = b->pPdLongTime->value(); float pd_short = b->pPdShortTime->value(); size_t pd_short_latency = dspu::millis_to_samples(fSampleRate, pd_long - pd_short) / 2; size_t pd_latency = dspu::millis_to_samples(fSampleRate, pd_long) / 2; float pd_bias = dspu::db_to_gain(b->pPdBias->value()); b->fPdMakeup = dspu::db_to_gain(b->pPdMakeup->value() + meta::beat_breather::PD_MAKEUP_SHIFT); b->sPdLong.set_mode(dspu::SCM_RMS); b->sPdLong.set_source(dspu::SCS_MIDDLE); b->sPdLong.set_reactivity(pd_long); b->sPdLong.set_gain(GAIN_AMP_0_DB); b->sPdShort.set_mode(dspu::SCM_RMS); b->sPdShort.set_source(dspu::SCS_MIDDLE); b->sPdShort.set_reactivity(pd_short); b->sPdShort.set_gain(pd_bias); b->sPdDelay.set_delay(pd_short_latency); b->sPdMeter.set_method(dspu::MM_ABS_MAXIMUM); if ((b->nOldMode != BAND_OFF) && (b->nMode == BAND_OFF)) b->sPdMeter.clear(); // Update peak filter configuration float pf_thresh = b->pPfThreshold->value(); float pf_zone = b->pPfZone->value(); size_t pf_latency = dspu::millis_to_samples(fSampleRate, b->pPfLookahead->value()); b->sPf.set_attack(b->pPfAttack->value()); b->sPf.set_release(b->pPfRelease->value()); b->sPf.set_threshold(pf_thresh, pf_thresh); b->sPf.set_zone(pf_zone, pf_zone); b->sPf.set_reduction(b->pPfReduction->value()); if (b->sPf.modified()) { b->sPf.update_settings(); if (i == 0) b->sPf.curve(b->vPfMesh, vPfMesh, meta::beat_breather::CURVE_MESH_POINTS, false); b->nSync |= SYNC_PEAK_FILTER; } b->sPfDelay.set_delay(pf_latency); // Update beat processor configuration float bp_ratio = b->pBpRatio->value() - 1.0f; float bp_shift = b->pBpTimeShift->value(); size_t bp_sc_latency = dspu::millis_to_samples(fSampleRate, lsp_max(bp_shift, 0.0f)); size_t bp_latency = dspu::millis_to_samples(fSampleRate, lsp_max(-bp_shift, 0.0f)); if (bp_ratio >= 1e-3f) { float bp_max_gain = b->pBpMaxGain->value(); float bp_user_th = b->pBpThreshold->value(); float bp_log_th = logf(bp_user_th); float bp_log_gate_th = logf(bp_max_gain) / bp_ratio + bp_log_th; float bp_th = expf(bp_log_gate_th); float bp_zone = bp_user_th / bp_th; b->sBp.set_threshold(bp_th, bp_th); b->sBp.set_reduction(1.0f / bp_max_gain); b->sBp.set_zone(bp_zone, bp_zone); b->fBpMakeup = bp_max_gain; } else { float bp_th = b->pBpThreshold->value(); b->sBp.set_threshold(bp_th, bp_th); b->sBp.set_reduction(GAIN_AMP_0_DB); b->sBp.set_zone(GAIN_AMP_0_DB, GAIN_AMP_0_DB); b->fBpMakeup = GAIN_AMP_0_DB; } b->sBp.set_attack(b->pBpAttack->value()); b->sBp.set_release(b->pBpRelease->value()); if (b->sBp.modified()) { b->sBp.update_settings(); if (i == 0) b->sBp.curve(b->vBpMesh, vBpMesh, meta::beat_breather::CURVE_MESH_POINTS, false); b->nSync |= SYNC_BEAT_PROC; } b->sBpScDelay.set_delay(bp_sc_latency); b->sBpDelay.set_delay(pd_latency + pf_latency + bp_latency); // Compute the overall latency of the band if (b->nMode != BAND_OFF) max_band_latency = lsp_max(max_band_latency, b->sBpDelay.delay()); } // Reconfigure the crossover bool csync = (sync) || (c->sCrossover.needs_update()); c->sCrossover.update_settings(); if ((csync) && (i == 0)) { // Output band parameters and update sync curve flag for (size_t j=0; jvBands[j]; // Get frequency response for band c->sCrossover.freq_chart(j, b->vFreqChart, vFftFreqs, meta::beat_breather::FFT_MESH_POINTS); b->nSync |= SYNC_BAND_FILTER; } } } // Apply latency compensations and report latency for (size_t i=0; ivBands[j]; if (b->nMode == BAND_OFF) continue; b->sDelay.set_delay(max_band_latency - b->sBpDelay.delay()); lsp_trace("Band #%d: latency=%d, compensation=%d, overall=%d", int(i), int(b->sBpDelay.delay()), int(b->sDelay.delay()), int(max_band_latency)); } size_t overall_latency = max_band_latency + c->sCrossover.latency(); c->sDelay.set_delay(overall_latency); c->sDryDelay.set_delay(overall_latency); if (i == 0) set_latency(overall_latency); } } void beat_breather::process_band(void *object, void *subject, size_t band, const float *data, size_t sample, size_t count) { channel_t *c = static_cast(subject); band_t *b = &c->vBands[band]; // Apply delay compensation and store to band's data buffer. b->sDelay.process(&b->vInData[sample], data, count); // Measure the input level b->fInLevel = lsp_max(dsp::abs_max(&b->vInData[sample], count), b->fInLevel); } void beat_breather::process(size_t samples) { bind_inputs(); for (size_t offset = 0; offset < samples; ) { size_t to_do = lsp_min(samples - offset, BUFFER_SIZE); // Stores band data to band_t::vIn split_signal(to_do); // Stores normalized RMS difference to band_t::vPdData apply_peak_detector(to_do); // Stores processed data to band_t::vPfData apply_punch_filter(to_do); // Stores the processed band data to band_t::vBpData apply_beat_processor(to_do); // Stores the processed band data to channel_t::vOutData mix_bands(to_do); // Post-process data post_process_block(to_do); // Update pointers and the offset update_pointers(to_do); offset += to_do; } sCounter.submit(samples); output_meters(); if ((pWrapper != NULL) && (sCounter.fired())) pWrapper->query_display_draw(); sCounter.commit(); } void beat_breather::bind_inputs() { for (size_t i=0; ivIn = c->pIn->buffer(); c->vOut = c->pOut->buffer(); c->fInLevel = GAIN_AMP_M_INF_DB; c->fOutLevel = GAIN_AMP_M_INF_DB; for (size_t j=0; jvBands[j]; b->fInLevel = GAIN_AMP_M_INF_DB; b->fOutLevel = GAIN_AMP_M_INF_DB; b->fPdLevel = GAIN_AMP_M_INF_DB; b->fPfInGain = GAIN_AMP_M_INF_DB; b->fPfOutGain = GAIN_AMP_M_INF_DB; b->fPfReduction = GAIN_AMP_0_DB; b->fBpInGain = GAIN_AMP_M_INF_DB; b->fBpOutGain = GAIN_AMP_M_INF_DB; b->fBpReduction = GAIN_AMP_M_INF_DB; } } } void beat_breather::split_signal(size_t samples) { for (size_t i=0; ivInData, c->vIn, fInGain, samples); // Pass the input signal to crossover c->sCrossover.process(c->vInData, samples); } } void beat_breather::normalize_rms(float *dst, const float *lrms, const float *srms, float gain, size_t samples) { for (size_t i=0; i l) && (l >= GAIN_AMP_M_140_DB)) dst[i] = (s * gain) / l; else dst[i] = gain; } } void beat_breather::apply_peak_detector(size_t samples) { // Esimate RMS for all bands for (size_t i=0; ivBands[j]; if (b->nMode == BAND_OFF) continue; // Estimate long-time RMS b->sPdLong.process(b->vPdData, const_cast(&b->vInData), samples); // Estimate short-time RMS b->sPdShort.process(b->vPfData, const_cast(&b->vInData), samples); // Apply delay compensation to short-time RMS estimation b->sPdDelay.process(b->vPfData, b->vPfData, samples); } } // Mix sidechain if 'Stereo Split' is not enabled if ((nChannels > 1) && (!bStereoSplit)) { for (size_t j=0; jnMode == BAND_OFF) || (right->nMode == BAND_OFF)) continue; // Convert stereo long-time RMS to mono dsp::lr_to_mid(left->vPdData, left->vPdData, right->vPdData, samples); // Duplicate long-time RMS to second channel dsp::copy(right->vPdData, left->vPdData, samples); // Convert stereo short-time RMS to mono dsp::lr_to_mid(left->vPfData, left->vPfData, right->vPfData, samples); // Duplicate short-time RMS to second channel dsp::copy(right->vPfData, left->vPfData, samples); } } // Do post-processing and normalization for (size_t i=0; ivBands[j]; if (b->nMode == BAND_OFF) continue; // Produce normalized Peak/RMS signal normalize_rms(b->vPdData, b->vPdData, b->vPfData, b->fPdMakeup, samples); b->sPdMeter.process(b->vPdData, samples); b->fPdLevel = lsp_max(b->fPdLevel, dsp::abs_max(b->vPdData, samples)); } } } void beat_breather::apply_punch_filter(size_t samples) { // Do post-processing and normalization for (size_t i=0; ivBands[j]; if (b->nMode == BAND_OFF) continue; // Process sidechain signal and produce VCA b->sPf.process(b->vPfData, vBuffer, b->vPdData, samples); // Update gating dot meter size_t idx = dsp::max_index(b->vPfData, samples); if (vBuffer[idx] > b->fPfInGain) { b->fPfInGain = vBuffer[idx]; b->fPfOutGain = b->vPfData[idx] * b->fPfInGain; } b->fPfReduction = lsp_min(dsp::abs_min(b->vPfData, samples), b->fPfReduction); // Apply lookahead delay to Peak/RMS signal b->sPfDelay.process(vBuffer, b->vPdData, samples); // Apply VCA to peak signal dsp::mul2(b->vPfData, vBuffer, samples); } } } void beat_breather::apply_beat_processor(size_t samples) { // Process the data stored in band_t::vPfData and band_t::vIn and store result to band_t::vData for (size_t i=0; ivBands[j]; if (b->nMode == BAND_OFF) continue; // Apply time shift delay to the sidechain b->sBpScDelay.process(b->vBpData, b->vPfData, samples); // Process sidechain signal and produce VCA b->sBp.process(b->vBpData, vBuffer, b->vBpData, samples); // Update gating dot meter size_t idx = dsp::max_index(b->vBpData, samples); if (vBuffer[idx] > b->fBpInGain) { b->fBpInGain = vBuffer[idx]; b->fBpOutGain = b->vBpData[idx] * b->fBpInGain * b->fBpMakeup; } b->fBpReduction = lsp_max(dsp::abs_max(b->vBpData, samples) * b->fBpMakeup, b->fBpReduction); // Apply time shift delay + latency compensation to the signal of the band b->sBpDelay.process(b->vInData, b->vInData, samples); // Apply VCA to original signal dsp::fmmul_k3(b->vBpData, b->vInData, b->fBpMakeup, samples); } } } void beat_breather::mix_bands(size_t samples) { // Mix bands depending on the band listen mode for (size_t i=0; ivBands[j].nMode) { case BAND_PD: case BAND_PF: ++num_pd; break; default: break; } } float pd_makeup = (num_pd > 0) ? 1.0f / num_pd : 1.0f; // Mix the tracks size_t mixed = 0; for (size_t j=0; jvBands[j]; switch (b->nMode) { case BAND_BF: b->fOutLevel = lsp_max(dsp::abs_max(b->vInData, samples) * b->fGain, b->fOutLevel); b->fReduction = b->fGain; if (mixed++) dsp::fmadd_k3(c->vOutData, b->vInData, b->fGain, samples); else dsp::mul_k3(c->vOutData, b->vInData, b->fGain, samples); break; case BAND_PD: b->fOutLevel = lsp_max(dsp::abs_max(b->vPdData, samples) * b->fGain * pd_makeup, b->fOutLevel); b->fReduction = b->fPdLevel * b->fGain; if (mixed++) dsp::fmadd_k3(c->vOutData, b->vPdData, b->fGain * pd_makeup, samples); else dsp::mul_k3(c->vOutData, b->vPdData, b->fGain * pd_makeup, samples); break; case BAND_PF: b->fOutLevel = lsp_max(dsp::abs_max(b->vPfData, samples) * b->fGain * pd_makeup, b->fOutLevel); b->fReduction = b->fPfReduction * b->fGain; if (mixed++) dsp::fmadd_k3(c->vOutData, b->vPfData, b->fGain * pd_makeup, samples); else dsp::mul_k3(c->vOutData, b->vPfData, b->fGain * pd_makeup, samples); break; case BAND_BP: b->fOutLevel = lsp_max(dsp::abs_max(b->vBpData, samples) * b->fGain, b->fOutLevel); b->fReduction = b->fBpReduction * b->fGain; if (mixed++) dsp::fmadd_k3(c->vOutData, b->vBpData, b->fGain, samples); else dsp::mul_k3(c->vOutData, b->vBpData, b->fGain, samples); break; case BAND_MUTE: case BAND_OFF: default: break; } } // Clear audio output if there is no one band active if (!mixed) dsp::fill_zero(c->vOutData, samples); } } void beat_breather::post_process_block(size_t samples) { // Apply delay compensation to input data and measure level for (size_t i=0; isDelay.process(c->vInData, c->vInData, samples); // Measure the input level c->fInLevel = lsp_max(dsp::abs_max(c->vInData, samples), c->fInLevel); // Mix dry/wet into channel_t::vOutData dsp::mix2(c->vOutData, c->vInData, fWetGain, fDryGain, samples); // Measure the output level c->fOutLevel = lsp_max(dsp::abs_max(c->vOutData, samples), c->fOutLevel); } // Measure levels if (sAnalyzer.activity()) sAnalyzer.process(vAnalyze, samples); // Apply bypass switch for (size_t i=0; isDryDelay.process(vBuffer, c->vIn, samples); // Apply bypass and output data c->sBypass.process(c->vOut, vBuffer, c->vOutData, samples); } } void beat_breather::update_pointers(size_t samples) { for (size_t i=0; ivIn += samples; c->vOut += samples; } } void beat_breather::output_meters() { // Output meshes plug::mesh_t *mesh; for (size_t i=0; ivBands[j]; if ((b->nMode != BAND_OFF) && (b->nMode != BAND_MUTE)) { if (mixed++) dsp::fmadd_k3( vBuffer, &vChannels[0].vBands[j].vFreqChart[offset], b->fReduction, samples); else dsp::mul_k3( vBuffer, &vChannels[0].vBands[j].vFreqChart[offset], b->fReduction, samples); } } // Fill the output frequency chart if (mixed) dsp::copy(&c->vFreqChart[offset], vBuffer, samples); else dsp::fill_zero(&c->vFreqChart[offset], samples); offset += samples; } } // Output input and output level meters c->pInLevel->set_value(c->fInLevel); c->pOutLevel->set_value(c->fOutLevel); // Output transfer function of the channel mesh = (c->pFreqMesh != NULL) ? c->pFreqMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { dsp::copy(mesh->pvData[0], vFftFreqs, meta::beat_breather::FFT_MESH_POINTS); dsp::copy(mesh->pvData[1], c->vFreqChart, meta::beat_breather::FFT_MESH_POINTS); mesh->data(2, meta::beat_breather::FFT_MESH_POINTS); } // Sync filter characteristics for each band for (size_t j=0; jvBands[j]; // Output meters b->pInLevel->set_value(b->fInLevel); b->pOutLevel->set_value(b->fOutLevel); b->pPfEnvLevel->set_value(b->fPfInGain); b->pPfCurveLevel->set_value(b->fPfOutGain); b->pPfGainLevel->set_value(b->fPfReduction); b->pBpEnvLevel->set_value(b->fBpInGain); b->pBpCurveLevel->set_value(b->fBpOutGain); b->pBpGainLevel->set_value(b->fBpReduction); // Synchronize band transfer function mesh if ((i == 0) && (b->nSync & SYNC_BAND_FILTER)) { mesh = (b->pFreqMesh != NULL) ? b->pFreqMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { mesh->pvData[0][0] = SPEC_FREQ_MIN*0.5f; mesh->pvData[0][meta::beat_breather::FFT_MESH_POINTS+1] = SPEC_FREQ_MAX * 2.0f; mesh->pvData[1][0] = 0.0f; mesh->pvData[1][meta::beat_breather::FFT_MESH_POINTS+1] = 0.0f; dsp::copy(&mesh->pvData[0][1], vFftFreqs, meta::beat_breather::FFT_MESH_POINTS); dsp::copy(&mesh->pvData[1][1], b->vFreqChart, meta::beat_breather::FFT_MESH_POINTS); mesh->data(2, meta::beat_breather::FFT_MESH_POINTS + 2); b->nSync &= ~SYNC_BAND_FILTER; } } // Synchronize peak detector mesh mesh = b->pPdMesh->buffer(); if ((mesh != NULL) && (mesh->isEmpty())) { // Fill mesh with new values dsp::copy(mesh->pvData[0], vPdMesh, meta::beat_breather::TIME_MESH_POINTS); b->sPdMeter.read(mesh->pvData[1], meta::beat_breather::TIME_MESH_POINTS); mesh->data(2, meta::beat_breather::TIME_MESH_POINTS); } // Synchronize peak filter function mesh if ((i == 0) && (b->nSync & SYNC_PEAK_FILTER)) { mesh = (b->pPfMesh != NULL) ? b->pPfMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { dsp::copy(mesh->pvData[0], vPfMesh, meta::beat_breather::CURVE_MESH_POINTS); dsp::copy(mesh->pvData[1], b->vPfMesh, meta::beat_breather::CURVE_MESH_POINTS); mesh->data(2, meta::beat_breather::CURVE_MESH_POINTS); b->nSync &= ~SYNC_PEAK_FILTER; } } // Synchronize beat processor function mesh if ((i == 0) && (b->nSync & SYNC_BEAT_PROC)) { mesh = (b->pBpMesh != NULL) ? b->pBpMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { dsp::copy(mesh->pvData[0], vBpMesh, meta::beat_breather::CURVE_MESH_POINTS); dsp::mul_k3(mesh->pvData[1], b->vBpMesh, b->fBpMakeup, meta::beat_breather::CURVE_MESH_POINTS); mesh->data(2, meta::beat_breather::CURVE_MESH_POINTS); b->nSync &= ~SYNC_BEAT_PROC; } } } // Output spectrum analysis for input channel mesh = ((sAnalyzer.channel_active(c->nAnIn)) && (c->pInMesh != NULL)) ? c->pInMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { // Add extra points mesh->pvData[0][0] = SPEC_FREQ_MIN*0.5f; mesh->pvData[0][meta::beat_breather::FFT_MESH_POINTS+1] = SPEC_FREQ_MAX * 2.0f; mesh->pvData[1][0] = 0.0f; mesh->pvData[1][meta::beat_breather::FFT_MESH_POINTS+1] = 0.0f; dsp::copy(&mesh->pvData[0][1], vFftFreqs, meta::beat_breather::FFT_MESH_POINTS); sAnalyzer.get_spectrum(c->nAnIn, &mesh->pvData[1][1], vFftIndexes, meta::beat_breather::FFT_MESH_POINTS); // Mark mesh containing data mesh->data(2, meta::beat_breather::FFT_MESH_POINTS + 2); } // Output spectrum analysis for output channel mesh = ((sAnalyzer.channel_active(c->nAnOut)) && (c->pOutMesh != NULL)) ? c->pOutMesh->buffer() : NULL; if ((mesh != NULL) && (mesh->isEmpty())) { dsp::copy(mesh->pvData[0], vFftFreqs, meta::beat_breather::FFT_MESH_POINTS); sAnalyzer.get_spectrum(c->nAnOut, mesh->pvData[1], vFftIndexes, meta::beat_breather::FFT_MESH_POINTS); // Mark mesh containing data mesh->data(2, meta::beat_breather::FFT_MESH_POINTS); } } } void beat_breather::ui_activated() { // Determine number of channels for (size_t i=0; ivBands[i]; b->nSync = SYNC_ALL; } } } bool beat_breather::inline_display(plug::ICanvas *cv, size_t width, size_t height) { // Check proportions if (height > (M_RGOLD_RATIO * width)) height = M_RGOLD_RATIO * width; // Init canvas if (!cv->init(width, height)) return false; width = cv->width(); height = cv->height(); // Clear background bool bypassing = vChannels[0].sBypass.bypassing(); cv->set_color_rgb((bypassing) ? CV_DISABLED : CV_BACKGROUND); cv->paint(); // Draw axis cv->set_line_width(1.0); // "-72 db / (:zoom ** 3)" max="24 db * :zoom" float miny = logf(GAIN_AMP_M_72_DB / dsp::ipowf(fZoom, 3)); float maxy = logf(GAIN_AMP_P_24_DB * fZoom); float zx = 1.0f/SPEC_FREQ_MIN; float zy = dsp::ipowf(fZoom, 3)/GAIN_AMP_M_72_DB; float dx = width/(logf(SPEC_FREQ_MAX)-logf(SPEC_FREQ_MIN)); float dy = height/(miny-maxy); // Draw vertical lines cv->set_color_rgb(CV_YELLOW, 0.5f); for (float i=100.0f; iline(ax, 0, ax, height); } // Draw horizontal lines cv->set_color_rgb(CV_WHITE, 0.5f); for (float i=GAIN_AMP_M_72_DB; iline(0, ay, width, ay); } // Allocate buffer: f, x, y, tr pIDisplay = core::IDBuffer::reuse(pIDisplay, 4, width+2); core::IDBuffer *b = pIDisplay; if (b == NULL) return false; // Initialize mesh b->v[0][0] = SPEC_FREQ_MIN*0.5f; b->v[0][width+1] = SPEC_FREQ_MAX*2.0f; b->v[3][0] = 1.0f; b->v[3][width+1] = 1.0f; static const uint32_t c_colors[] = { CV_MIDDLE_CHANNEL, CV_LEFT_CHANNEL, CV_RIGHT_CHANNEL }; size_t channels = ((nChannels < 2) || (!bStereoSplit)) ? 1 : 2; const uint32_t *vc = (channels == 1) ? &c_colors[0] : &c_colors[1]; bool aa = cv->set_anti_aliasing(true); lsp_finally { cv->set_anti_aliasing(aa); }; cv->set_line_width(2); for (size_t i=0; iv[0][j+1] = vFftFreqs[k]; b->v[3][j+1] = c->vFreqChart[k]; } dsp::fill(b->v[1], 0.0f, width+2); dsp::fill(b->v[2], height, width+2); dsp::axis_apply_log1(b->v[1], b->v[0], zx, dx, width+2); dsp::axis_apply_log1(b->v[2], b->v[3], zy, dy, width+2); // Draw mesh uint32_t color = (bypassing || !(active())) ? CV_SILVER : vc[i]; Color stroke(color), fill(color, 0.5f); cv->draw_poly(b->v[1], b->v[2], width+2, stroke, fill); } return true; } void beat_breather::dump(dspu::IStateDumper *v) const { plug::Module::dump(v); v->write("nChannels", nChannels); v->begin_array("vChannels", vChannels, nChannels); { for (size_t i=0; iwrite_object("sBypass", &c->sBypass); v->write_object("sCrossover", &c->sCrossover); v->write_object("sDelay", &c->sDelay); v->write_object("sDryDelay", &c->sDryDelay); v->begin_array("vBands", c->vBands, meta::beat_breather::BANDS_MAX); { for (size_t j=0; jvBands[j]; v->write_object("sDelay", &b->sDelay); v->write_object("sPdLong", &b->sPdLong); v->write_object("sPdShort", &b->sPdShort); v->write_object("sPdDelay", &b->sPdDelay); v->write_object("sPdMeter", &b->sPdMeter); v->write_object("sPf", &b->sPf); v->write_object("sPfDelay", &b->sPfDelay); v->write_object("sBp", &b->sBp); v->write_object("sBpScDelay", &b->sBpScDelay); v->write_object("sBpDelay", &b->sBpDelay); v->write("nOldMode", b->nOldMode); v->write("nMode", b->nMode); v->write("fGain", b->fGain); v->write("fInLevel", b->fInLevel); v->write("fOutLevel", b->fOutLevel); v->write("fReduction", b->fReduction); v->write("nSync", b->nSync); v->write("fPdMakeup", b->fPdMakeup); v->write("fPdLevel", b->fPdLevel); v->write("fPfInGain", b->fPfInGain); v->write("fPfOutGain", b->fPfOutGain); v->write("fPfReduction", b->fPfReduction); v->write("fBpMakeup", b->fBpMakeup); v->write("fBpInGain", b->fBpInGain); v->write("fBpOutGain", b->fBpOutGain); v->write("fBpReduction", b->fBpReduction); v->write("vInData", b->vInData); v->write("vPdData", b->vPdData); v->write("vPfData", b->vPfData); v->write("vBpData", b->vBpData); v->write("vFreqChart", b->vFreqChart); v->write("vPfMesh", b->vPfMesh); v->write("vBpMesh", b->vBpMesh); v->write("pSolo", b->pSolo); v->write("pMute", b->pMute); v->write("pListen", b->pListen); v->write("pLpfSlope", b->pLpfSlope); v->write("pHpfSlope", b->pHpfSlope); v->write("pFlatten", b->pFlatten); v->write("pOutGain", b->pOutGain); v->write("pFreqEnd", b->pFreqEnd); v->write("pFreqMesh", b->pFreqMesh); v->write("pInLevel", b->pInLevel); v->write("pOutLevel", b->pOutLevel); v->write("pPdLongTime", b->pPdLongTime); v->write("pPdShortTime", b->pPdShortTime); v->write("pPdBias", b->pPdBias); v->write("pPdMakeup", b->pPdMakeup); v->write("pPdMesh", b->pPdMesh); v->write("pPfLookahead", b->pPfLookahead); v->write("pPfAttack", b->pPfAttack); v->write("pPfRelease", b->pPfRelease); v->write("pPfThreshold", b->pPfThreshold); v->write("pPfReduction", b->pPfReduction); v->write("pPfZone", b->pPfZone); v->write("pPfMesh", b->pPfMesh); v->write("pPfEnvLevel", b->pPfEnvLevel); v->write("pPfCurveLevel", b->pPfCurveLevel); v->write("pPfGainLevel", b->pPfGainLevel); v->write("pBpAttack", b->pBpAttack); v->write("pBpRelease", b->pBpRelease); v->write("pBpTimeShift", b->pBpTimeShift); v->write("pBpThreshold", b->pBpThreshold); v->write("pBpRatio", b->pBpRatio); v->write("pBpMaxGain", b->pBpMaxGain); v->write("pBpMesh", b->pBpMesh); v->write("pBpEnvLevel", b->pBpEnvLevel); v->write("pBpCurveLevel", b->pBpCurveLevel); v->write("pBpGainLevel", b->pBpGainLevel); } } v->end_array(); v->write("nAnIn", c->nAnIn); v->write("nAnOut", c->nAnOut); v->write("fInLevel", c->fInLevel); v->write("fOutLevel", c->fOutLevel); v->write("vIn", c->vIn); v->write("vOut", c->vOut); v->write("vInData", c->vInData); v->write("vOutData", c->vOutData); v->write("vFreqChart", c->vFreqChart); v->write("pIn", c->pIn); v->write("pOut", c->pOut); v->write("pInLevel", c->pInLevel); v->write("pOutLevel", c->pOutLevel); v->write("pInFft", c->pInFft); v->write("pOutFft", c->pOutFft); v->write("pInMesh", c->pInMesh); v->write("pOutMesh", c->pOutMesh); v->write("pFreqMesh", c->pFreqMesh); } } v->end_array(); v->write("bStereoSplit", bStereoSplit); v->write("fInGain", fInGain); v->write("fDryGain", fDryGain); v->write("fWetGain", fWetGain); v->write("fZoom", fZoom); v->writev("vAnalyze", vAnalyze, 4); v->write_object("sAnalyzer", &sAnalyzer); v->write_object("sCounter", &sCounter); v->begin_array("vSplits", vSplits, meta::beat_breather::BANDS_MAX-1); { for (size_t i=0; ibegin_object(sp, sizeof(split_t)); { v->write("nBandId", sp->nBandId); v->write("fFrequency", sp->fFrequency); v->write("bEnabled", sp->bEnabled); v->write("pEnable", sp->pEnable); v->write("pFrequency", sp->pFrequency); } v->end_object(); } } v->end_array(); v->write("vBuffer", vBuffer); v->write("vFftFreqs", vFftFreqs); v->write("vFftIndexes", vFftIndexes); v->write("vPdMesh", vPdMesh); v->write("vPfMesh", vPfMesh); v->write("vBpMesh", vBpMesh); v->write("pBypass", pBypass); v->write("pInGain", pInGain); v->write("pDryGain", pDryGain); v->write("pWetGain", pWetGain); v->write("pDryWet", pDryWet); v->write("pOutGain", pOutGain); v->write("pStereoSplit", pStereoSplit); v->write("pFFTReactivity", pFFTReactivity); v->write("pFFTShift", pFFTShift); v->write("pZoom", pZoom); v->write("pIDisplay", pIDisplay); v->write("pData", pData); } } /* namespace plugins */ } /* namespace lsp */