1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*
* lingot, a musical instrument tuner.
*
* Copyright (C) 2004-2011 Ibán Cereijo Graña, Jairo Chapela Martínez.
*
* This file is part of lingot.
*
* lingot is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* lingot is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with lingot; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <math.h>
#include "lingot-signal.h"
/*
peak identification functions.
*/
FLT lingot_signal_get_noise_threshold(LingotConfig* conf, FLT w) {
//return 0.5*(1.0 - 0.9*w/M_PI);
return pow(10.0, (conf->noise_threshold_db * (1.0 - 0.9 * w / M_PI)) / 10.0);
//return conf->noise_threshold_un;
}
//---------------------------------------------------------------------------
/* returns the index of the maximun of the buffer x of size N */
void lingot_signal_get_max(FLT *x, int N, int* Mi) {
register int i;
FLT M;
M = -1.0;
*Mi = -1;
for (i = 0; i < N; i++) {
if (x[i] > M) {
M = x[i];
*Mi = i;
}
}
}
//---------------------------------------------------------------------------
int lingot_signal_is_peak(LingotConfig* conf, FLT* x, int index) {
register unsigned int j;
//static FLT delta_w_FFT = 2.0*M_PI/conf->FFT_SIZE; // resolution in rads
// a peak must be greater than noise threshold.
if (x[index] < conf->noise_threshold_nu)
return 0;
for (j = 0; j < conf->peak_half_width; j++) {
if (x[index + j] < x[index + j + 1])
return 0;
if (x[index - j] < x[index - j - 1])
return 0;
}
return 1;
}
//---------------------------------------------------------------------------
// search the fundamental peak given the spd and its 2nd derivative
int lingot_signal_get_fundamental_peak(LingotConfig* conf, FLT *x, FLT* d2x,
int N) {
register unsigned int i, j, m;
int p_index[conf->peak_number];
// at this moment there is no peaks.
for (i = 0; i < conf->peak_number; i++)
p_index[i] = -1;
unsigned int lowest_index = (unsigned int) ceil(conf->min_frequency * (1.0
* conf->oversampling / conf->sample_rate) * conf->fft_size);
if (lowest_index < conf->peak_half_width)
lowest_index = conf->peak_half_width;
// I'll get the PEAK_NUMBER maximum peaks.
for (i = lowest_index; i < N - conf->peak_half_width; i++)
if (lingot_signal_is_peak(conf, x, i)) {
// search a place in the maximums buffer, if it doesn't exists, the
// lower maximum is candidate to be replaced.
m = 0; // first candidate.
for (j = 0; j < conf->peak_number; j++) {
if (p_index[j] == -1) {
m = j; // there is a place.
break;
}
if (d2x[p_index[j]] < d2x[p_index[m]])
m = j; // search the lowest.
}
if (p_index[m] == -1)
p_index[m] = i; // there is a place
else if (d2x[i] > d2x[p_index[m]])
p_index[m] = i; // if greater
}
FLT maximum = 0.0;
int maximum_index = -1;
// search the maximum peak
for (i = 0; i < conf->peak_number; i++)
if ((p_index[i] != -1) && (x[p_index[i]] > maximum)) {
maximum = x[p_index[i]];
maximum_index = p_index[i];
}
if (maximum_index == -1)
return N;
// all peaks much lower than maximum are deleted.
for (i = 0; i < conf->peak_number; i++)
if ((p_index[i] == -1) || (conf->peak_rejection_relation_nu
* x[p_index[i]] < maximum))
p_index[i] = N; // there are available places in the buffer.
// search the lowest maximum index.
for (m = 0, j = 0; j < conf->peak_number; j++) {
if (p_index[j] < p_index[m])
m = j;
}
return p_index[m];
}
//---------------------------------------------------------------------------
// generates a Hamming window of N samples
void lingot_signal_window(int N, FLT* out, window_type_t window_type) {
register int i;
switch (window_type) {
case RECTANGULAR:
for (i = 0; i < N; i++)
out[i] = 1.0;
break;
case HANNING:
for (i = 0; i < N; i++)
out[i] = 0.5 * (1 - cos((2.0 * M_PI * i) / (N - 1)));
break;
case HAMMING:
for (i = 0; i < N; i++)
out[i] = 0.53836 - 0.46164 * cos((2.0 * M_PI * i) / (N - 1));
break;
default:
break;
}
}
|
