← Back to branch summary

~ubuntu-branches/ubuntu/raring/lmms/raring-proposed

« back to all changes in this revision

Viewing changes to plugins/ladspa_effect/swh/foverdrive_1196.c

  • Committer: Charlie Smotherman
  • Date: 2012-12-05 22:08:38 UTC
  • mfrom: (33.1.7 lmms_0.4.13)
  • Revision ID: cjsmo@cableone.net-20121205220838-09pjfzew9m5023hr
https://launchpad.net/bugs/824231
https://launchpad.net/bugs/863366
* New  Upstream release.
  - Minor tweaking to ZynAddSubFX, CALF, SWH plugins  and Stefan Fendt's RC
    filters.
  - Added UI fixes: Magnentic effect of knobs and Piano-roll fixes
  - Updated German localization and copyright year
* debian/lmms-common.install:
  - added /usr/share/applications so the lmms.desktop file will correctly
    install (LP: #863366)
  - This should also fix the Software Center not displaying lmms in sound
    and video (LP: #824231)

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/ladspa_effect/swh/foverdrive_1196.c
 
1
#include <stdlib.h>
 
2
#include <string.h>
 
3
#ifndef WIN32
 
4
#include "config.h"
 
5
#endif
 
6
 
 
7
#ifdef ENABLE_NLS
 
8
#include <libintl.h>
 
9
#endif
 
10
 
 
11
#define         _ISOC9X_SOURCE  1
 
12
#define         _ISOC99_SOURCE  1
 
13
#define         __USE_ISOC99    1
 
14
#define         __USE_ISOC9X    1
 
15
 
 
16
#include <math.h>
 
17
 
 
18
#include "ladspa.h"
 
19
 
 
20
#ifdef WIN32
 
21
#define _WINDOWS_DLL_EXPORT_ __declspec(dllexport)
 
22
int bIsFirstTime = 1; 
 
23
void _init(); // forward declaration
 
24
#else
 
25
#define _WINDOWS_DLL_EXPORT_ 
 
26
#endif
 
27
 
 
28
 
 
29
#define FOVERDRIVE_DRIVE               0
 
30
#define FOVERDRIVE_INPUT               1
 
31
#define FOVERDRIVE_OUTPUT              2
 
32
 
 
33
static LADSPA_Descriptor *foverdriveDescriptor = NULL;
 
34
 
 
35
typedef struct {
 
36
        LADSPA_Data *drive;
 
37
        LADSPA_Data *input;
 
38
        LADSPA_Data *output;
 
39
        LADSPA_Data run_adding_gain;
 
40
} Foverdrive;
 
41
 
 
42
_WINDOWS_DLL_EXPORT_
 
43
const LADSPA_Descriptor *ladspa_descriptor(unsigned long index) {
 
44
 
 
45
#ifdef WIN32
 
46
        if (bIsFirstTime) {
 
47
                _init();
 
48
                bIsFirstTime = 0;
 
49
        }
 
50
#endif
 
51
        switch (index) {
 
52
        case 0:
 
53
                return foverdriveDescriptor;
 
54
        default:
 
55
                return NULL;
 
56
        }
 
57
}
 
58
 
 
59
static void cleanupFoverdrive(LADSPA_Handle instance) {
 
60
        free(instance);
 
61
}
 
62
 
 
63
static void connectPortFoverdrive(
 
64
 LADSPA_Handle instance,
 
65
 unsigned long port,
 
66
 LADSPA_Data *data) {
 
67
        Foverdrive *plugin;
 
68
 
 
69
        plugin = (Foverdrive *)instance;
 
70
        switch (port) {
 
71
        case FOVERDRIVE_DRIVE:
 
72
                plugin->drive = data;
 
73
                break;
 
74
        case FOVERDRIVE_INPUT:
 
75
                plugin->input = data;
 
76
                break;
 
77
        case FOVERDRIVE_OUTPUT:
 
78
                plugin->output = data;
 
79
                break;
 
80
        }
 
81
}
 
82
 
 
83
static LADSPA_Handle instantiateFoverdrive(
 
84
 const LADSPA_Descriptor *descriptor,
 
85
 unsigned long s_rate) {
 
86
        Foverdrive *plugin_data = (Foverdrive *)malloc(sizeof(Foverdrive));
 
87
        plugin_data->run_adding_gain = 1.0f;
 
88
 
 
89
        return (LADSPA_Handle)plugin_data;
 
90
}
 
91
 
 
92
#undef buffer_write
 
93
#undef RUN_ADDING
 
94
#undef RUN_REPLACING
 
95
 
 
96
#define buffer_write(b, v) (b = v)
 
97
#define RUN_ADDING    0
 
98
#define RUN_REPLACING 1
 
99
 
 
100
static void runFoverdrive(LADSPA_Handle instance, unsigned long sample_count) {
 
101
        Foverdrive *plugin_data = (Foverdrive *)instance;
 
102
 
 
103
        /* Drive level (float value) */
 
104
        const LADSPA_Data drive = *(plugin_data->drive);
 
105
 
 
106
        /* Input (array of floats of length sample_count) */
 
107
        const LADSPA_Data * const input = plugin_data->input;
 
108
 
 
109
        /* Output (array of floats of length sample_count) */
 
110
        LADSPA_Data * const output = plugin_data->output;
 
111
 
 
112
#line 16 "foverdrive_1196.xml"
 
113
        unsigned long pos;
 
114
        const float drivem1 = drive - 1.0f;
 
115
 
 
116
        for (pos = 0; pos < sample_count; pos++) {
 
117
                LADSPA_Data x = input[pos];
 
118
                const float fx = fabs(x);
 
119
                buffer_write(output[pos], x*(fx + drive)/(x*x + drivem1*fx + 1.0f));
 
120
        }
 
121
}
 
122
#undef buffer_write
 
123
#undef RUN_ADDING
 
124
#undef RUN_REPLACING
 
125
 
 
126
#define buffer_write(b, v) (b += (v) * run_adding_gain)
 
127
#define RUN_ADDING    1
 
128
#define RUN_REPLACING 0
 
129
 
 
130
static void setRunAddingGainFoverdrive(LADSPA_Handle instance, LADSPA_Data gain) {
 
131
        ((Foverdrive *)instance)->run_adding_gain = gain;
 
132
}
 
133
 
 
134
static void runAddingFoverdrive(LADSPA_Handle instance, unsigned long sample_count) {
 
135
        Foverdrive *plugin_data = (Foverdrive *)instance;
 
136
        LADSPA_Data run_adding_gain = plugin_data->run_adding_gain;
 
137
 
 
138
        /* Drive level (float value) */
 
139
        const LADSPA_Data drive = *(plugin_data->drive);
 
140
 
 
141
        /* Input (array of floats of length sample_count) */
 
142
        const LADSPA_Data * const input = plugin_data->input;
 
143
 
 
144
        /* Output (array of floats of length sample_count) */
 
145
        LADSPA_Data * const output = plugin_data->output;
 
146
 
 
147
#line 16 "foverdrive_1196.xml"
 
148
        unsigned long pos;
 
149
        const float drivem1 = drive - 1.0f;
 
150
 
 
151
        for (pos = 0; pos < sample_count; pos++) {
 
152
                LADSPA_Data x = input[pos];
 
153
                const float fx = fabs(x);
 
154
                buffer_write(output[pos], x*(fx + drive)/(x*x + drivem1*fx + 1.0f));
 
155
        }
 
156
}
 
157
 
 
158
void _init() {
 
159
        char **port_names;
 
160
        LADSPA_PortDescriptor *port_descriptors;
 
161
        LADSPA_PortRangeHint *port_range_hints;
 
162
 
 
163
#ifdef ENABLE_NLS
 
164
#define D_(s) dgettext(PACKAGE, s)
 
165
        setlocale(LC_ALL, "");
 
166
        bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
 
167
#else
 
168
#define D_(s) (s)
 
169
#endif
 
170
 
 
171
 
 
172
        foverdriveDescriptor =
 
173
         (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));
 
174
 
 
175
        if (foverdriveDescriptor) {
 
176
                foverdriveDescriptor->UniqueID = 1196;
 
177
                foverdriveDescriptor->Label = "foverdrive";
 
178
                foverdriveDescriptor->Properties =
 
179
                 LADSPA_PROPERTY_HARD_RT_CAPABLE;
 
180
                foverdriveDescriptor->Name =
 
181
                 D_("Fast overdrive");
 
182
                foverdriveDescriptor->Maker =
 
183
                 "Steve Harris <steve@plugin.org.uk>";
 
184
                foverdriveDescriptor->Copyright =
 
185
                 "GPL";
 
186
                foverdriveDescriptor->PortCount = 3;
 
187
 
 
188
                port_descriptors = (LADSPA_PortDescriptor *)calloc(3,
 
189
                 sizeof(LADSPA_PortDescriptor));
 
190
                foverdriveDescriptor->PortDescriptors =
 
191
                 (const LADSPA_PortDescriptor *)port_descriptors;
 
192
 
 
193
                port_range_hints = (LADSPA_PortRangeHint *)calloc(3,
 
194
                 sizeof(LADSPA_PortRangeHint));
 
195
                foverdriveDescriptor->PortRangeHints =
 
196
                 (const LADSPA_PortRangeHint *)port_range_hints;
 
197
 
 
198
                port_names = (char **)calloc(3, sizeof(char*));
 
199
                foverdriveDescriptor->PortNames =
 
200
                 (const char **)port_names;
 
201
 
 
202
                /* Parameters for Drive level */
 
203
                port_descriptors[FOVERDRIVE_DRIVE] =
 
204
                 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
 
205
                port_names[FOVERDRIVE_DRIVE] =
 
206
                 D_("Drive level");
 
207
                port_range_hints[FOVERDRIVE_DRIVE].HintDescriptor =
 
208
                 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MINIMUM;
 
209
                port_range_hints[FOVERDRIVE_DRIVE].LowerBound = 1;
 
210
                port_range_hints[FOVERDRIVE_DRIVE].UpperBound = 3;
 
211
 
 
212
                /* Parameters for Input */
 
213
                port_descriptors[FOVERDRIVE_INPUT] =
 
214
                 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
 
215
                port_names[FOVERDRIVE_INPUT] =
 
216
                 D_("Input");
 
217
                port_range_hints[FOVERDRIVE_INPUT].HintDescriptor = 0;
 
218
 
 
219
                /* Parameters for Output */
 
220
                port_descriptors[FOVERDRIVE_OUTPUT] =
 
221
                 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
 
222
                port_names[FOVERDRIVE_OUTPUT] =
 
223
                 D_("Output");
 
224
                port_range_hints[FOVERDRIVE_OUTPUT].HintDescriptor = 0;
 
225
 
 
226
                foverdriveDescriptor->activate = NULL;
 
227
                foverdriveDescriptor->cleanup = cleanupFoverdrive;
 
228
                foverdriveDescriptor->connect_port = connectPortFoverdrive;
 
229
                foverdriveDescriptor->deactivate = NULL;
 
230
                foverdriveDescriptor->instantiate = instantiateFoverdrive;
 
231
                foverdriveDescriptor->run = runFoverdrive;
 
232
                foverdriveDescriptor->run_adding = runAddingFoverdrive;
 
233
                foverdriveDescriptor->set_run_adding_gain = setRunAddingGainFoverdrive;
 
234
        }
 
235
}
 
236
 
 
237
void _fini() {
 
238
        if (foverdriveDescriptor) {
 
239
                free((LADSPA_PortDescriptor *)foverdriveDescriptor->PortDescriptors);
 
240
                free((char **)foverdriveDescriptor->PortNames);
 
241
                free((LADSPA_PortRangeHint *)foverdriveDescriptor->PortRangeHints);
 
242
                free(foverdriveDescriptor);
 
243
        }
 
244
 
 
245
}