← Back to branch summary

~ubuntu-branches/ubuntu/utopic/lmms/utopic

« back to all changes in this revision

Viewing changes to .pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_tubewarmth.c

  • Committer: Package Import Robot
  • Author(s): Israel Dahl
  • Date: 2014-04-30 18:49:37 UTC
  • mfrom: (1.1.15)
  • Revision ID: package-import@ubuntu.com-20140430184937-hozuuxonlbshciya
Tags: 1.0.1-src-0ubuntu1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/fix-crash-on-close.patch/plugins/LadspaEffect/tap/tap_tubewarmth.c
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 
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 
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
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
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 
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
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 
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 
373
 
cleanup_TubeWarmth(LADSPA_Handle Instance) {
374
 
 
375
 
        free(Instance);
376
 
}
377
 
 
378
 
 
379
 
 
380
 
LADSPA_Descriptor * mono_descriptor = NULL;
381
 
 
382
 
 
383
 
 
384
 
/* __attribute__((constructor)) _init() is called automatically when the plugin library is first
385
 
   loaded. */
386
 
void 
387
 
__attribute__((constructor)) _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
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
 
/* __attribute__((destructor)) _fini() is called automatically when the library is unloaded. */
475
 
void
476
 
__attribute__((destructor)) _fini() {
477
 
        delete_descriptor(mono_descriptor);
478
 
}
479
 
 
480
 
 
481
 
/* Return a descriptor of the requested plugin type. */
482
 
const LADSPA_Descriptor * 
483
 
ladspa_descriptor(unsigned long Index) {
484
 
 
485
 
        switch (Index) {
486
 
        case 0:
487
 
                return mono_descriptor;
488
 
        default:
489
 
                return NULL;
490
 
        }
491
 
}