1 #ifndef INCLUDED_AUDIOFX_AMPLITUDE_H 2 #define INCLUDED_AUDIOFX_AMPLITUDE_H 3 4 #include <vector> 5 #include <string> 6 7 #include "samplebuffer_iterators.h" 8 #include "audiofx.h" 9 10 /** 11 * Virtual base for amplitude effects and dynamic processors. 12 * @author Kai Vehmanen 13 */ 14 class EFFECT_AMPLITUDE : public EFFECT_BASE { 15 16 public: 17 18 static parameter_t db_to_linear(parameter_t value); 19 20 virtual void init(SAMPLE_BUFFER *insample); 21 virtual void release(void); 22 virtual ~EFFECT_AMPLITUDE(void); 23 24 protected: 25 26 SAMPLE_BUFFER *cur_sbuf_repp; 27 28 }; 29 30 #include "audiofx_compressor.h" 31 32 /** 33 * Amplifier for adjusting signal level (linear) 34 * @author Kai Vehmanen 35 */ 36 class EFFECT_AMPLIFY: public EFFECT_AMPLITUDE { 37 38 parameter_t gain_rep; 39 SAMPLE_ITERATOR i; 40 SAMPLE_BUFFER* sbuf_repp; 41 42 public: 43 name(void)44 virtual std::string name(void) const { return("Amplify"); } parameter_names(void)45 virtual std::string parameter_names(void) const { return("amp-%"); } 46 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 47 48 virtual void set_parameter(int param, parameter_t value); 49 virtual parameter_t get_parameter(int param) const; 50 51 virtual void init(SAMPLE_BUFFER *insample); 52 virtual void release(void); 53 virtual void process(void); 54 virtual void process_ref(void); 55 56 EFFECT_AMPLIFY (parameter_t multiplier_percent = 100.0); 57 virtual ~EFFECT_AMPLIFY(void); clone(void)58 EFFECT_AMPLIFY* clone(void) const { return new EFFECT_AMPLIFY(*this); } new_expr(void)59 EFFECT_AMPLIFY* new_expr(void) const { return new EFFECT_AMPLIFY(); } 60 }; 61 62 /** 63 * Amplifier for adjusting signal level (dB) 64 * @author Kai Vehmanen 65 */ 66 class EFFECT_AMPLIFY_DB: public EFFECT_AMPLITUDE { 67 68 private: 69 70 parameter_t gain_rep; 71 parameter_t gain_db_rep; 72 int channel_rep; 73 SAMPLE_BUFFER *sbuf_repp; 74 SAMPLE_ITERATOR_CHANNEL i_ch; 75 SAMPLE_ITERATOR i_all; 76 77 public: 78 name(void)79 virtual std::string name(void) const { return("Amplify (dB)"); } parameter_names(void)80 virtual std::string parameter_names(void) const { return("gain-db,channel"); } 81 82 virtual void set_parameter(int param, parameter_t value); 83 virtual parameter_t get_parameter(int param) const; 84 85 virtual void init(SAMPLE_BUFFER *insample); 86 virtual void release(void); 87 virtual void process(void); 88 virtual void process_ref(void); 89 90 virtual int output_channels(int i_channels) const; 91 92 EFFECT_AMPLIFY_DB(parameter_t gain = 0.0f, int channel = 0); 93 virtual ~EFFECT_AMPLIFY_DB(void); clone(void)94 EFFECT_AMPLIFY_DB* clone(void) const { return new EFFECT_AMPLIFY_DB(*this); } new_expr(void)95 EFFECT_AMPLIFY_DB* new_expr(void) const { return new EFFECT_AMPLIFY_DB(); } 96 }; 97 98 /** 99 * Amplifier with clip control. 100 * @author Kai Vehmanen 101 */ 102 class EFFECT_AMPLIFY_CLIPCOUNT : public EFFECT_AMPLITUDE { 103 104 parameter_t gain; 105 int nm, num_of_clipped, maxnum_of_clipped; 106 SAMPLE_ITERATOR i; 107 108 public: 109 name(void)110 virtual std::string name(void) const { return("Amplify with clipping control"); } parameter_names(void)111 virtual std::string parameter_names(void) const { return("amp-%,max-clipped-samples"); } 112 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 113 114 virtual void set_parameter(int param, parameter_t value); 115 virtual parameter_t get_parameter(int param) const; 116 117 virtual void init(SAMPLE_BUFFER *insample); 118 virtual void process(void); 119 new_expr(void)120 EFFECT_AMPLIFY_CLIPCOUNT* new_expr(void) const { return new EFFECT_AMPLIFY_CLIPCOUNT(); } clone(void)121 EFFECT_AMPLIFY_CLIPCOUNT* clone(void) const { return new EFFECT_AMPLIFY_CLIPCOUNT(*this); } 122 EFFECT_AMPLIFY_CLIPCOUNT (parameter_t multiplier_percent = 100.0, int max_clipped = 0); 123 }; 124 125 /** 126 * Channel amplifier 127 * @author Kai Vehmanen 128 */ 129 class EFFECT_AMPLIFY_CHANNEL: public EFFECT_AMPLITUDE { 130 131 parameter_t gain; 132 int channel_rep; 133 SAMPLE_ITERATOR_CHANNEL i; 134 135 public: 136 name(void)137 virtual std::string name(void) const { return("Channel amplify"); } parameter_names(void)138 virtual std::string parameter_names(void) const { return("amp-%,channel"); } 139 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 140 141 virtual void set_parameter(int param, parameter_t value); 142 virtual parameter_t get_parameter(int param) const; 143 144 virtual int output_channels(int i_channels) const; 145 146 virtual void init(SAMPLE_BUFFER *insample); 147 virtual void process(void); 148 virtual void process_ref(void); 149 clone(void)150 EFFECT_AMPLIFY_CHANNEL* clone(void) const { return new EFFECT_AMPLIFY_CHANNEL(*this); } new_expr(void)151 EFFECT_AMPLIFY_CHANNEL* new_expr(void) const { return new EFFECT_AMPLIFY_CHANNEL(); } 152 EFFECT_AMPLIFY_CHANNEL (parameter_t multiplier_percent = 100.0, int channel = 1); 153 }; 154 155 /** 156 * Limiter effect 157 * @author Kai Vehmanen 158 */ 159 class EFFECT_LIMITER: public EFFECT_AMPLITUDE { 160 161 parameter_t limit_rep; 162 SAMPLE_ITERATOR i; 163 164 public: 165 name(void)166 virtual std::string name(void) const { return("Limiter"); } parameter_names(void)167 virtual std::string parameter_names(void) const { return("limit-%"); } 168 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 169 170 virtual void set_parameter(int param, parameter_t value); 171 virtual parameter_t get_parameter(int param) const; 172 173 virtual void init(SAMPLE_BUFFER *insample); 174 virtual void process(void); 175 176 EFFECT_LIMITER (parameter_t multiplier_percent = 100.0); 177 virtual ~EFFECT_LIMITER(void); clone(void)178 EFFECT_LIMITER* clone(void) const { return new EFFECT_LIMITER(*this); } new_expr(void)179 EFFECT_LIMITER* new_expr(void) const { return new EFFECT_LIMITER(); } 180 }; 181 182 /** 183 * Dynamic compressor. 184 * @author Kai Vehmanen 185 */ 186 class EFFECT_COMPRESS : public EFFECT_AMPLITUDE { 187 188 parameter_t crate; 189 parameter_t threshold; 190 SAMPLE_ITERATOR_CHANNELS i; 191 192 parameter_t delta, ratio, new_value; 193 bool first_time; 194 195 std::vector<SAMPLE_SPECS::sample_t> lastin, lastout; 196 197 public: 198 name(void)199 virtual std::string name(void) const { return("Compressor"); } parameter_names(void)200 virtual std::string parameter_names(void) const { return("compression-rate-dB,threshold-%"); } 201 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 202 203 virtual void set_parameter(int param, parameter_t value); 204 virtual parameter_t get_parameter(int param) const; 205 206 virtual void init(SAMPLE_BUFFER *insample); 207 virtual void process(void); 208 clone(void)209 EFFECT_COMPRESS* clone(void) const { return new EFFECT_COMPRESS(*this); } new_expr(void)210 EFFECT_COMPRESS* new_expr(void) const { return new EFFECT_COMPRESS(); } 211 EFFECT_COMPRESS (const EFFECT_COMPRESS& x); 212 EFFECT_COMPRESS (parameter_t compress_rate = 1.0, parameter_t thold = 10.0); 213 }; 214 215 /** 216 * Noise gate with attack and release 217 * @author Kai Vehmanen 218 */ 219 class EFFECT_NOISEGATE : public EFFECT_AMPLITUDE { 220 221 SAMPLE_ITERATOR_CHANNELS i; 222 223 parameter_t th_level; 224 parameter_t th_time; 225 parameter_t atime, htime, rtime; 226 227 std::vector<parameter_t> th_time_lask; 228 std::vector<parameter_t> attack_lask; 229 std::vector<parameter_t> hold_lask; 230 std::vector<parameter_t> release_lask; 231 std::vector<parameter_t> gain; 232 233 enum { ng_waiting, ng_attacking, ng_active, ng_holding, ng_releasing }; 234 235 std::vector<int> ng_status; 236 237 public: 238 name(void)239 virtual std::string name(void) const { return("Noisegate"); } description(void)240 virtual std::string description(void) const { return("Noise gate with attack and release."); } parameter_names(void)241 virtual std::string parameter_names(void) const { 242 return("threshold-level-%,pre-hold-time-msec,attack-time-msec,post-hold-time-msec,release-time-msec"); 243 } 244 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 245 246 virtual void set_parameter(int param, parameter_t value); 247 virtual parameter_t get_parameter(int param) const; 248 249 virtual void init(SAMPLE_BUFFER *insample); 250 virtual void process(void); 251 clone(void)252 EFFECT_NOISEGATE* clone(void) const { return new EFFECT_NOISEGATE(*this); } new_expr(void)253 EFFECT_NOISEGATE* new_expr(void) const { return new EFFECT_NOISEGATE(); } 254 EFFECT_NOISEGATE (parameter_t thlevel_percent = 100.0, 255 parameter_t thtime = 50.0, 256 parameter_t atime = 50.0, 257 parameter_t htime = 50.0, 258 parameter_t rtime = 50.0); 259 }; 260 261 /** 262 * Panning effect for controlling the stereo image. 263 * @author Kai Vehmanen 264 */ 265 class EFFECT_NORMAL_PAN : public EFFECT_AMPLITUDE { 266 267 private: 268 269 SAMPLE_ITERATOR_CHANNEL i; 270 271 parameter_t right_percent_rep; 272 parameter_t l_gain, r_gain; 273 274 public: 275 name(void)276 virtual std::string name(void) const { return("Normal pan"); } description(void)277 virtual std::string description(void) const { return("Panning effect for controlling the stereo image."); } parameter_names(void)278 virtual std::string parameter_names(void) const { return("right-%"); } 279 virtual void parameter_description(int param, struct PARAM_DESCRIPTION *pd) const; 280 output_channels(int i_channels)281 virtual int output_channels(int i_channels) const { return(2); } 282 283 virtual void set_parameter(int param, parameter_t value); 284 virtual parameter_t get_parameter(int param) const; 285 286 virtual void init(SAMPLE_BUFFER *insample); 287 virtual void process(void); 288 virtual void process_ref(void); 289 clone(void)290 EFFECT_NORMAL_PAN* clone(void) const { return new EFFECT_NORMAL_PAN(*this); } new_expr(void)291 EFFECT_NORMAL_PAN* new_expr(void) const { return new EFFECT_NORMAL_PAN(); } 292 EFFECT_NORMAL_PAN(parameter_t right_percent = 50.0); 293 }; 294 295 #endif 296