← Back to branch summary

~ubuntu-branches/ubuntu/trusty/lmms/trusty

« back to all changes in this revision

Viewing changes to plugins/ladspa_effect/swh/freq_tracker_1418.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/freq_tracker_1418.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
#line 10 "freq_tracker_1418.xml"
 
29
 
 
30
#include "ladspa-util.h"
 
31
 
 
32
#define FREQTRACKER_SPEED              0
 
33
#define FREQTRACKER_INPUT              1
 
34
#define FREQTRACKER_FREQ               2
 
35
 
 
36
static LADSPA_Descriptor *freqTrackerDescriptor = NULL;
 
37
 
 
38
typedef struct {
 
39
        LADSPA_Data *speed;
 
40
        LADSPA_Data *input;
 
41
        LADSPA_Data *freq;
 
42
        int          cross_time;
 
43
        LADSPA_Data  f;
 
44
        LADSPA_Data  fo;
 
45
        float        fs;
 
46
        LADSPA_Data  last_amp;
 
47
        LADSPA_Data run_adding_gain;
 
48
} FreqTracker;
 
49
 
 
50
_WINDOWS_DLL_EXPORT_
 
51
const LADSPA_Descriptor *ladspa_descriptor(unsigned long index) {
 
52
 
 
53
#ifdef WIN32
 
54
        if (bIsFirstTime) {
 
55
                _init();
 
56
                bIsFirstTime = 0;
 
57
        }
 
58
#endif
 
59
        switch (index) {
 
60
        case 0:
 
61
                return freqTrackerDescriptor;
 
62
        default:
 
63
                return NULL;
 
64
        }
 
65
}
 
66
 
 
67
static void activateFreqTracker(LADSPA_Handle instance) {
 
68
        FreqTracker *plugin_data = (FreqTracker *)instance;
 
69
        int cross_time = plugin_data->cross_time;
 
70
        LADSPA_Data f = plugin_data->f;
 
71
        LADSPA_Data fo = plugin_data->fo;
 
72
        float fs = plugin_data->fs;
 
73
        LADSPA_Data last_amp = plugin_data->last_amp;
 
74
#line 27 "freq_tracker_1418.xml"
 
75
        cross_time = 0;
 
76
        f = 0.0f;
 
77
        fo = 0.0f;
 
78
        last_amp = 0.0f;
 
79
        plugin_data->cross_time = cross_time;
 
80
        plugin_data->f = f;
 
81
        plugin_data->fo = fo;
 
82
        plugin_data->fs = fs;
 
83
        plugin_data->last_amp = last_amp;
 
84
 
 
85
}
 
86
 
 
87
static void cleanupFreqTracker(LADSPA_Handle instance) {
 
88
        free(instance);
 
89
}
 
90
 
 
91
static void connectPortFreqTracker(
 
92
 LADSPA_Handle instance,
 
93
 unsigned long port,
 
94
 LADSPA_Data *data) {
 
95
        FreqTracker *plugin;
 
96
 
 
97
        plugin = (FreqTracker *)instance;
 
98
        switch (port) {
 
99
        case FREQTRACKER_SPEED:
 
100
                plugin->speed = data;
 
101
                break;
 
102
        case FREQTRACKER_INPUT:
 
103
                plugin->input = data;
 
104
                break;
 
105
        case FREQTRACKER_FREQ:
 
106
                plugin->freq = data;
 
107
                break;
 
108
        }
 
109
}
 
110
 
 
111
static LADSPA_Handle instantiateFreqTracker(
 
112
 const LADSPA_Descriptor *descriptor,
 
113
 unsigned long s_rate) {
 
114
        FreqTracker *plugin_data = (FreqTracker *)malloc(sizeof(FreqTracker));
 
115
        int cross_time;
 
116
        LADSPA_Data f;
 
117
        LADSPA_Data fo;
 
118
        float fs;
 
119
        LADSPA_Data last_amp;
 
120
 
 
121
#line 19 "freq_tracker_1418.xml"
 
122
        fs = s_rate;
 
123
        f = 0.0f;
 
124
        fo = 0.0f;
 
125
        cross_time = 0;
 
126
        last_amp = 0.0f;
 
127
 
 
128
        plugin_data->cross_time = cross_time;
 
129
        plugin_data->f = f;
 
130
        plugin_data->fo = fo;
 
131
        plugin_data->fs = fs;
 
132
        plugin_data->last_amp = last_amp;
 
133
 
 
134
        return (LADSPA_Handle)plugin_data;
 
135
}
 
136
 
 
137
#undef buffer_write
 
138
#undef RUN_ADDING
 
139
#undef RUN_REPLACING
 
140
 
 
141
#define buffer_write(b, v) (b = v)
 
142
#define RUN_ADDING    0
 
143
#define RUN_REPLACING 1
 
144
 
 
145
static void runFreqTracker(LADSPA_Handle instance, unsigned long sample_count) {
 
146
        FreqTracker *plugin_data = (FreqTracker *)instance;
 
147
 
 
148
        /* Tracking speed (float value) */
 
149
        const LADSPA_Data speed = *(plugin_data->speed);
 
150
 
 
151
        /* Input (array of floats of length sample_count) */
 
152
        const LADSPA_Data * const input = plugin_data->input;
 
153
 
 
154
        /* Frequency (Hz) (array of floats of length sample_count) */
 
155
        LADSPA_Data * const freq = plugin_data->freq;
 
156
        int cross_time = plugin_data->cross_time;
 
157
        LADSPA_Data f = plugin_data->f;
 
158
        LADSPA_Data fo = plugin_data->fo;
 
159
        float fs = plugin_data->fs;
 
160
        LADSPA_Data last_amp = plugin_data->last_amp;
 
161
 
 
162
#line 34 "freq_tracker_1418.xml"
 
163
        unsigned long pos;
 
164
        float xm1 = last_amp;
 
165
        const float damp_lp = (1.0f - speed) * 0.9f;
 
166
        const float damp_lpi = 1.0f - damp_lp;
 
167
 
 
168
        for (pos = 0; pos < sample_count; pos++) {
 
169
          if (input[pos] < 0.0f && xm1 > 0.0f) {
 
170
            if (cross_time > 3.0f) {
 
171
              f = fs / ((float)cross_time * 2.0f);
 
172
            }
 
173
            cross_time = 0;
 
174
          }
 
175
          xm1 = input[pos];
 
176
          cross_time++;
 
177
          fo = fo * damp_lp + f * damp_lpi;
 
178
          fo = flush_to_zero(fo);
 
179
          buffer_write(freq[pos], fo);
 
180
        }
 
181
 
 
182
        plugin_data->last_amp = xm1;
 
183
        plugin_data->fo = fo;
 
184
        plugin_data->f = f;
 
185
        plugin_data->cross_time = cross_time;
 
186
}
 
187
#undef buffer_write
 
188
#undef RUN_ADDING
 
189
#undef RUN_REPLACING
 
190
 
 
191
#define buffer_write(b, v) (b += (v) * run_adding_gain)
 
192
#define RUN_ADDING    1
 
193
#define RUN_REPLACING 0
 
194
 
 
195
static void setRunAddingGainFreqTracker(LADSPA_Handle instance, LADSPA_Data gain) {
 
196
        ((FreqTracker *)instance)->run_adding_gain = gain;
 
197
}
 
198
 
 
199
static void runAddingFreqTracker(LADSPA_Handle instance, unsigned long sample_count) {
 
200
        FreqTracker *plugin_data = (FreqTracker *)instance;
 
201
        LADSPA_Data run_adding_gain = plugin_data->run_adding_gain;
 
202
 
 
203
        /* Tracking speed (float value) */
 
204
        const LADSPA_Data speed = *(plugin_data->speed);
 
205
 
 
206
        /* Input (array of floats of length sample_count) */
 
207
        const LADSPA_Data * const input = plugin_data->input;
 
208
 
 
209
        /* Frequency (Hz) (array of floats of length sample_count) */
 
210
        LADSPA_Data * const freq = plugin_data->freq;
 
211
        int cross_time = plugin_data->cross_time;
 
212
        LADSPA_Data f = plugin_data->f;
 
213
        LADSPA_Data fo = plugin_data->fo;
 
214
        float fs = plugin_data->fs;
 
215
        LADSPA_Data last_amp = plugin_data->last_amp;
 
216
 
 
217
#line 34 "freq_tracker_1418.xml"
 
218
        unsigned long pos;
 
219
        float xm1 = last_amp;
 
220
        const float damp_lp = (1.0f - speed) * 0.9f;
 
221
        const float damp_lpi = 1.0f - damp_lp;
 
222
 
 
223
        for (pos = 0; pos < sample_count; pos++) {
 
224
          if (input[pos] < 0.0f && xm1 > 0.0f) {
 
225
            if (cross_time > 3.0f) {
 
226
              f = fs / ((float)cross_time * 2.0f);
 
227
            }
 
228
            cross_time = 0;
 
229
          }
 
230
          xm1 = input[pos];
 
231
          cross_time++;
 
232
          fo = fo * damp_lp + f * damp_lpi;
 
233
          fo = flush_to_zero(fo);
 
234
          buffer_write(freq[pos], fo);
 
235
        }
 
236
 
 
237
        plugin_data->last_amp = xm1;
 
238
        plugin_data->fo = fo;
 
239
        plugin_data->f = f;
 
240
        plugin_data->cross_time = cross_time;
 
241
}
 
242
 
 
243
void _init() {
 
244
        char **port_names;
 
245
        LADSPA_PortDescriptor *port_descriptors;
 
246
        LADSPA_PortRangeHint *port_range_hints;
 
247
 
 
248
#ifdef ENABLE_NLS
 
249
#define D_(s) dgettext(PACKAGE, s)
 
250
        setlocale(LC_ALL, "");
 
251
        bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
 
252
#else
 
253
#define D_(s) (s)
 
254
#endif
 
255
 
 
256
 
 
257
        freqTrackerDescriptor =
 
258
         (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));
 
259
 
 
260
        if (freqTrackerDescriptor) {
 
261
                freqTrackerDescriptor->UniqueID = 1418;
 
262
                freqTrackerDescriptor->Label = "freqTracker";
 
263
                freqTrackerDescriptor->Properties =
 
264
                 LADSPA_PROPERTY_HARD_RT_CAPABLE;
 
265
                freqTrackerDescriptor->Name =
 
266
                 D_("Frequency tracker");
 
267
                freqTrackerDescriptor->Maker =
 
268
                 "Steve Harris <steve@plugin.org.uk>";
 
269
                freqTrackerDescriptor->Copyright =
 
270
                 "GPL";
 
271
                freqTrackerDescriptor->PortCount = 3;
 
272
 
 
273
                port_descriptors = (LADSPA_PortDescriptor *)calloc(3,
 
274
                 sizeof(LADSPA_PortDescriptor));
 
275
                freqTrackerDescriptor->PortDescriptors =
 
276
                 (const LADSPA_PortDescriptor *)port_descriptors;
 
277
 
 
278
                port_range_hints = (LADSPA_PortRangeHint *)calloc(3,
 
279
                 sizeof(LADSPA_PortRangeHint));
 
280
                freqTrackerDescriptor->PortRangeHints =
 
281
                 (const LADSPA_PortRangeHint *)port_range_hints;
 
282
 
 
283
                port_names = (char **)calloc(3, sizeof(char*));
 
284
                freqTrackerDescriptor->PortNames =
 
285
                 (const char **)port_names;
 
286
 
 
287
                /* Parameters for Tracking speed */
 
288
                port_descriptors[FREQTRACKER_SPEED] =
 
289
                 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
 
290
                port_names[FREQTRACKER_SPEED] =
 
291
                 D_("Tracking speed");
 
292
                port_range_hints[FREQTRACKER_SPEED].HintDescriptor =
 
293
                 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MIDDLE;
 
294
                port_range_hints[FREQTRACKER_SPEED].LowerBound = 0;
 
295
                port_range_hints[FREQTRACKER_SPEED].UpperBound = 1;
 
296
 
 
297
                /* Parameters for Input */
 
298
                port_descriptors[FREQTRACKER_INPUT] =
 
299
                 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
 
300
                port_names[FREQTRACKER_INPUT] =
 
301
                 D_("Input");
 
302
                port_range_hints[FREQTRACKER_INPUT].HintDescriptor = 0;
 
303
 
 
304
                /* Parameters for Frequency (Hz) */
 
305
                port_descriptors[FREQTRACKER_FREQ] =
 
306
                 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
 
307
                port_names[FREQTRACKER_FREQ] =
 
308
                 D_("Frequency (Hz)");
 
309
                port_range_hints[FREQTRACKER_FREQ].HintDescriptor = 0;
 
310
 
 
311
                freqTrackerDescriptor->activate = activateFreqTracker;
 
312
                freqTrackerDescriptor->cleanup = cleanupFreqTracker;
 
313
                freqTrackerDescriptor->connect_port = connectPortFreqTracker;
 
314
                freqTrackerDescriptor->deactivate = NULL;
 
315
                freqTrackerDescriptor->instantiate = instantiateFreqTracker;
 
316
                freqTrackerDescriptor->run = runFreqTracker;
 
317
                freqTrackerDescriptor->run_adding = runAddingFreqTracker;
 
318
                freqTrackerDescriptor->set_run_adding_gain = setRunAddingGainFreqTracker;
 
319
        }
 
320
}
 
321
 
 
322
void _fini() {
 
323
        if (freqTrackerDescriptor) {
 
324
                free((LADSPA_PortDescriptor *)freqTrackerDescriptor->PortDescriptors);
 
325
                free((char **)freqTrackerDescriptor->PortNames);
 
326
                free((LADSPA_PortRangeHint *)freqTrackerDescriptor->PortRangeHints);
 
327
                free(freqTrackerDescriptor);
 
328
        }
 
329
 
 
330
}