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
|
#include "test.h"
#include "fluidsynth.h"
#include "fluidsynth_priv.h"
#include "fluid_synth.h"
#include <string.h>
// static const int CHANNELS=16;
enum { SAMPLES=1024 };
static int smpl;
int render_one_mock(fluid_synth_t *synth, int blocks)
{
fluid_real_t *left_in, *fx_left_in;
fluid_real_t *right_in, *fx_right_in;
int i, j;
int naudchan = fluid_synth_count_audio_channels(synth);
fluid_rvoice_mixer_get_bufs(synth->eventhandler->mixer, &left_in, &right_in);
fluid_rvoice_mixer_get_fx_bufs(synth->eventhandler->mixer, &fx_left_in, &fx_right_in);
for(i = 0; i < naudchan; i++)
{
for(j = 0; j < blocks * FLUID_BUFSIZE; j++)
{
int idx = i * FLUID_MIXER_MAX_BUFFERS_DEFAULT * FLUID_BUFSIZE + j;
right_in[idx] = left_in[idx] = (float)smpl++;
}
}
return blocks;
}
int process_and_check(fluid_synth_t* synth, int number_of_samples, int offset)
{
int i;
float left[SAMPLES], right[SAMPLES];
float *dry[1 * 2];
dry[0] = left;
dry[1] = right;
FLUID_MEMSET(left, 0, sizeof(left));
FLUID_MEMSET(right, 0, sizeof(right));
TEST_SUCCESS(fluid_synth_process_LOCAL(synth, number_of_samples, 0, NULL, 2, dry, render_one_mock));
for(i=0; i<number_of_samples; i++)
{
TEST_ASSERT(left[i]==offset);
TEST_ASSERT(right[i]==offset);
offset++;
}
return offset;
}
int write_and_check(fluid_synth_t* synth, int number_of_samples, int offset)
{
int i;
float buf[2*SAMPLES];
FLUID_MEMSET(buf, 0, sizeof(buf));
// one buffer, interleaved writing
TEST_SUCCESS(fluid_synth_write_float_LOCAL(synth, number_of_samples, buf, 0, 2, buf, 1, 2, render_one_mock));
for(i=0; i< 2*number_of_samples; i+=2)
{
TEST_ASSERT(buf[i+0] == offset);
TEST_ASSERT(buf[i+1] == offset);
offset++;
}
FLUID_MEMSET(buf, 0, sizeof(buf));
// "two" buffers, planar writing
TEST_SUCCESS(fluid_synth_write_float_LOCAL(synth, number_of_samples, buf, 0, 1, buf, SAMPLES, 1, render_one_mock));
for(i=0; i< number_of_samples; i++)
{
TEST_ASSERT(buf[i+0] == offset);
TEST_ASSERT(buf[i+SAMPLES] == offset);
offset++;
}
return offset;
}
// this test should make sure that sample rate changed are handled correctly
int main(void)
{
int off=0;
fluid_synth_t *synth;
fluid_settings_t *settings = new_fluid_settings();
TEST_ASSERT(settings != NULL);
synth = new_fluid_synth(settings);
TEST_ASSERT(synth != NULL);
off = process_and_check(synth, 100, off);
off = process_and_check(synth, 200, off);
off = process_and_check(synth, 300, off);
// next statement should not result in a call to render_one_mock() and therefore not increase the static "smpl" var
off = process_and_check(synth, 0, off);
off = process_and_check(synth, 1000, off);
off = process_and_check(synth, SAMPLES, off);
off = process_and_check(synth, 900, off);
off = process_and_check(synth, 800, off);
off = process_and_check(synth, FLUID_BUFSIZE, off);
// currently it is not possible to call different rendering functions subsequently
off = smpl;
off = write_and_check(synth, 100, off);
off = write_and_check(synth, 200, off);
off = write_and_check(synth, 300, off);
off = write_and_check(synth, 0, off);
off = write_and_check(synth, 1000, off);
off = write_and_check(synth, SAMPLES, off);
off = write_and_check(synth, 900, off);
off = write_and_check(synth, 800, off);
off = write_and_check(synth, FLUID_BUFSIZE, off);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return EXIT_SUCCESS;
}
|
