diff --git a/include/lmms_math.h b/include/lmms_math.h index 1177c6921..5882739bd 100644 --- a/include/lmms_math.h +++ b/include/lmms_math.h @@ -130,7 +130,17 @@ static inline int fast_rand() return( (unsigned)( next / 65536 ) % 32768 ); } +static inline double fastRand( double range ) +{ + static const double fast_rand_ratio = 1.0f / FAST_RAND_MAX; + return fast_rand() * range * fast_rand_ratio; +} +static inline float fastRandf( float range ) +{ + static const float fast_rand_ratio = 1.0f / FAST_RAND_MAX; + return fast_rand() * range * fast_rand_ratio; +} // source: http://martin.ankerl.com/2007/10/04/optimized-pow-approximation-for-java-and-c-c/ static inline double fastPow( double a, double b ) @@ -241,5 +251,4 @@ static inline float fastSqrt( float n ) return u.f; } - #endif diff --git a/plugins/Bitcrush/Bitcrush.cpp b/plugins/Bitcrush/Bitcrush.cpp new file mode 100644 index 000000000..e9ab9639a --- /dev/null +++ b/plugins/Bitcrush/Bitcrush.cpp @@ -0,0 +1,245 @@ +/* + * Bitcrush.cpp - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + +#include "Bitcrush.h" +#include "embed.cpp" + +const int OS_RATE = 5; +const float OS_RATIO = 1.0f / OS_RATE; +const float CUTOFF_RATIO = 0.353553391f; +const int SILENCEFRAMES = 10; + +extern "C" +{ + +Plugin::Descriptor PLUGIN_EXPORT bitcrush_plugin_descriptor = +{ + STRINGIFY( PLUGIN_NAME ), + "Bitcrush", + QT_TRANSLATE_NOOP( "pluginBrowser", "An oversampling bitcrusher" ), + "Vesa Kivimäki ", + 0x0100, + Plugin::Effect, + new PluginPixmapLoader( "logo" ), + NULL, + NULL +}; + +} + +BitcrushEffect::BitcrushEffect( Model * parent, const Descriptor::SubPluginFeatures::Key * key ) : + Effect( &bitcrush_plugin_descriptor, parent, key ), + m_controls( this ), + m_sampleRate( Engine::mixer()->processingSampleRate() ), + m_filter( m_sampleRate ) +{ + m_buffer = MM_ALLOC( sampleFrame, Engine::mixer()->framesPerPeriod() * OS_RATE ); + m_filter.setLowpass( m_sampleRate * ( CUTOFF_RATIO * OS_RATIO ) ); + m_needsUpdate = true; + + m_bitCounterL = 0.0f; + m_bitCounterR = 0.0f; + + m_left = 0.0f; + m_right = 0.0f; + + m_silenceCounter = 0; +} + +BitcrushEffect::~BitcrushEffect() +{ + MM_FREE( m_buffer ); +} + + +void BitcrushEffect::sampleRateChanged() +{ + m_sampleRate = Engine::mixer()->processingSampleRate(); + m_filter.setSampleRate( m_sampleRate ); + m_filter.setLowpass( m_sampleRate * CUTOFF_RATIO ); + m_needsUpdate = true; +} + + +inline float BitcrushEffect::depthCrush( float in ) +{ + return roundf( in * (float) m_levels ) * m_levelsRatio; +} + +inline float BitcrushEffect::noise( float amt ) +{ + return fastRandf( amt * 2.0f ) - amt; +} + +bool BitcrushEffect::processAudioBuffer( sampleFrame* buf, const fpp_t frames ) +{ + // update values + if( m_needsUpdate || m_controls.m_rateEnabled.isValueChanged() ) + { + m_rateEnabled = m_controls.m_rateEnabled.value(); + m_bitCounterL = 0.0f; + m_bitCounterR = 0.0f; + } + if( m_needsUpdate || m_controls.m_depthEnabled.isValueChanged() ) + { + m_depthEnabled = m_controls.m_depthEnabled.value(); + } + if( m_needsUpdate || m_controls.m_rate.isValueChanged() || m_controls.m_stereoDiff.isValueChanged() ) + { + const float rate = m_controls.m_rate.value(); + const float diff = m_controls.m_stereoDiff.value() * 0.005 * rate; + + m_rateCoeffL = ( m_sampleRate * OS_RATE ) / ( rate - diff ); + m_rateCoeffR = ( m_sampleRate * OS_RATE ) / ( rate + diff ); + + m_bitCounterL = 0.0f; + m_bitCounterR = 0.0f; + } + if( m_needsUpdate || m_controls.m_levels.isValueChanged() ) + { + m_levels = m_controls.m_levels.value(); + m_levelsRatio = 1.0f / (float) m_levels; + } + if( m_needsUpdate || m_controls.m_inGain.isValueChanged() ) + { + m_inGain = dbvToAmp( m_controls.m_inGain.value() ); + } + if( m_needsUpdate || m_controls.m_outGain.isValueChanged() ) + { + m_outGain = dbvToAmp( m_controls.m_outGain.value() ); + } + if( m_needsUpdate || m_controls.m_outClip.isValueChanged() ) + { + m_outClip = dbvToAmp( m_controls.m_outClip.value() ); + } + m_needsUpdate = false; + + const float noiseAmt = m_controls.m_inNoise.value() * 0.01f; + + // read input buffer and write it to oversampled buffer + if( m_rateEnabled ) // rate crushing enabled so do that + { + for( int f = 0; f < frames; ++f ) + { + for( int o = 0; o < OS_RATE; ++o ) + { + m_buffer[f * OS_RATE + o][0] = m_left; + m_buffer[f * OS_RATE + o][1] = m_right; + m_bitCounterL += 1.0f; + m_bitCounterR += 1.0f; + if( m_bitCounterL > m_rateCoeffL ) + { + m_bitCounterL -= m_rateCoeffL; + m_left = m_depthEnabled + ? depthCrush( buf[f][0] * m_inGain + noise( buf[f][0] * noiseAmt ) ) + : buf[f][0] * m_inGain + noise( buf[f][0] * noiseAmt ); + } + if( m_bitCounterR > m_rateCoeffR ) + { + m_bitCounterR -= m_rateCoeffR; + m_right = m_depthEnabled + ? depthCrush( buf[f][1] * m_inGain + noise( buf[f][1] * noiseAmt ) ) + : buf[f][1] * m_inGain + noise( buf[f][1] * noiseAmt ); + } + } + } + } + else // rate crushing disabled: simply oversample with zero-order hold + { + for( int f = 0; f < frames; ++f ) + { + for( int o = 0; o < OS_RATE; ++o ) + { + m_buffer[f * OS_RATE + o][0] = m_depthEnabled + ? depthCrush( buf[f][0] * m_inGain + noise( buf[f][0] * noiseAmt ) ) + : buf[f][0] * m_inGain + noise( buf[f][0] * noiseAmt ); + m_buffer[f * OS_RATE + o][1] = m_depthEnabled + ? depthCrush( buf[f][1] * m_inGain + noise( buf[f][1] * noiseAmt ) ) + : buf[f][1] * m_inGain + noise( buf[f][1] * noiseAmt ); + } + } + } + + // the oversampled buffer is now written, so filter it to reduce aliasing + + for( int f = 0; f < frames * OS_RATE; ++f ) + { + if( qMax( qAbs( m_buffer[f][0] ), qAbs( m_buffer[f][1] ) ) >= 1.0e-10f ) + { + m_silenceCounter = 0; + m_buffer[f][0] = m_filter.update( m_buffer[f][0], 0 ); + m_buffer[f][1] = m_filter.update( m_buffer[f][1], 1 ); + } + else + { + if( m_silenceCounter > SILENCEFRAMES ) + { + m_buffer[f][0] = m_buffer[f][1] = 0.0f; + } + else + { + ++m_silenceCounter; + m_buffer[f][0] = m_filter.update( m_buffer[f][0], 0 ); + m_buffer[f][1] = m_filter.update( m_buffer[f][1], 1 ); + } + } + } + + + // now downsample and write it back to main buffer + + double outSum = 0.0; + const float d = dryLevel(); + const float w = wetLevel(); + for( int f = 0; f < frames; ++f ) + { + float lsum = 0.0f; + float rsum = 0.0f; + for( int o = 0; o < OS_RATE; ++o ) + { + lsum += m_buffer[f * OS_RATE + o][0] * OS_RATIO; + rsum += m_buffer[f * OS_RATE + o][1] * OS_RATIO; + } + buf[f][0] = d * buf[f][0] + w * qBound( -m_outClip, lsum, m_outClip ) * m_outGain; + buf[f][1] = d * buf[f][1] + w * qBound( -m_outClip, rsum, m_outClip ) * m_outGain; + outSum += buf[f][0]*buf[f][0] + buf[f][1]*buf[f][1]; + } + + checkGate( outSum / frames ); + + return isRunning(); +} + + +extern "C" +{ + +// necessary for getting instance out of shared lib +Plugin * PLUGIN_EXPORT lmms_plugin_main( Model* parent, void* data ) +{ + return new BitcrushEffect( parent, static_cast( data ) ); +} + +} diff --git a/plugins/Bitcrush/Bitcrush.h b/plugins/Bitcrush/Bitcrush.h new file mode 100644 index 000000000..0c599e107 --- /dev/null +++ b/plugins/Bitcrush/Bitcrush.h @@ -0,0 +1,83 @@ +/* + * Bitcrush.h - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + + +#ifndef BITCRUSH_H +#define BITCRUSH_H + +#include "Effect.h" +#include "BitcrushControls.h" +#include "ValueBuffer.h" +#include "lmms_math.h" +#include "BasicFilters.h" + +class BitcrushEffect : public Effect +{ +public: + BitcrushEffect( Model* parent, const Descriptor::SubPluginFeatures::Key* key ); + virtual ~BitcrushEffect(); + virtual bool processAudioBuffer( sampleFrame* buf, const fpp_t frames ); + + virtual EffectControls* controls() + { + return &m_controls; + } + +private: + void sampleRateChanged(); + float depthCrush( float in ); + float noise( float amt ); + + BitcrushControls m_controls; + + sampleFrame * m_buffer; + float m_sampleRate; + StereoLinkwitzRiley m_filter; + + float m_bitCounterL; + float m_rateCoeffL; + float m_bitCounterR; + float m_rateCoeffR; + bool m_rateEnabled; + + float m_left; + float m_right; + + int m_levels; + float m_levelsRatio; + bool m_depthEnabled; + + float m_inGain; + float m_outGain; + float m_outClip; + + bool m_needsUpdate; + + int m_silenceCounter; + + friend class BitcrushControls; +}; + +#endif diff --git a/plugins/Bitcrush/BitcrushControlDialog.cpp b/plugins/Bitcrush/BitcrushControlDialog.cpp new file mode 100644 index 000000000..3faa7e52c --- /dev/null +++ b/plugins/Bitcrush/BitcrushControlDialog.cpp @@ -0,0 +1,113 @@ +/* + * BitcrushControlDialog.cpp - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + + +#include +#include + +#include "BitcrushControlDialog.h" +#include "BitcrushControls.h" +#include "embed.h" +#include "ToolTip.h" +#include "LedCheckbox.h" +#include "Knob.h" + +BitcrushControlDialog::BitcrushControlDialog( BitcrushControls * controls ) : + EffectControlDialog( controls ) +{ + setAutoFillBackground( true ); + QPalette pal; + pal.setBrush( backgroundRole(), PLUGIN_NAME::getIconPixmap( "artwork" ) ); + setPalette( pal ); + setFixedSize( 215, 120 ); + + // labels + QLabel * inLabel = new QLabel( tr( "IN" ), this ); + inLabel->move( 12, 10); + + QLabel * outLabel = new QLabel( tr( "OUT" ), this ); + outLabel->move( 176, 10 ); + + // input knobs + Knob * inGain = new Knob( knobBright_26, this ); + inGain->move( 12, 25 ); + inGain->setModel( & controls->m_inGain ); + inGain->setLabel( tr( "GAIN" ) ); + inGain->setHintText( tr( "Input Gain:" ) + " ", " dBV" ); + + Knob * inNoise = new Knob( knobBright_26, this ); + inNoise->move( 12, 70 ); + inNoise->setModel( & controls->m_inNoise ); + inNoise->setLabel( tr( "NOIS" ) ); + inNoise->setHintText( tr( "Input Noise:" ) + " ", "%" ); + + + // output knobs + Knob * outGain = new Knob( knobBright_26, this ); + outGain->move( 176, 25 ); + outGain->setModel( & controls->m_outGain ); + outGain->setLabel( tr( "GAIN" ) ); + outGain->setHintText( tr( "Output Gain:" ) + " ", " dBV" ); + + Knob * outClip = new Knob( knobBright_26, this ); + outClip->move( 176, 70 ); + outClip->setModel( & controls->m_outClip ); + outClip->setLabel( tr( "CLIP" ) ); + outClip->setHintText( tr( "Output Clip:" ) + " ", "%" ); + + + // leds + LedCheckBox * rateEnabled = new LedCheckBox( tr( "Rate" ), this, tr( "Rate Enabled" ), LedCheckBox::Green ); + rateEnabled->move( 50, 30 ); + rateEnabled->setModel( & controls->m_rateEnabled ); + ToolTip::add( rateEnabled, tr( "Enable samplerate-crushing" ) ); + + LedCheckBox * depthEnabled = new LedCheckBox( tr( "Depth" ), this, tr( "Depth Enabled" ), LedCheckBox::Green ); + depthEnabled->move( 50, 80 ); + depthEnabled->setModel( & controls->m_depthEnabled ); + ToolTip::add( depthEnabled, tr( "Enable bitdepth-crushing" ) ); + + + // rate crushing knobs + Knob * rate = new Knob( knobBright_26, this ); + rate->move( 100, 20 ); + rate->setModel( & controls->m_rate ); + rate->setLabel( tr( "Rate" ) ); + rate->setHintText( tr( "Sample rate:" ) + " ", " Hz" ); + + Knob * stereoDiff = new Knob( knobBright_26, this ); + stereoDiff->move( 140, 20 ); + stereoDiff->setModel( & controls->m_stereoDiff ); + stereoDiff->setLabel( tr( "STD" ) ); + stereoDiff->setHintText( tr( "Stereo difference:" ) + " ", "%" ); + + + // depth crushing knob + Knob * levels = new Knob( knobBright_26, this ); + levels->move( 140, 70 ); + levels->setModel( & controls->m_levels ); + levels->setLabel( tr( "Levels" ) ); + levels->setHintText( tr( "Levels:" ) + " ", "" ); +} diff --git a/plugins/Bitcrush/BitcrushControlDialog.h b/plugins/Bitcrush/BitcrushControlDialog.h new file mode 100644 index 000000000..69c4dd5f5 --- /dev/null +++ b/plugins/Bitcrush/BitcrushControlDialog.h @@ -0,0 +1,44 @@ +/* + * BitcrushControlDialog.h - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + + +#ifndef BITCRUSH_CONTROL_DIALOG_H +#define BITCRUSH_CONTROL_DIALOG_H + +#include "EffectControlDialog.h" + +class BitcrushControls; + +class BitcrushControlDialog : public EffectControlDialog +{ + Q_OBJECT +public: + BitcrushControlDialog( BitcrushControls * controls ); + virtual ~BitcrushControlDialog() + { + } +}; + +#endif diff --git a/plugins/Bitcrush/BitcrushControls.cpp b/plugins/Bitcrush/BitcrushControls.cpp new file mode 100644 index 000000000..e67cef0d1 --- /dev/null +++ b/plugins/Bitcrush/BitcrushControls.cpp @@ -0,0 +1,89 @@ +/* + * BitcrushControls.cpp - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + + +#include + +#include "BitcrushControls.h" +#include "Bitcrush.h" +#include "lmms_math.h" + + +BitcrushControls::BitcrushControls( BitcrushEffect * eff ) : + EffectControls( eff ), + m_effect( eff ), + m_inGain( 0.0f, -20.0f, 20.0f, 0.1f, this, "Input gain" ), + m_inNoise( 0.0f, 0.0f, 100.0f, 0.1f, this, "Input noise" ), + m_outGain( 0.0f, -20.0f, 20.0f, 0.1f, this, "Output gain" ), + m_outClip( 0.0f, -20.0f, 20.0f, 0.1f, this, "Output clip" ), + m_rate( 44100.f, 20.f, 44100.f, 1.0f, this, "Samplerate" ), + m_stereoDiff( 0.f, 0.f, 50.f, 0.1f, this, "Stereo difference" ), + m_levels( 256.f, 1.f, 256.f, 1.0f, this, "Levels" ), + m_rateEnabled( true, this, "Rate enabled" ), + m_depthEnabled( true, this, "Depth enabled" ) +{ + m_rate.setStrictStepSize( true ); + m_levels.setStrictStepSize( true ); + + connect( Engine::mixer(), SIGNAL( sampleRateChanged() ), this, SLOT( sampleRateChanged() ) ); +} + +BitcrushControls::~BitcrushControls() +{ +} + +void BitcrushControls::saveSettings( QDomDocument & doc, QDomElement & elem ) +{ + m_inGain.saveSettings( doc, elem, "ingain" ); + m_inNoise.saveSettings( doc, elem, "innoise" ); + m_outGain.saveSettings( doc, elem, "outgain" ); + m_outClip.saveSettings( doc, elem, "outclip" ); + m_rate.saveSettings( doc, elem, "rate" ); + m_stereoDiff.saveSettings( doc, elem, "stereodiff" ); + m_levels.saveSettings( doc, elem, "levels" ); + m_rateEnabled.saveSettings( doc, elem, "rateon" ); + m_depthEnabled.saveSettings( doc, elem, "depthon" ); +} + + +void BitcrushControls::loadSettings( const QDomElement & elem ) +{ + m_inGain.loadSettings( elem, "ingain" ); + m_inNoise.loadSettings( elem, "innoise" ); + m_outGain.loadSettings( elem, "outgain" ); + m_outClip.loadSettings( elem, "outclip" ); + m_rate.loadSettings( elem, "rate" ); + m_stereoDiff.loadSettings( elem, "stereodiff" ); + m_levels.loadSettings( elem, "levels" ); + m_rateEnabled.loadSettings( elem, "rateon" ); + m_depthEnabled.loadSettings( elem, "depthon" ); + + m_effect->m_needsUpdate = true; +} + +void BitcrushControls::sampleRateChanged() +{ + m_effect->sampleRateChanged(); +} diff --git a/plugins/Bitcrush/BitcrushControls.h b/plugins/Bitcrush/BitcrushControls.h new file mode 100644 index 000000000..42ec34e38 --- /dev/null +++ b/plugins/Bitcrush/BitcrushControls.h @@ -0,0 +1,82 @@ +/* + * BitcrushControls.h - A native bitcrusher + * + * Copyright (c) 2014 Vesa Kivimäki + * Copyright (c) 2006-2014 Tobias Doerffel + * + * This file is part of LMMS - http://lmms.io + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program (see COPYING); if not, write to the + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA. + * + */ + +#ifndef BITCRUSH_CONTROLS_H +#define BITCRUSH_CONTROLS_H + +#include "EffectControls.h" +#include "BitcrushControlDialog.h" + +class BitcrushEffect; + +class BitcrushControls : public EffectControls +{ + Q_OBJECT +public: + BitcrushControls( BitcrushEffect * eff ); + virtual ~BitcrushControls(); + + virtual void saveSettings( QDomDocument & doc, QDomElement & elem ); + virtual void loadSettings( const QDomElement & elem ); + inline virtual QString nodeName() const + { + return( "bitcrushcontrols" ); + } + + virtual int controlCount() + { + return( 9 ); + } + + virtual EffectControlDialog * createView() + { + return( new BitcrushControlDialog( this ) ); + } + +private slots: + void sampleRateChanged(); + +private: + BitcrushEffect * m_effect; + + FloatModel m_inGain; + FloatModel m_inNoise; + + FloatModel m_outGain; + FloatModel m_outClip; + + FloatModel m_rate; + FloatModel m_stereoDiff; + + FloatModel m_levels; + + BoolModel m_rateEnabled; + BoolModel m_depthEnabled; + + friend class BitcrushControlDialog; + friend class BitcrushEffect; +}; + +#endif diff --git a/plugins/Bitcrush/CMakeLists.txt b/plugins/Bitcrush/CMakeLists.txt new file mode 100644 index 000000000..ca70afceb --- /dev/null +++ b/plugins/Bitcrush/CMakeLists.txt @@ -0,0 +1,3 @@ +INCLUDE(BuildPlugin) + +BUILD_PLUGIN(bitcrush Bitcrush.cpp BitcrushControls.cpp BitcrushControlDialog.cpp MOCFILES BitcrushControls.h BitcrushControlDialog.h EMBEDDED_RESOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.png") diff --git a/plugins/Bitcrush/artwork.png b/plugins/Bitcrush/artwork.png new file mode 100644 index 000000000..c0c97bdd5 Binary files /dev/null and b/plugins/Bitcrush/artwork.png differ diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt index e6f3509ee..4df760ecd 100644 --- a/plugins/CMakeLists.txt +++ b/plugins/CMakeLists.txt @@ -2,6 +2,7 @@ ADD_SUBDIRECTORY(Amplifier) ADD_SUBDIRECTORY(audio_file_processor) ADD_SUBDIRECTORY(BassBooster) ADD_SUBDIRECTORY(bit_invader) +ADD_SUBDIRECTORY(Bitcrush) ADD_SUBDIRECTORY(carlabase) ADD_SUBDIRECTORY(carlapatchbay) ADD_SUBDIRECTORY(carlarack)