1 /* -*- linux-c -*-
2 Copyright (C) 2004 Tom Szilagyi
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17
18 $Id: tap_tubewarmth.c,v 1.1 2004/08/02 18:14:50 tszilagyi Exp $
19 */
20
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <math.h>
26
27 #include "ladspa.h"
28 #include "tap_utils.h"
29
30
31 /* The Unique ID of the plugin: */
32
33 #define ID_MONO 2158
34
35 /* The port numbers for the plugin: */
36
37 #define DRIVE 0
38 #define BLEND 1
39 #define INPUT 2
40 #define OUTPUT 3
41
42 /* Total number of ports */
43
44
45 #define PORTCOUNT_MONO 4
46
47
48 /* The structure used to hold port connection information and state */
49
50 typedef struct {
51 LADSPA_Data * drive;
52 LADSPA_Data * blend;
53 LADSPA_Data * input;
54 LADSPA_Data * output;
55
56 LADSPA_Data prev_med;
57 LADSPA_Data prev_out;
58
59 LADSPA_Data rdrive;
60 LADSPA_Data rbdr;
61 LADSPA_Data kpa;
62 LADSPA_Data kpb;
63 LADSPA_Data kna;
64 LADSPA_Data knb;
65 LADSPA_Data ap;
66 LADSPA_Data an;
67 LADSPA_Data imr;
68 LADSPA_Data kc;
69 LADSPA_Data srct;
70 LADSPA_Data sq;
71 LADSPA_Data pwrq;
72
73 LADSPA_Data prev_drive;
74 LADSPA_Data prev_blend;
75
76 unsigned long sample_rate;
77 LADSPA_Data run_adding_gain;
78 } TubeWarmth;
79
80
81
82 /* Construct a new plugin instance. */
83 LADSPA_Handle
instantiate_TubeWarmth(const LADSPA_Descriptor * Descriptor,unsigned long sample_rate)84 instantiate_TubeWarmth(const LADSPA_Descriptor * Descriptor,
85 unsigned long sample_rate) {
86
87 LADSPA_Handle * ptr;
88
89 if ((ptr = malloc(sizeof(TubeWarmth))) != NULL) {
90 ((TubeWarmth *)ptr)->sample_rate = sample_rate;
91 ((TubeWarmth *)ptr)->run_adding_gain = 1.0f;
92
93 ((TubeWarmth *)ptr)->prev_med = 0.0f;
94 ((TubeWarmth *)ptr)->prev_out = 0.0f;
95
96 ((TubeWarmth *)ptr)->rdrive = 0.0f;
97 ((TubeWarmth *)ptr)->rbdr = 0.0f;
98 ((TubeWarmth *)ptr)->kpa = 0.0f;
99 ((TubeWarmth *)ptr)->kpb = 0.0f;
100 ((TubeWarmth *)ptr)->kna = 0.0f;
101 ((TubeWarmth *)ptr)->knb = 0.0f;
102 ((TubeWarmth *)ptr)->ap = 0.0f;
103 ((TubeWarmth *)ptr)->an = 0.0f;
104 ((TubeWarmth *)ptr)->imr = 0.0f;
105 ((TubeWarmth *)ptr)->kc = 0.0f;
106 ((TubeWarmth *)ptr)->srct = 0.0f;
107 ((TubeWarmth *)ptr)->sq = 0.0f;
108 ((TubeWarmth *)ptr)->pwrq = 0.0f;
109
110 /* These are out of band to force param recalc upon first run() */
111 ((TubeWarmth *)ptr)->prev_drive = -1.0f;
112 ((TubeWarmth *)ptr)->prev_blend = -11.0f;
113
114 return ptr;
115 }
116 return NULL;
117 }
118
119
120
121
122
123 /* Connect a port to a data location. */
124 void
connect_port_TubeWarmth(LADSPA_Handle Instance,unsigned long Port,LADSPA_Data * DataLocation)125 connect_port_TubeWarmth(LADSPA_Handle Instance,
126 unsigned long Port,
127 LADSPA_Data * DataLocation) {
128
129 TubeWarmth * ptr = (TubeWarmth *)Instance;
130
131 switch (Port) {
132 case DRIVE:
133 ptr->drive = DataLocation;
134 break;
135 case BLEND:
136 ptr->blend = DataLocation;
137 break;
138 case INPUT:
139 ptr->input = DataLocation;
140 break;
141 case OUTPUT:
142 ptr->output = DataLocation;
143 break;
144 }
145 }
146
147
148 #define EPS 0.000000001f
149
150 static inline float
M(float x)151 M(float x) {
152
153 if ((x > EPS) || (x < -EPS))
154 return x;
155 else
156 return 0.0f;
157 }
158
159 static inline float
D(float x)160 D(float x) {
161
162 if (x > EPS)
163 return sqrt(x);
164 else if (x < -EPS)
165 return sqrt(-x);
166 else
167 return 0.0f;
168 }
169
170 void
run_TubeWarmth(LADSPA_Handle Instance,unsigned long SampleCount)171 run_TubeWarmth(LADSPA_Handle Instance,
172 unsigned long SampleCount) {
173
174 TubeWarmth * ptr = (TubeWarmth *)Instance;
175 LADSPA_Data * input = ptr->input;
176 LADSPA_Data * output = ptr->output;
177 LADSPA_Data drive = LIMIT(*(ptr->drive),0.1f,10.0f);
178 LADSPA_Data blend = LIMIT(*(ptr->blend),-10.0f,10.0f);
179
180 unsigned long sample_index;
181 unsigned long sample_count = SampleCount;
182 unsigned long sample_rate = ptr->sample_rate;
183
184 LADSPA_Data rdrive = ptr->rdrive;
185 LADSPA_Data rbdr = ptr->rbdr;
186 LADSPA_Data kpa = ptr->kpa;
187 LADSPA_Data kpb = ptr->kpb;
188 LADSPA_Data kna = ptr->kna;
189 LADSPA_Data knb = ptr->knb;
190 LADSPA_Data ap = ptr->ap;
191 LADSPA_Data an = ptr->an;
192 LADSPA_Data imr = ptr->imr;
193 LADSPA_Data kc = ptr->kc;
194 LADSPA_Data srct = ptr->srct;
195 LADSPA_Data sq = ptr->sq;
196 LADSPA_Data pwrq = ptr->pwrq;
197
198 LADSPA_Data prev_med;
199 LADSPA_Data prev_out;
200 LADSPA_Data in;
201 LADSPA_Data med;
202 LADSPA_Data out;
203
204 if ((ptr->prev_drive != drive) || (ptr->prev_blend != blend)) {
205
206 rdrive = 12.0f / drive;
207 rbdr = rdrive / (10.5f - blend) * 780.0f / 33.0f;
208 kpa = D(2.0f * (rdrive*rdrive) - 1.0f) + 1.0f;
209 kpb = (2.0f - kpa) / 2.0f;
210 ap = ((rdrive*rdrive) - kpa + 1.0f) / 2.0f;
211 kc = kpa / D(2.0f * D(2.0f * (rdrive*rdrive) - 1.0f) - 2.0f * rdrive*rdrive);
212
213 srct = (0.1f * sample_rate) / (0.1f * sample_rate + 1.0f);
214 sq = kc*kc + 1.0f;
215 knb = -1.0f * rbdr / D(sq);
216 kna = 2.0f * kc * rbdr / D(sq);
217 an = rbdr*rbdr / sq;
218 imr = 2.0f * knb + D(2.0f * kna + 4.0f * an - 1.0f);
219 pwrq = 2.0f / (imr + 1.0f);
220
221 ptr->prev_drive = drive;
222 ptr->prev_blend = blend;
223 }
224
225 for (sample_index = 0; sample_index < sample_count; sample_index++) {
226
227 in = *(input++);
228 prev_med = ptr->prev_med;
229 prev_out = ptr->prev_out;
230
231 if (in >= 0.0f) {
232 med = (D(ap + in * (kpa - in)) + kpb) * pwrq;
233 } else {
234 med = (D(an - in * (kna + in)) + knb) * pwrq * -1.0f;
235 }
236
237 out = srct * (med - prev_med + prev_out);
238
239 if (out < -1.0f)
240 out = -1.0f;
241
242 *(output++) = out;
243
244 ptr->prev_med = M(med);
245 ptr->prev_out = M(out);
246 }
247
248 ptr->rdrive = rdrive;
249 ptr->rbdr = rbdr;
250 ptr->kpa = kpa;
251 ptr->kpb = kpb;
252 ptr->kna = kna;
253 ptr->knb = knb;
254 ptr->ap = ap;
255 ptr->an = an;
256 ptr->imr = imr;
257 ptr->kc = kc;
258 ptr->srct = srct;
259 ptr->sq = sq;
260 ptr->pwrq = pwrq;
261 }
262
263
264
265 void
set_run_adding_gain_TubeWarmth(LADSPA_Handle Instance,LADSPA_Data gain)266 set_run_adding_gain_TubeWarmth(LADSPA_Handle Instance, LADSPA_Data gain) {
267
268 TubeWarmth * ptr = (TubeWarmth *)Instance;
269
270 ptr->run_adding_gain = gain;
271 }
272
273
274
275 void
run_adding_TubeWarmth(LADSPA_Handle Instance,unsigned long SampleCount)276 run_adding_TubeWarmth(LADSPA_Handle Instance,
277 unsigned long SampleCount) {
278
279 TubeWarmth * ptr = (TubeWarmth *)Instance;
280 LADSPA_Data * input = ptr->input;
281 LADSPA_Data * output = ptr->output;
282 LADSPA_Data drive = LIMIT(*(ptr->drive),0.1f,10.0f);
283 LADSPA_Data blend = LIMIT(*(ptr->blend),-10.0f,10.0f);
284
285 unsigned long sample_index;
286 unsigned long sample_count = SampleCount;
287 unsigned long sample_rate = ptr->sample_rate;
288
289 LADSPA_Data rdrive = ptr->rdrive;
290 LADSPA_Data rbdr = ptr->rbdr;
291 LADSPA_Data kpa = ptr->kpa;
292 LADSPA_Data kpb = ptr->kpb;
293 LADSPA_Data kna = ptr->kna;
294 LADSPA_Data knb = ptr->knb;
295 LADSPA_Data ap = ptr->ap;
296 LADSPA_Data an = ptr->an;
297 LADSPA_Data imr = ptr->imr;
298 LADSPA_Data kc = ptr->kc;
299 LADSPA_Data srct = ptr->srct;
300 LADSPA_Data sq = ptr->sq;
301 LADSPA_Data pwrq = ptr->pwrq;
302
303 LADSPA_Data prev_med;
304 LADSPA_Data prev_out;
305 LADSPA_Data in;
306 LADSPA_Data med;
307 LADSPA_Data out;
308
309 if ((ptr->prev_drive != drive) || (ptr->prev_blend != blend)) {
310
311 rdrive = 12.0f / drive;
312 rbdr = rdrive / (10.5f - blend) * 780.0f / 33.0f;
313 kpa = D(2.0f * (rdrive*rdrive) - 1.0f) + 1.0f;
314 kpb = (2.0f - kpa) / 2.0f;
315 ap = ((rdrive*rdrive) - kpa + 1.0f) / 2.0f;
316 kc = kpa / D(2.0f * D(2.0f * (rdrive*rdrive) - 1.0f) - 2.0f * rdrive*rdrive);
317
318 srct = (0.1f * sample_rate) / (0.1f * sample_rate + 1.0f);
319 sq = kc*kc + 1.0f;
320 knb = -1.0f * rbdr / D(sq);
321 kna = 2.0f * kc * rbdr / D(sq);
322 an = rbdr*rbdr / sq;
323 imr = 2.0f * knb + D(2.0f * kna + 4.0f * an - 1.0f);
324 pwrq = 2.0f / (imr + 1.0f);
325
326 ptr->prev_drive = drive;
327 ptr->prev_blend = blend;
328 }
329
330 for (sample_index = 0; sample_index < sample_count; sample_index++) {
331
332 in = *(input++);
333 prev_med = ptr->prev_med;
334 prev_out = ptr->prev_out;
335
336 if (in >= 0.0f) {
337 med = (D(ap + in * (kpa - in)) + kpb) * pwrq;
338 } else {
339 med = (D(an - in * (kna + in)) + knb) * pwrq * -1.0f;
340 }
341
342 out = srct * (med - prev_med + prev_out);
343
344 if (out < -1.0f)
345 out = -1.0f;
346
347 *(output++) += out * ptr->run_adding_gain;
348
349 ptr->prev_med = M(med);
350 ptr->prev_out = M(out);
351 }
352
353 ptr->rdrive = rdrive;
354 ptr->rbdr = rbdr;
355 ptr->kpa = kpa;
356 ptr->kpb = kpb;
357 ptr->kna = kna;
358 ptr->knb = knb;
359 ptr->ap = ap;
360 ptr->an = an;
361 ptr->imr = imr;
362 ptr->kc = kc;
363 ptr->srct = srct;
364 ptr->sq = sq;
365 ptr->pwrq = pwrq;
366 }
367
368
369
370
371 /* Throw away a TubeWarmth effect instance. */
372 void
cleanup_TubeWarmth(LADSPA_Handle Instance)373 cleanup_TubeWarmth(LADSPA_Handle Instance) {
374
375 free(Instance);
376 }
377
378
379
380 LADSPA_Descriptor * mono_descriptor = NULL;
381
382
383
384 /* _init() is called automatically when the plugin library is first
385 loaded. */
386 void
_init()387 _init() {
388
389 char ** port_names;
390 LADSPA_PortDescriptor * port_descriptors;
391 LADSPA_PortRangeHint * port_range_hints;
392
393 if ((mono_descriptor =
394 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor))) == NULL)
395 exit(1);
396
397
398 mono_descriptor->UniqueID = ID_MONO;
399 mono_descriptor->Label = strdup("tap_tubewarmth");
400 mono_descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE;
401 mono_descriptor->Name = strdup("TAP TubeWarmth");
402 mono_descriptor->Maker = strdup("Tom Szilagyi");
403 mono_descriptor->Copyright = strdup("GPL");
404 mono_descriptor->PortCount = PORTCOUNT_MONO;
405
406 if ((port_descriptors =
407 (LADSPA_PortDescriptor *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortDescriptor))) == NULL)
408 exit(1);
409
410 mono_descriptor->PortDescriptors = (const LADSPA_PortDescriptor *)port_descriptors;
411 port_descriptors[DRIVE] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
412 port_descriptors[BLEND] = LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
413 port_descriptors[INPUT] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
414 port_descriptors[OUTPUT] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
415
416 if ((port_names =
417 (char **)calloc(PORTCOUNT_MONO, sizeof(char *))) == NULL)
418 exit(1);
419
420 mono_descriptor->PortNames = (const char **)port_names;
421 port_names[DRIVE] = strdup("Drive");
422 port_names[BLEND] = strdup("Tape--Tube Blend");
423 port_names[INPUT] = strdup("Input");
424 port_names[OUTPUT] = strdup("Output");
425
426 if ((port_range_hints =
427 ((LADSPA_PortRangeHint *)calloc(PORTCOUNT_MONO, sizeof(LADSPA_PortRangeHint)))) == NULL)
428 exit(1);
429
430 mono_descriptor->PortRangeHints = (const LADSPA_PortRangeHint *)port_range_hints;
431 port_range_hints[DRIVE].HintDescriptor =
432 (LADSPA_HINT_BOUNDED_BELOW |
433 LADSPA_HINT_BOUNDED_ABOVE |
434 LADSPA_HINT_DEFAULT_LOW);
435 port_range_hints[BLEND].HintDescriptor =
436 (LADSPA_HINT_BOUNDED_BELOW |
437 LADSPA_HINT_BOUNDED_ABOVE |
438 LADSPA_HINT_DEFAULT_MAXIMUM);
439 port_range_hints[DRIVE].LowerBound = 0.1f;
440 port_range_hints[DRIVE].UpperBound = 10.0f;
441 port_range_hints[BLEND].LowerBound = -10.0f;
442 port_range_hints[BLEND].UpperBound = 10.0f;
443 port_range_hints[INPUT].HintDescriptor = 0;
444 port_range_hints[OUTPUT].HintDescriptor = 0;
445 mono_descriptor->instantiate = instantiate_TubeWarmth;
446 mono_descriptor->connect_port = connect_port_TubeWarmth;
447 mono_descriptor->activate = NULL;
448 mono_descriptor->run = run_TubeWarmth;
449 mono_descriptor->run_adding = run_adding_TubeWarmth;
450 mono_descriptor->set_run_adding_gain = set_run_adding_gain_TubeWarmth;
451 mono_descriptor->deactivate = NULL;
452 mono_descriptor->cleanup = cleanup_TubeWarmth;
453 }
454
455
456 void
delete_descriptor(LADSPA_Descriptor * descriptor)457 delete_descriptor(LADSPA_Descriptor * descriptor) {
458 unsigned long index;
459 if (descriptor) {
460 free((char *)descriptor->Label);
461 free((char *)descriptor->Name);
462 free((char *)descriptor->Maker);
463 free((char *)descriptor->Copyright);
464 free((LADSPA_PortDescriptor *)descriptor->PortDescriptors);
465 for (index = 0; index < descriptor->PortCount; index++)
466 free((char *)(descriptor->PortNames[index]));
467 free((char **)descriptor->PortNames);
468 free((LADSPA_PortRangeHint *)descriptor->PortRangeHints);
469 free(descriptor);
470 }
471 }
472
473
474 /* _fini() is called automatically when the library is unloaded. */
475 void
_fini()476 _fini() {
477 delete_descriptor(mono_descriptor);
478 }
479
480
481 /* Return a descriptor of the requested plugin type. */
482 const LADSPA_Descriptor *
ladspa_descriptor(unsigned long Index)483 ladspa_descriptor(unsigned long Index) {
484
485 switch (Index) {
486 case 0:
487 return mono_descriptor;
488 default:
489 return NULL;
490 }
491 }
492