include/Effect.h

   1 /*
   2  * Effect.h - base class for effects
   3  *
   4  * Copyright (c) 2006-2007 Danny McRae <khjklujn/at/users.sourceforge.net>
   5  * Copyright (c) 2006-2009 Tobias Doerffel <tobydox/at/users.sourceforge.net>
   6  *
   7  * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this program (see COPYING); if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301 USA.
  23  *
  24  */
  25
  26 #ifndef _EFFECT_H
  27 #define _EFFECT_H
  28
  29 #include "Plugin.h"
  30 #include "engine.h"
  31 #include "Mixer.h"
  32 #include "AutomatableModel.h"
  33 #include "TempoSyncKnobModel.h"
  34
  35
  36 class EffectChain;
  37 class EffectControls;
  38
  39
  40 class EXPORT Effect : public Plugin
  41 {
  42 public:
  43         Effect( const Plugin::Descriptor * _desc,
  44                         Model * _parent,
  45                         const Descriptor::SubPluginFeatures::Key * _key );
  46         virtual ~Effect();
  47
  48         virtual void saveSettings( QDomDocument & _doc, QDomElement & _parent );
  49         virtual void loadSettings( const QDomElement & _this );
  50
  51         inline virtual QString nodeName() const
  52         {
  53                 return "effect";
  54         }
  55
  56
  57         virtual bool processAudioBuffer( sampleFrame * _buf,
  58                                                 const fpp_t _frames ) = 0;
  59
  60         inline ch_cnt_t processorCount() const
  61         {
  62                 return m_processors;
  63         }
  64
  65         inline void setProcessorCount( ch_cnt_t _processors )
  66         {
  67                 m_processors = _processors;
  68         }
  69
  70         inline bool isOkay() const
  71         {
  72                 return m_okay;
  73         }
  74
  75         inline void setOkay( bool _state )
  76         {
  77                 m_okay = _state;
  78         }
  79
  80
  81         inline bool isRunning() const
  82         {
  83                 return m_running;
  84         }
  85
  86         inline void startRunning()
  87         {
  88                 m_bufferCount = 0;
  89                 m_running = true;
  90         }
  91
  92         inline void stopRunning()
  93         {
  94                 m_running = false;
  95         }
  96
  97         inline bool isEnabled() const
  98         {
  99                 return m_enabledModel.value();
 100         }
 101
 102         inline f_cnt_t timeout() const
 103         {
 104                 const float samples =
 105                                 engine::getMixer()->processingSampleRate() *
 106                                         m_autoQuitModel.value() / 1000.0f;
 107                 return 1 + ( static_cast<Uint32>( samples ) /
 108                                 engine::getMixer()->framesPerPeriod() );
 109         }
 110
 111         inline float wetLevel() const
 112         {
 113                 return m_wetDryModel.value();
 114         }
 115
 116         inline float dryLevel() const
 117         {
 118                 return 1.0f - m_wetDryModel.value();
 119         }
 120
 121         inline float gate() const
 122         {
 123                 const float level = m_gateModel.value();
 124                 return level*level * m_processors *
 125                                 engine::getMixer()->framesPerPeriod();
 126         }
 127
 128         inline f_cnt_t bufferCount() const
 129         {
 130                 return m_bufferCount;
 131         }
 132
 133         inline void resetBufferCount()
 134         {
 135                 m_bufferCount = 0;
 136         }
 137
 138         inline void incrementBufferCount()
 139         {
 140                 ++m_bufferCount;
 141         }
 142
 143         inline bool dontRun() const
 144         {
 145                 return m_noRun;
 146         }
 147
 148         inline void setDontRun( bool _state )
 149         {
 150                 m_noRun = _state;
 151         }
 152
 153         inline const Descriptor::SubPluginFeatures::Key & key() const
 154         {
 155                 return m_key;
 156         }
 157
 158         virtual EffectControls * controls() = 0;
 159
 160         static Effect * instantiate( const QString & _plugin_name,
 161                                 Model * _parent,
 162                                 Descriptor::SubPluginFeatures::Key * _key );
 163
 164
 165 protected:
 166         void checkGate( double _out_sum );
 167
 168         virtual PluginView * instantiateView( QWidget * );
 169
 170         // some effects might not be capable of higher sample-rates so they can
 171         // sample it down before processing and back after processing
 172         inline void sampleDown( const sampleFrame * _src_buf,
 173                                                         sampleFrame * _dst_buf,
 174                                                         sample_rate_t _dst_sr )
 175         {
 176                 resample( 0, _src_buf,
 177                                 engine::getMixer()->processingSampleRate(),
 178                                         _dst_buf, _dst_sr,
 179                                         engine::getMixer()->framesPerPeriod() );
 180         }
 181
 182         inline void sampleBack( const sampleFrame * _src_buf,
 183                                                         sampleFrame * _dst_buf,
 184                                                         sample_rate_t _src_sr )
 185         {
 186                 resample( 1, _src_buf, _src_sr, _dst_buf,
 187                                 engine::getMixer()->processingSampleRate(),
 188                         engine::getMixer()->framesPerPeriod() * _src_sr /
 189                                 engine::getMixer()->processingSampleRate() );
 190         }
 191         void reinitSRC();
 192
 193
 194 private:
 195         void resample( int _i, const sampleFrame * _src_buf,
 196                                         sample_rate_t _src_sr,
 197                                         sampleFrame * _dst_buf, sample_rate_t _dst_sr,
 198                                         const f_cnt_t _frames );
 199
 200         Descriptor::SubPluginFeatures::Key m_key;
 201
 202         ch_cnt_t m_processors;
 203
 204         bool m_okay;
 205         bool m_noRun;
 206         bool m_running;
 207         f_cnt_t m_bufferCount;
 208
 209         BoolModel m_enabledModel;
 210         FloatModel m_wetDryModel;
 211         FloatModel m_gateModel;
 212         TempoSyncKnobModel m_autoQuitModel;
 213
 214         SRC_DATA m_srcData[2];
 215         SRC_STATE * m_srcState[2];
 216
 217
 218         friend class EffectView;
 219         friend class EffectChain;
 220
 221 } ;
 222
 223
 224 typedef Effect::Descriptor::SubPluginFeatures::Key EffectKey;
 225 typedef Effect::Descriptor::SubPluginFeatures::KeyList EffectKeyList;
 226
 227
 228 #endif