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
|
#include "compute.h"
#include "fft.h"
#include <math.h>
#define MIN_SAMPLES 256
#define MAX_SAMPLES 2048
//#define MAX(a,b) (a>b?a:b)
//#define MIN(a,b) (a<b?a:b)
//static inline float todB_a(const float *x);
void compute_spectrum(float *data, int width, float output[PSHalf]);
float compute_level(const float *data, size_t nsamples, int rate) {
size_t i;
float input[MAX_SAMPLES], pwrspec[PSHalf];
float value;
int f, min_f_index, max_f_index;
if (nsamples >= MAX_SAMPLES) {
printf("WARN : nsamples >= MAX_SAMPLES : %i >= %i\n", nsamples, MAX_SAMPLES);
nsamples=MAX_SAMPLES;
}
if (nsamples < MIN_SAMPLES) {
printf("WARN : nsamples < MIN_SAMPLES : %i >= %i\n", nsamples, MIN_SAMPLES);
return -120.f;
}
/* Replicate with symmetry the sound to obtain an input buffer of the minimal len
for (i=0;i<MIN_SAMPLES;i++) {
if ( (i/nsamples)%2==1 )
input[i]=data[i]; // First channel only
else
input[i]=data[nsamples-i-1];
}
nsamples=MIN_SAMPLES;
} else {*/
for (i=0;i<nsamples;i++) {
input[i]=data[i]; // First channel only
}
//}
compute_spectrum(input, nsamples, pwrspec);
// Compute the mean power for 200Hz to 2000Hz band
min_f_index=((float)PSHalf)*200.f/(((float)rate)/2.f);
max_f_index=((float)PSHalf)*2000.f/(((float)rate)/2.f);
value=0.f;
for (f=min_f_index;f<=max_f_index;f++) {
value+=pwrspec[f];
}
// Mean value
value=value/(max_f_index-min_f_index+1);
return value;
}
/*
static inline float todB_a(const float *x){
return (float)((*(int32_t *)x)&0x7fffffff) * 7.17711438e-7f -764.6161886f;
}
*/
// Adapted from Audacity
void compute_spectrum(float *data, int width, float output[PSHalf]) {
int i, start, windows;
float temp;
float in[PSNumS];
float out[PSHalf];
float processed[PSHalf]={0.0f};
start = 0;
windows = 0;
while (start + PSNumS <= width) {
// Windowing : Hanning
for (i=0; i<PSNumS; i++)
in[i] = data[start+i] *(0.50-0.50*cos(2*M_PI*i/(PSNumS-1)));
// Returns only the real part of the result
PowerSpectrum(in, out);
for (i=0; i<PSHalf; i++)
processed[i] += out[i];
start += PSHalf;
windows++;
}
// Convert to decibels
// But do it safely; -Inf is nobody's friend
for (i = 0; i < PSHalf; i++){
temp=(processed[i] / PSNumS / windows);
if (temp > 0.0)
output[i] = 10*log10(temp);
else
output[i] = 0;
}
}
void audio2hsv_1(float audio_level, float *light_h, float *light_s, float *light_v) {
static float hue=0;
float level_norm=(38.f+audio_level)/30.f;
if (level_norm<0.0f) level_norm=0.f;
//if (level_norm<0.1f) level_norm=0.f; //FIXME : ici cache misere pour le tremblement sur plancher bruit
if (level_norm>1.f) level_norm=1.f;
hue=(hue+0.0002f);
if (hue>1.f) hue-=1.f;
// printf("%+3.1f %+1.3f\n", audio_level, level_norm);
// Dummy code
*light_h=hue;
*light_s=1.f;
*light_v=level_norm;
}
|
