1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2019 Joël Krähemann
3 *
4 * This file is part of GSequencer.
5 *
6 * GSequencer is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GSequencer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GSequencer. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <glib.h>
21 #include <glib-object.h>
22
23 #include <CUnit/CUnit.h>
24 #include <CUnit/Automated.h>
25 #include <CUnit/Basic.h>
26
27 #include <ags/libags.h>
28 #include <ags/libags-audio.h>
29
30 int ags_filter_util_test_init_suite();
31 int ags_filter_util_test_clean_suite();
32
33 void ags_filter_util_test_pitch_s8();
34 void ags_filter_util_test_pitch_s16();
35 void ags_filter_util_test_pitch_s24();
36 void ags_filter_util_test_pitch_s32();
37 void ags_filter_util_test_pitch_s64();
38 void ags_filter_util_test_pitch_float();
39 void ags_filter_util_test_pitch_double();
40 void ags_filter_util_test_pitch_complex();
41
42 #define AGS_FILTER_UTIL_TEST_FREQ (440.0)
43 #define AGS_FILTER_UTIL_TEST_PHASE (0.0)
44 #define AGS_FILTER_UTIL_TEST_VOLUME (1.0)
45 #define AGS_FILTER_UTIL_TEST_SAMPLERATE (44100)
46 #define AGS_FILTER_UTIL_TEST_OFFSET (0)
47 #define AGS_FILTER_UTIL_TEST_FRAME_COUNT (1024)
48 #define AGS_FILTER_UTIL_TEST_BASE_KEY (0.0)
49 #define AGS_FILTER_UTIL_TEST_TUNING (200.0)
50
51 /* The suite initialization function.
52 * Opens the temporary file used by the tests.
53 * Returns zero on success, non-zero otherwise.
54 */
55 int
ags_filter_util_test_init_suite()56 ags_filter_util_test_init_suite()
57 {
58 return(0);
59 }
60
61 /* The suite cleanup function.
62 * Closes the temporary file used by the tests.
63 * Returns zero on success, non-zero otherwise.
64 */
65 int
ags_filter_util_test_clean_suite()66 ags_filter_util_test_clean_suite()
67 {
68 return(0);
69 }
70
71 void
ags_filter_util_test_pitch_s8()72 ags_filter_util_test_pitch_s8()
73 {
74 gint8 *buffer;
75
76 gboolean success;
77
78 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
79 AGS_SOUNDCARD_SIGNED_8_BIT);
80
81 ags_synth_util_sin_s8(buffer,
82 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
83 AGS_FILTER_UTIL_TEST_SAMPLERATE,
84 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
85
86 ags_filter_util_pitch_s8(buffer,
87 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
88 AGS_FILTER_UTIL_TEST_SAMPLERATE,
89 AGS_FILTER_UTIL_TEST_BASE_KEY,
90 AGS_FILTER_UTIL_TEST_TUNING);
91
92 success = TRUE;
93
94 //TODO:JK: implement me
95
96 CU_ASSERT(success == TRUE);
97 }
98
99 void
ags_filter_util_test_pitch_s16()100 ags_filter_util_test_pitch_s16()
101 {
102 gint16 *buffer;
103
104 gboolean success;
105
106 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
107 AGS_SOUNDCARD_SIGNED_16_BIT);
108
109 ags_synth_util_sin_s16(buffer,
110 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
111 AGS_FILTER_UTIL_TEST_SAMPLERATE,
112 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
113
114 ags_filter_util_pitch_s16(buffer,
115 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
116 AGS_FILTER_UTIL_TEST_SAMPLERATE,
117 AGS_FILTER_UTIL_TEST_BASE_KEY,
118 AGS_FILTER_UTIL_TEST_TUNING);
119
120 success = TRUE;
121
122 //TODO:JK: implement me
123
124 CU_ASSERT(success == TRUE);
125 }
126
127 void
ags_filter_util_test_pitch_s24()128 ags_filter_util_test_pitch_s24()
129 {
130 gint32 *buffer;
131
132 gboolean success;
133
134 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
135 AGS_SOUNDCARD_SIGNED_24_BIT);
136
137 ags_synth_util_sin_s24(buffer,
138 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
139 AGS_FILTER_UTIL_TEST_SAMPLERATE,
140 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
141
142 ags_filter_util_pitch_s24(buffer,
143 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
144 AGS_FILTER_UTIL_TEST_SAMPLERATE,
145 AGS_FILTER_UTIL_TEST_BASE_KEY,
146 AGS_FILTER_UTIL_TEST_TUNING);
147
148 success = TRUE;
149
150 //TODO:JK: implement me
151
152 CU_ASSERT(success == TRUE);
153 }
154
155 void
ags_filter_util_test_pitch_s32()156 ags_filter_util_test_pitch_s32()
157 {
158 gint32 *buffer;
159
160 gboolean success;
161
162 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
163 AGS_SOUNDCARD_SIGNED_32_BIT);
164
165 ags_synth_util_sin_s32(buffer,
166 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
167 AGS_FILTER_UTIL_TEST_SAMPLERATE,
168 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
169
170 ags_filter_util_pitch_s32(buffer,
171 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
172 AGS_FILTER_UTIL_TEST_SAMPLERATE,
173 AGS_FILTER_UTIL_TEST_BASE_KEY,
174 AGS_FILTER_UTIL_TEST_TUNING);
175
176 success = TRUE;
177
178 //TODO:JK: implement me
179
180 CU_ASSERT(success == TRUE);
181 }
182
183 void
ags_filter_util_test_pitch_s64()184 ags_filter_util_test_pitch_s64()
185 {
186 gint64 *buffer;
187
188 gboolean success;
189
190 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
191 AGS_SOUNDCARD_SIGNED_64_BIT);
192
193 ags_synth_util_sin_s64(buffer,
194 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
195 AGS_FILTER_UTIL_TEST_SAMPLERATE,
196 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
197
198 ags_filter_util_pitch_s64(buffer,
199 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
200 AGS_FILTER_UTIL_TEST_SAMPLERATE,
201 AGS_FILTER_UTIL_TEST_BASE_KEY,
202 AGS_FILTER_UTIL_TEST_TUNING);
203
204 success = TRUE;
205
206 //TODO:JK: implement me
207
208 CU_ASSERT(success == TRUE);
209 }
210
211 void
ags_filter_util_test_pitch_float()212 ags_filter_util_test_pitch_float()
213 {
214 gfloat *buffer;
215
216 gboolean success;
217
218 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
219 AGS_SOUNDCARD_FLOAT);
220
221 ags_synth_util_sin_float(buffer,
222 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
223 AGS_FILTER_UTIL_TEST_SAMPLERATE,
224 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
225
226 ags_filter_util_pitch_float(buffer,
227 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
228 AGS_FILTER_UTIL_TEST_SAMPLERATE,
229 AGS_FILTER_UTIL_TEST_BASE_KEY,
230 AGS_FILTER_UTIL_TEST_TUNING);
231
232 success = TRUE;
233
234 //TODO:JK: implement me
235
236 CU_ASSERT(success == TRUE);
237 }
238
239 void
ags_filter_util_test_pitch_double()240 ags_filter_util_test_pitch_double()
241 {
242 gdouble *buffer;
243
244 gboolean success;
245
246 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
247 AGS_SOUNDCARD_DOUBLE);
248
249 ags_synth_util_sin_double(buffer,
250 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
251 AGS_FILTER_UTIL_TEST_SAMPLERATE,
252 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
253
254 ags_filter_util_pitch_double(buffer,
255 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
256 AGS_FILTER_UTIL_TEST_SAMPLERATE,
257 AGS_FILTER_UTIL_TEST_BASE_KEY,
258 AGS_FILTER_UTIL_TEST_TUNING);
259
260 success = TRUE;
261
262 //TODO:JK: implement me
263
264 CU_ASSERT(success == TRUE);
265 }
266
267 void
ags_filter_util_test_pitch_complex()268 ags_filter_util_test_pitch_complex()
269 {
270 AgsComplex *buffer;
271
272 gboolean success;
273
274 buffer = ags_stream_alloc(AGS_FILTER_UTIL_TEST_FRAME_COUNT,
275 AGS_SOUNDCARD_COMPLEX);
276
277 ags_synth_util_sin_complex(buffer,
278 AGS_FILTER_UTIL_TEST_FREQ, AGS_FILTER_UTIL_TEST_PHASE, AGS_FILTER_UTIL_TEST_VOLUME,
279 AGS_FILTER_UTIL_TEST_SAMPLERATE,
280 AGS_FILTER_UTIL_TEST_OFFSET, AGS_FILTER_UTIL_TEST_FRAME_COUNT);
281
282 ags_filter_util_pitch_complex(buffer,
283 AGS_FILTER_UTIL_TEST_FRAME_COUNT,
284 AGS_FILTER_UTIL_TEST_SAMPLERATE,
285 AGS_FILTER_UTIL_TEST_BASE_KEY,
286 AGS_FILTER_UTIL_TEST_TUNING);
287
288 success = TRUE;
289
290 //TODO:JK: implement me
291
292 CU_ASSERT(success == TRUE);
293 }
294
295 int
main(int argc,char ** argv)296 main(int argc, char **argv)
297 {
298 CU_pSuite pSuite = NULL;
299
300 putenv("LC_ALL=C");
301 putenv("LANG=C");
302
303 /* initialize the CUnit test registry */
304 if(CUE_SUCCESS != CU_initialize_registry()){
305 return CU_get_error();
306 }
307
308 /* add a suite to the registry */
309 pSuite = CU_add_suite("AgsFMSynthUtilTest", ags_filter_util_test_init_suite, ags_filter_util_test_clean_suite);
310
311 if(pSuite == NULL){
312 CU_cleanup_registry();
313
314 return CU_get_error();
315 }
316
317 /* add the tests to the suite */
318 if((CU_add_test(pSuite, "test of ags_filter_util.c pitch signed 8 bit", ags_filter_util_test_pitch_s8) == NULL) ||
319 (CU_add_test(pSuite, "test of ags_filter_util.c pitch signed 16 bit", ags_filter_util_test_pitch_s16) == NULL) ||
320 (CU_add_test(pSuite, "test of ags_filter_util.c pitch signed 24 bit", ags_filter_util_test_pitch_s24) == NULL) ||
321 (CU_add_test(pSuite, "test of ags_filter_util.c pitch signed 32 bit", ags_filter_util_test_pitch_s32) == NULL) ||
322 (CU_add_test(pSuite, "test of ags_filter_util.c pitch signed 64 bit", ags_filter_util_test_pitch_s64) == NULL) ||
323 (CU_add_test(pSuite, "test of ags_filter_util.c pitch float", ags_filter_util_test_pitch_float) == NULL) ||
324 (CU_add_test(pSuite, "test of ags_filter_util.c pitch double", ags_filter_util_test_pitch_double) == NULL) ||
325 (CU_add_test(pSuite, "test of ags_filter_util.c pitch complex", ags_filter_util_test_pitch_complex) == NULL)){
326 CU_cleanup_registry();
327
328 return CU_get_error();
329 }
330
331 /* Run all tests using the CUnit Basic interface */
332 CU_basic_set_mode(CU_BRM_VERBOSE);
333 CU_basic_run_tests();
334
335 CU_cleanup_registry();
336
337 return(CU_get_error());
338 }
339