1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2005-2021 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_synth_util_test_init_suite();
31 int ags_synth_util_test_clean_suite();
32
33 void ags_synth_util_test_alloc();
34 void ags_synth_util_test_copy();
35 void ags_synth_util_test_free();
36 void ags_synth_util_test_get_source();
37 void ags_synth_util_test_set_source();
38 void ags_synth_util_test_get_source_stride();
39 void ags_synth_util_test_set_source_stride();
40 void ags_synth_util_test_get_buffer_length();
41 void ags_synth_util_test_set_buffer_length();
42 void ags_synth_util_test_get_audio_buffer_util_format();
43 void ags_synth_util_test_set_audio_buffer_util_format();
44 void ags_synth_util_test_get_samplerate();
45 void ags_synth_util_test_set_samplerate();
46 void ags_synth_util_test_get_synth_oscillator_mode();
47 void ags_synth_util_test_set_synth_oscillator_mode();
48 void ags_synth_util_test_get_frequency();
49 void ags_synth_util_test_set_frequency();
50 void ags_synth_util_test_get_phase();
51 void ags_synth_util_test_set_phase();
52 void ags_synth_util_test_get_volume();
53 void ags_synth_util_test_set_volume();
54 void ags_synth_util_test_get_frame_count();
55 void ags_synth_util_test_set_frame_count();
56 void ags_synth_util_test_get_offset();
57 void ags_synth_util_test_set_offset();
58
59 void ags_synth_util_test_compute_sin_s8();
60 void ags_synth_util_test_compute_sin_s16();
61 void ags_synth_util_test_compute_sin_s24();
62 void ags_synth_util_test_compute_sin_s32();
63 void ags_synth_util_test_compute_sin_s64();
64 void ags_synth_util_test_compute_sin_float();
65 void ags_synth_util_test_compute_sin_double();
66 void ags_synth_util_test_compute_sin_complex();
67
68 void ags_synth_util_test_sin_s8();
69 void ags_synth_util_test_sin_s16();
70 void ags_synth_util_test_sin_s24();
71 void ags_synth_util_test_sin_s32();
72 void ags_synth_util_test_sin_s64();
73 void ags_synth_util_test_sin_float();
74 void ags_synth_util_test_sin_double();
75 void ags_synth_util_test_sin_complex();
76
77 void ags_synth_util_test_compute_sawtooth_s8();
78 void ags_synth_util_test_compute_sawtooth_s16();
79 void ags_synth_util_test_compute_sawtooth_s24();
80 void ags_synth_util_test_compute_sawtooth_s32();
81 void ags_synth_util_test_compute_sawtooth_s64();
82 void ags_synth_util_test_compute_sawtooth_float();
83 void ags_synth_util_test_compute_sawtooth_double();
84 void ags_synth_util_test_compute_sawtooth_complex();
85
86 void ags_synth_util_test_sawtooth_s8();
87 void ags_synth_util_test_sawtooth_s16();
88 void ags_synth_util_test_sawtooth_s24();
89 void ags_synth_util_test_sawtooth_s32();
90 void ags_synth_util_test_sawtooth_s64();
91 void ags_synth_util_test_sawtooth_float();
92 void ags_synth_util_test_sawtooth_double();
93 void ags_synth_util_test_sawtooth_complex();
94
95 void ags_synth_util_test_compute_triangle_s8();
96 void ags_synth_util_test_compute_triangle_s16();
97 void ags_synth_util_test_compute_triangle_s24();
98 void ags_synth_util_test_compute_triangle_s32();
99 void ags_synth_util_test_compute_triangle_s64();
100 void ags_synth_util_test_compute_triangle_float();
101 void ags_synth_util_test_compute_triangle_double();
102 void ags_synth_util_test_compute_triangle_complex();
103
104 void ags_synth_util_test_triangle_s8();
105 void ags_synth_util_test_triangle_s16();
106 void ags_synth_util_test_triangle_s24();
107 void ags_synth_util_test_triangle_s32();
108 void ags_synth_util_test_triangle_s64();
109 void ags_synth_util_test_triangle_float();
110 void ags_synth_util_test_triangle_double();
111 void ags_synth_util_test_triangle_complex();
112
113 void ags_synth_util_test_compute_square_s8();
114 void ags_synth_util_test_compute_square_s16();
115 void ags_synth_util_test_compute_square_s24();
116 void ags_synth_util_test_compute_square_s32();
117 void ags_synth_util_test_compute_square_s64();
118 void ags_synth_util_test_compute_square_float();
119 void ags_synth_util_test_compute_square_double();
120 void ags_synth_util_test_compute_square_complex();
121
122 void ags_synth_util_test_square_s8();
123 void ags_synth_util_test_square_s16();
124 void ags_synth_util_test_square_s24();
125 void ags_synth_util_test_square_s32();
126 void ags_synth_util_test_square_s64();
127 void ags_synth_util_test_square_float();
128 void ags_synth_util_test_square_double();
129 void ags_synth_util_test_square_complex();
130
131 void ags_synth_util_test_compute_impulse_s8();
132 void ags_synth_util_test_compute_impulse_s16();
133 void ags_synth_util_test_compute_impulse_s24();
134 void ags_synth_util_test_compute_impulse_s32();
135 void ags_synth_util_test_compute_impulse_s64();
136 void ags_synth_util_test_compute_impulse_float();
137 void ags_synth_util_test_compute_impulse_double();
138 void ags_synth_util_test_compute_impulse_complex();
139
140 void ags_synth_util_test_impulse_s8();
141 void ags_synth_util_test_impulse_s16();
142 void ags_synth_util_test_impulse_s24();
143 void ags_synth_util_test_impulse_s32();
144 void ags_synth_util_test_impulse_s64();
145 void ags_synth_util_test_impulse_float();
146 void ags_synth_util_test_impulse_double();
147 void ags_synth_util_test_impulse_complex();
148
149 #define AGS_SYNTH_UTIL_TEST_PHASE (0.0)
150 #define AGS_SYNTH_UTIL_TEST_VOLUME (1.0)
151 #define AGS_SYNTH_UTIL_TEST_SAMPLERATE (44100)
152 #define AGS_SYNTH_UTIL_TEST_OFFSET (0)
153 #define AGS_SYNTH_UTIL_TEST_FRAME_COUNT (1024)
154
155 gdouble test_freq[] = {
156 13289.75,
157 7040.00,
158 880.0,
159 440.0,
160 220.0,
161 27.5,
162 8.18,
163 -1.0,
164 };
165
166 /* The suite initialization function.
167 * Opens the temporary file used by the tests.
168 * Returns zero on success, non-zero otherwise.
169 */
170 int
ags_synth_util_test_init_suite()171 ags_synth_util_test_init_suite()
172 {
173 return(0);
174 }
175
176 /* The suite cleanup function.
177 * Closes the temporary file used by the tests.
178 * Returns zero on success, non-zero otherwise.
179 */
180 int
ags_synth_util_test_clean_suite()181 ags_synth_util_test_clean_suite()
182 {
183 return(0);
184 }
185
186 void
ags_synth_util_test_alloc()187 ags_synth_util_test_alloc()
188 {
189 AgsSynthUtil *synth_util;
190
191 synth_util = ags_synth_util_alloc();
192
193 CU_ASSERT(synth_util != NULL);
194 }
195
196 void
ags_synth_util_test_copy()197 ags_synth_util_test_copy()
198 {
199 AgsSynthUtil *ptr;
200 AgsSynthUtil synth_util;
201
202 synth_util.source = ags_stream_alloc(2 * 1024,
203 AGS_SOUNDCARD_SIGNED_16_BIT);
204
205 synth_util.source_stride = 2;
206
207 synth_util.buffer_length = 2 * 1024;
208 synth_util.audio_buffer_util_format = AGS_AUDIO_BUFFER_UTIL_S16;
209 synth_util.samplerate = 44100;
210
211 synth_util.synth_oscillator_mode = AGS_SYNTH_OSCILLATOR_IMPULSE;
212
213 synth_util.frequency = 220.0;
214 synth_util.phase = 0.0;
215 synth_util.volume = 1.0;
216
217 synth_util.frame_count = 4096;
218 synth_util.offset = 0;
219
220 ptr = ags_synth_util_copy(&synth_util);
221
222 CU_ASSERT(ptr != NULL);
223
224 CU_ASSERT(ptr->source == synth_util.source);
225 CU_ASSERT(ptr->source_stride == synth_util.source_stride);
226
227 CU_ASSERT(ptr->buffer_length == synth_util.buffer_length);
228 CU_ASSERT(ptr->audio_buffer_util_format == synth_util.audio_buffer_util_format);
229 CU_ASSERT(ptr->samplerate == synth_util.samplerate);
230
231 CU_ASSERT(ptr->frequency == synth_util.frequency);
232 CU_ASSERT(ptr->phase == synth_util.phase);
233 CU_ASSERT(ptr->volume == synth_util.volume);
234
235 CU_ASSERT(ptr->frame_count == synth_util.frame_count);
236 CU_ASSERT(ptr->offset == synth_util.offset);
237 }
238
239 void
ags_synth_util_test_free()240 ags_synth_util_test_free()
241 {
242 AgsSynthUtil *synth_util;
243
244 synth_util = ags_synth_util_alloc();
245
246 CU_ASSERT(synth_util != NULL);
247
248 ags_synth_util_free(synth_util);
249 }
250
251 void
ags_synth_util_test_get_source()252 ags_synth_util_test_get_source()
253 {
254 AgsSynthUtil synth_util;
255
256 synth_util.source = ags_stream_alloc(2 * 1024,
257 AGS_SOUNDCARD_SIGNED_16_BIT);
258
259 CU_ASSERT(ags_synth_util_get_source(&synth_util) == synth_util.source);
260 }
261
262 void
ags_synth_util_test_set_source()263 ags_synth_util_test_set_source()
264 {
265 AgsSynthUtil synth_util;
266
267 gpointer source;
268
269 source = ags_stream_alloc(2 * 1024,
270 AGS_SOUNDCARD_SIGNED_16_BIT);
271
272 ags_synth_util_set_source(&synth_util,
273 source);
274
275 CU_ASSERT(synth_util.source == synth_util.source);
276 }
277
278 void
ags_synth_util_test_get_source_stride()279 ags_synth_util_test_get_source_stride()
280 {
281 //TODO:JK: implement me
282 }
283
284 void
ags_synth_util_test_set_source_stride()285 ags_synth_util_test_set_source_stride()
286 {
287 //TODO:JK: implement me
288 }
289
290 void
ags_synth_util_test_get_buffer_length()291 ags_synth_util_test_get_buffer_length()
292 {
293 //TODO:JK: implement me
294 }
295
296 void
ags_synth_util_test_set_buffer_length()297 ags_synth_util_test_set_buffer_length()
298 {
299 //TODO:JK: implement me
300 }
301
302 void
ags_synth_util_test_get_audio_buffer_util_format()303 ags_synth_util_test_get_audio_buffer_util_format()
304 {
305 //TODO:JK: implement me
306 }
307
308 void
ags_synth_util_test_set_audio_buffer_util_format()309 ags_synth_util_test_set_audio_buffer_util_format()
310 {
311 //TODO:JK: implement me
312 }
313
314 void
ags_synth_util_test_get_samplerate()315 ags_synth_util_test_get_samplerate()
316 {
317 //TODO:JK: implement me
318 }
319
320 void
ags_synth_util_test_set_samplerate()321 ags_synth_util_test_set_samplerate()
322 {
323 //TODO:JK: implement me
324 }
325
326 void
ags_synth_util_test_get_synth_oscillator_mode()327 ags_synth_util_test_get_synth_oscillator_mode()
328 {
329 //TODO:JK: implement me
330 }
331
332 void
ags_synth_util_test_set_synth_oscillator_mode()333 ags_synth_util_test_set_synth_oscillator_mode()
334 {
335 //TODO:JK: implement me
336 }
337
338 void
ags_synth_util_test_get_frequency()339 ags_synth_util_test_get_frequency()
340 {
341 //TODO:JK: implement me
342 }
343
344 void
ags_synth_util_test_set_frequency()345 ags_synth_util_test_set_frequency()
346 {
347 //TODO:JK: implement me
348 }
349
350 void
ags_synth_util_test_get_phase()351 ags_synth_util_test_get_phase()
352 {
353 //TODO:JK: implement me
354 }
355
356 void
ags_synth_util_test_set_phase()357 ags_synth_util_test_set_phase()
358 {
359 //TODO:JK: implement me
360 }
361
362 void
ags_synth_util_test_get_volume()363 ags_synth_util_test_get_volume()
364 {
365 //TODO:JK: implement me
366 }
367
368 void
ags_synth_util_test_set_volume()369 ags_synth_util_test_set_volume()
370 {
371 //TODO:JK: implement me
372 }
373
374 void
ags_synth_util_test_get_frame_count()375 ags_synth_util_test_get_frame_count()
376 {
377 //TODO:JK: implement me
378 }
379
380 void
ags_synth_util_test_set_frame_count()381 ags_synth_util_test_set_frame_count()
382 {
383 //TODO:JK: implement me
384 }
385
386 void
ags_synth_util_test_get_offset()387 ags_synth_util_test_get_offset()
388 {
389 //TODO:JK: implement me
390 }
391
392 void
ags_synth_util_test_set_offset()393 ags_synth_util_test_set_offset()
394 {
395 //TODO:JK: implement me
396 }
397
398 void
ags_synth_util_test_compute_sin_s8()399 ags_synth_util_test_compute_sin_s8()
400 {
401 //TODO:JK: implement me
402 }
403
404 void
ags_synth_util_test_compute_sin_s16()405 ags_synth_util_test_compute_sin_s16()
406 {
407 //TODO:JK: implement me
408 }
409
410 void
ags_synth_util_test_compute_sin_s24()411 ags_synth_util_test_compute_sin_s24()
412 {
413 //TODO:JK: implement me
414 }
415
416 void
ags_synth_util_test_compute_sin_s32()417 ags_synth_util_test_compute_sin_s32()
418 {
419 //TODO:JK: implement me
420 }
421
422 void
ags_synth_util_test_compute_sin_s64()423 ags_synth_util_test_compute_sin_s64()
424 {
425 //TODO:JK: implement me
426 }
427
428 void
ags_synth_util_test_compute_sin_float()429 ags_synth_util_test_compute_sin_float()
430 {
431 //TODO:JK: implement me
432 }
433
434 void
ags_synth_util_test_compute_sin_double()435 ags_synth_util_test_compute_sin_double()
436 {
437 //TODO:JK: implement me
438 }
439
440 void
ags_synth_util_test_compute_sin_complex()441 ags_synth_util_test_compute_sin_complex()
442 {
443 //TODO:JK: implement me
444 }
445
446
447 void
ags_synth_util_test_sin_s8()448 ags_synth_util_test_sin_s8()
449 {
450 gint8 *buffer;
451
452 guint xcross_count;
453 guint i;
454 gboolean success;
455
456 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
457 AGS_SOUNDCARD_SIGNED_8_BIT);
458
459 success = FALSE;
460
461 for(i = 0; test_freq[i] != -1.0; i++){
462 ags_audio_buffer_util_clear_buffer(buffer, 1,
463 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S8);
464
465 ags_synth_util_sin_s8(buffer,
466 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
467 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
468 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
469
470 xcross_count = ags_synth_util_get_xcross_count(buffer,
471 AGS_AUDIO_BUFFER_UTIL_S8,
472 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
473
474 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
475 }
476
477 CU_ASSERT(success == TRUE);
478 }
479
480 void
ags_synth_util_test_sin_s16()481 ags_synth_util_test_sin_s16()
482 {
483 gint16 *buffer;
484
485 guint xcross_count;
486 guint i;
487 gboolean success;
488
489 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
490 AGS_SOUNDCARD_SIGNED_16_BIT);
491
492 success = FALSE;
493
494 for(i = 0; test_freq[i] != -1.0; i++){
495 ags_audio_buffer_util_clear_buffer(buffer, 1,
496 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S16);
497
498 ags_synth_util_sin_s16(buffer,
499 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
500 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
501 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
502
503 xcross_count = ags_synth_util_get_xcross_count(buffer,
504 AGS_AUDIO_BUFFER_UTIL_S16,
505 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
506
507 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
508 }
509
510 CU_ASSERT(success == TRUE);
511 }
512
513 void
ags_synth_util_test_sin_s24()514 ags_synth_util_test_sin_s24()
515 {
516 gint32 *buffer;
517
518 guint xcross_count;
519 guint i;
520 gboolean success;
521
522 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
523 AGS_SOUNDCARD_SIGNED_24_BIT);
524
525 success = FALSE;
526
527 for(i = 0; test_freq[i] != -1.0; i++){
528 ags_audio_buffer_util_clear_buffer(buffer, 1,
529 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S24);
530
531 ags_synth_util_sin_s24(buffer,
532 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
533 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
534 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
535
536 xcross_count = ags_synth_util_get_xcross_count(buffer,
537 AGS_AUDIO_BUFFER_UTIL_S24,
538 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
539
540 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
541 }
542
543 CU_ASSERT(success == TRUE);
544 }
545
546 void
ags_synth_util_test_sin_s32()547 ags_synth_util_test_sin_s32()
548 {
549 gint32 *buffer;
550
551 guint xcross_count;
552 guint i;
553 gboolean success;
554
555 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
556 AGS_SOUNDCARD_SIGNED_32_BIT);
557
558 success = FALSE;
559
560 for(i = 0; test_freq[i] != -1.0; i++){
561 ags_audio_buffer_util_clear_buffer(buffer, 1,
562 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S32);
563
564 ags_synth_util_sin_s32(buffer,
565 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
566 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
567 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
568
569 xcross_count = ags_synth_util_get_xcross_count(buffer,
570 AGS_AUDIO_BUFFER_UTIL_S32,
571 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
572
573 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
574 }
575
576 CU_ASSERT(success == TRUE);
577 }
578
579 void
ags_synth_util_test_sin_s64()580 ags_synth_util_test_sin_s64()
581 {
582 gint64 *buffer;
583
584 guint xcross_count;
585 guint i;
586 gboolean success;
587
588 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
589 AGS_SOUNDCARD_SIGNED_64_BIT);
590
591 success = FALSE;
592
593 for(i = 0; test_freq[i] != -1.0; i++){
594 ags_audio_buffer_util_clear_buffer(buffer, 1,
595 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S64);
596
597 ags_synth_util_sin_s64(buffer,
598 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
599 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
600 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
601
602 xcross_count = ags_synth_util_get_xcross_count(buffer,
603 AGS_AUDIO_BUFFER_UTIL_S64,
604 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
605
606 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
607 }
608
609 CU_ASSERT(success == TRUE);
610 }
611
612 void
ags_synth_util_test_sin_float()613 ags_synth_util_test_sin_float()
614 {
615 gfloat *buffer;
616
617 guint xcross_count;
618 guint i;
619 gboolean success;
620
621 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
622 AGS_SOUNDCARD_FLOAT);
623
624 success = FALSE;
625
626 for(i = 0; test_freq[i] != -1.0; i++){
627 ags_audio_buffer_util_clear_buffer(buffer, 1,
628 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_FLOAT);
629
630 ags_synth_util_sin_float(buffer,
631 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
632 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
633 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
634
635 xcross_count = ags_synth_util_get_xcross_count(buffer,
636 AGS_AUDIO_BUFFER_UTIL_FLOAT,
637 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
638
639 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
640 }
641
642 CU_ASSERT(success == TRUE);
643 }
644
645 void
ags_synth_util_test_sin_double()646 ags_synth_util_test_sin_double()
647 {
648 gdouble *buffer;
649
650 guint xcross_count;
651 guint i;
652 gboolean success;
653
654 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
655 AGS_SOUNDCARD_DOUBLE);
656
657 success = FALSE;
658
659 for(i = 0; test_freq[i] != -1.0; i++){
660 ags_audio_buffer_util_clear_buffer(buffer, 1,
661 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_DOUBLE);
662
663 ags_synth_util_sin_double(buffer,
664 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
665 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
666 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
667
668 xcross_count = ags_synth_util_get_xcross_count(buffer,
669 AGS_AUDIO_BUFFER_UTIL_DOUBLE,
670 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
671
672 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
673 }
674
675 CU_ASSERT(success == TRUE);
676 }
677
678 void
ags_synth_util_test_sin_complex()679 ags_synth_util_test_sin_complex()
680 {
681 AgsComplex *buffer;
682
683 guint xcross_count;
684 guint i;
685 gboolean success;
686
687 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
688 AGS_SOUNDCARD_COMPLEX);
689
690 success = FALSE;
691
692 for(i = 0; test_freq[i] != -1.0; i++){
693 ags_audio_buffer_util_clear_buffer(buffer, 1,
694 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_COMPLEX);
695
696 ags_synth_util_sin_complex(buffer,
697 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
698 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
699 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
700
701 xcross_count = ags_synth_util_get_xcross_count(buffer,
702 AGS_AUDIO_BUFFER_UTIL_COMPLEX,
703 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
704
705 success = (xcross_count > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
706 }
707
708 CU_ASSERT(success == TRUE);
709 }
710
711 void
ags_synth_util_test_compute_sawtooth_s8()712 ags_synth_util_test_compute_sawtooth_s8()
713 {
714 //TODO:JK: implement me
715 }
716
717 void
ags_synth_util_test_compute_sawtooth_s16()718 ags_synth_util_test_compute_sawtooth_s16()
719 {
720 //TODO:JK: implement me
721 }
722
723 void
ags_synth_util_test_compute_sawtooth_s24()724 ags_synth_util_test_compute_sawtooth_s24()
725 {
726 //TODO:JK: implement me
727 }
728
729 void
ags_synth_util_test_compute_sawtooth_s32()730 ags_synth_util_test_compute_sawtooth_s32()
731 {
732 //TODO:JK: implement me
733 }
734
735 void
ags_synth_util_test_compute_sawtooth_s64()736 ags_synth_util_test_compute_sawtooth_s64()
737 {
738 //TODO:JK: implement me
739 }
740
741 void
ags_synth_util_test_compute_sawtooth_float()742 ags_synth_util_test_compute_sawtooth_float()
743 {
744 //TODO:JK: implement me
745 }
746
747 void
ags_synth_util_test_compute_sawtooth_double()748 ags_synth_util_test_compute_sawtooth_double()
749 {
750 //TODO:JK: implement me
751 }
752
753 void
ags_synth_util_test_compute_sawtooth_complex()754 ags_synth_util_test_compute_sawtooth_complex()
755 {
756 //TODO:JK: implement me
757 }
758
759
760 void
ags_synth_util_test_sawtooth_s8()761 ags_synth_util_test_sawtooth_s8()
762 {
763 gint8 *buffer;
764
765 guint xcross_count;
766 guint i;
767 gboolean success;
768
769 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
770 AGS_SOUNDCARD_SIGNED_8_BIT);
771
772 success = FALSE;
773
774 for(i = 0; test_freq[i] != -1.0; i++){
775 ags_audio_buffer_util_clear_buffer(buffer, 1,
776 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S8);
777
778 ags_synth_util_sawtooth_s8(buffer,
779 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
780 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
781 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
782
783 xcross_count = ags_synth_util_get_xcross_count(buffer,
784 AGS_AUDIO_BUFFER_UTIL_S8,
785 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
786
787 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
788 }
789
790 CU_ASSERT(success == TRUE);
791 }
792
793 void
ags_synth_util_test_sawtooth_s16()794 ags_synth_util_test_sawtooth_s16()
795 {
796 gint16 *buffer;
797
798 guint xcross_count;
799 guint i;
800 gboolean success;
801
802 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
803 AGS_SOUNDCARD_SIGNED_16_BIT);
804
805 success = FALSE;
806
807 for(i = 0; test_freq[i] != -1.0; i++){
808 ags_audio_buffer_util_clear_buffer(buffer, 1,
809 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S16);
810
811 ags_synth_util_sawtooth_s16(buffer,
812 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
813 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
814 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
815
816 xcross_count = ags_synth_util_get_xcross_count(buffer,
817 AGS_AUDIO_BUFFER_UTIL_S16,
818 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
819
820 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
821 }
822
823 CU_ASSERT(success == TRUE);
824 //TODO:JK: implement me
825 }
826
827 void
ags_synth_util_test_sawtooth_s24()828 ags_synth_util_test_sawtooth_s24()
829 {
830 gint32 *buffer;
831
832 guint xcross_count;
833 guint i;
834 gboolean success;
835
836 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
837 AGS_SOUNDCARD_SIGNED_24_BIT);
838
839 success = FALSE;
840
841 for(i = 0; test_freq[i] != -1.0; i++){
842 ags_audio_buffer_util_clear_buffer(buffer, 1,
843 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S24);
844
845 ags_synth_util_sawtooth_s24(buffer,
846 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
847 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
848 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
849
850 xcross_count = ags_synth_util_get_xcross_count(buffer,
851 AGS_AUDIO_BUFFER_UTIL_S24,
852 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
853
854 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
855 }
856
857 CU_ASSERT(success == TRUE);
858 }
859
860 void
ags_synth_util_test_sawtooth_s32()861 ags_synth_util_test_sawtooth_s32()
862 {
863 gint32 *buffer;
864
865 guint xcross_count;
866 guint i;
867 gboolean success;
868
869 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
870 AGS_SOUNDCARD_SIGNED_32_BIT);
871
872 success = FALSE;
873
874 for(i = 0; test_freq[i] != -1.0; i++){
875 ags_audio_buffer_util_clear_buffer(buffer, 1,
876 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S32);
877
878 ags_synth_util_sawtooth_s32(buffer,
879 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
880 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
881 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
882
883 xcross_count = ags_synth_util_get_xcross_count(buffer,
884 AGS_AUDIO_BUFFER_UTIL_S32,
885 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
886
887 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
888 }
889
890 CU_ASSERT(success == TRUE);
891 }
892
893 void
ags_synth_util_test_sawtooth_s64()894 ags_synth_util_test_sawtooth_s64()
895 {
896 gint64 *buffer;
897
898 guint xcross_count;
899 guint i;
900 gboolean success;
901
902 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
903 AGS_SOUNDCARD_SIGNED_64_BIT);
904
905 success = FALSE;
906
907 for(i = 0; test_freq[i] != -1.0; i++){
908 ags_audio_buffer_util_clear_buffer(buffer, 1,
909 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S64);
910
911 ags_synth_util_sawtooth_s64(buffer,
912 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
913 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
914 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
915
916 xcross_count = ags_synth_util_get_xcross_count(buffer,
917 AGS_AUDIO_BUFFER_UTIL_S64,
918 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
919
920 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
921 }
922
923 CU_ASSERT(success == TRUE);
924 }
925
926 void
ags_synth_util_test_sawtooth_float()927 ags_synth_util_test_sawtooth_float()
928 {
929 gfloat *buffer;
930
931 guint xcross_count;
932 guint i;
933 gboolean success;
934
935 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
936 AGS_SOUNDCARD_FLOAT);
937
938 success = FALSE;
939
940 for(i = 0; test_freq[i] != -1.0; i++){
941 ags_audio_buffer_util_clear_buffer(buffer, 1,
942 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_FLOAT);
943
944 ags_synth_util_sawtooth_float(buffer,
945 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
946 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
947 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
948
949 xcross_count = ags_synth_util_get_xcross_count(buffer,
950 AGS_AUDIO_BUFFER_UTIL_FLOAT,
951 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
952
953 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
954 }
955
956 CU_ASSERT(success == TRUE);
957 }
958
959 void
ags_synth_util_test_sawtooth_double()960 ags_synth_util_test_sawtooth_double()
961 {
962 gdouble *buffer;
963
964 guint xcross_count;
965 guint i;
966 gboolean success;
967
968 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
969 AGS_SOUNDCARD_DOUBLE);
970
971 success = FALSE;
972
973 for(i = 0; test_freq[i] != -1.0; i++){
974 ags_audio_buffer_util_clear_buffer(buffer, 1,
975 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_DOUBLE);
976
977 ags_synth_util_sawtooth_double(buffer,
978 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
979 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
980 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
981
982 xcross_count = ags_synth_util_get_xcross_count(buffer,
983 AGS_AUDIO_BUFFER_UTIL_DOUBLE,
984 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
985
986 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
987 }
988
989 CU_ASSERT(success == TRUE);
990 }
991
992 void
ags_synth_util_test_sawtooth_complex()993 ags_synth_util_test_sawtooth_complex()
994 {
995 AgsComplex *buffer;
996
997 guint xcross_count;
998 guint i;
999 gboolean success;
1000
1001 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1002 AGS_SOUNDCARD_COMPLEX);
1003
1004 success = FALSE;
1005
1006 for(i = 0; test_freq[i] != -1.0; i++){
1007 ags_audio_buffer_util_clear_buffer(buffer, 1,
1008 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_COMPLEX);
1009
1010 ags_synth_util_sawtooth_complex(buffer,
1011 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1012 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1013 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1014
1015 xcross_count = ags_synth_util_get_xcross_count(buffer,
1016 AGS_AUDIO_BUFFER_UTIL_COMPLEX,
1017 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1018
1019 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1020 }
1021
1022 CU_ASSERT(success == TRUE);
1023 }
1024
1025 void
ags_synth_util_test_compute_triangle_s8()1026 ags_synth_util_test_compute_triangle_s8()
1027 {
1028 //TODO:JK: implement me
1029 }
1030
1031 void
ags_synth_util_test_compute_triangle_s16()1032 ags_synth_util_test_compute_triangle_s16()
1033 {
1034 //TODO:JK: implement me
1035 }
1036
1037 void
ags_synth_util_test_compute_triangle_s24()1038 ags_synth_util_test_compute_triangle_s24()
1039 {
1040 //TODO:JK: implement me
1041 }
1042
1043 void
ags_synth_util_test_compute_triangle_s32()1044 ags_synth_util_test_compute_triangle_s32()
1045 {
1046 //TODO:JK: implement me
1047 }
1048
1049 void
ags_synth_util_test_compute_triangle_s64()1050 ags_synth_util_test_compute_triangle_s64()
1051 {
1052 //TODO:JK: implement me
1053 }
1054
1055 void
ags_synth_util_test_compute_triangle_float()1056 ags_synth_util_test_compute_triangle_float()
1057 {
1058 //TODO:JK: implement me
1059 }
1060
1061 void
ags_synth_util_test_compute_triangle_double()1062 ags_synth_util_test_compute_triangle_double()
1063 {
1064 //TODO:JK: implement me
1065 }
1066
1067 void
ags_synth_util_test_compute_triangle_complex()1068 ags_synth_util_test_compute_triangle_complex()
1069 {
1070 //TODO:JK: implement me
1071 }
1072
1073
1074 void
ags_synth_util_test_triangle_s8()1075 ags_synth_util_test_triangle_s8()
1076 {
1077 gint8 *buffer;
1078
1079 guint xcross_count;
1080 guint i;
1081 gboolean success;
1082
1083 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1084 AGS_SOUNDCARD_SIGNED_8_BIT);
1085
1086 success = FALSE;
1087
1088 for(i = 0; test_freq[i] != -1.0; i++){
1089 ags_audio_buffer_util_clear_buffer(buffer, 1,
1090 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S8);
1091
1092 ags_synth_util_triangle_s8(buffer,
1093 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1094 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1095 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1096
1097 xcross_count = ags_synth_util_get_xcross_count(buffer,
1098 AGS_AUDIO_BUFFER_UTIL_S8,
1099 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1100
1101 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1102 }
1103
1104 CU_ASSERT(success == TRUE);
1105 }
1106
1107 void
ags_synth_util_test_triangle_s16()1108 ags_synth_util_test_triangle_s16()
1109 {
1110 gint16 *buffer;
1111
1112 guint xcross_count;
1113 guint i;
1114 gboolean success;
1115
1116 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1117 AGS_SOUNDCARD_SIGNED_16_BIT);
1118
1119 success = FALSE;
1120
1121 for(i = 0; test_freq[i] != -1.0; i++){
1122 ags_audio_buffer_util_clear_buffer(buffer, 1,
1123 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S16);
1124
1125 ags_synth_util_triangle_s16(buffer,
1126 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1127 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1128 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1129
1130 xcross_count = ags_synth_util_get_xcross_count(buffer,
1131 AGS_AUDIO_BUFFER_UTIL_S16,
1132 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1133
1134 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1135 }
1136
1137 CU_ASSERT(success == TRUE);
1138 }
1139
1140 void
ags_synth_util_test_triangle_s24()1141 ags_synth_util_test_triangle_s24()
1142 {
1143 gint32 *buffer;
1144
1145 guint xcross_count;
1146 guint i;
1147 gboolean success;
1148
1149 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1150 AGS_SOUNDCARD_SIGNED_24_BIT);
1151
1152 success = FALSE;
1153
1154 for(i = 0; test_freq[i] != -1.0; i++){
1155 ags_audio_buffer_util_clear_buffer(buffer, 1,
1156 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S24);
1157
1158 ags_synth_util_triangle_s24(buffer,
1159 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1160 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1161 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1162
1163 xcross_count = ags_synth_util_get_xcross_count(buffer,
1164 AGS_AUDIO_BUFFER_UTIL_S24,
1165 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1166
1167 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1168 }
1169
1170 CU_ASSERT(success == TRUE);
1171 }
1172
1173 void
ags_synth_util_test_triangle_s32()1174 ags_synth_util_test_triangle_s32()
1175 {
1176 gint32 *buffer;
1177
1178 guint xcross_count;
1179 guint i;
1180 gboolean success;
1181
1182 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1183 AGS_SOUNDCARD_SIGNED_32_BIT);
1184
1185 success = FALSE;
1186
1187 for(i = 0; test_freq[i] != -1.0; i++){
1188 ags_audio_buffer_util_clear_buffer(buffer, 1,
1189 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S32);
1190
1191 ags_synth_util_triangle_s32(buffer,
1192 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1193 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1194 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1195
1196 xcross_count = ags_synth_util_get_xcross_count(buffer,
1197 AGS_AUDIO_BUFFER_UTIL_S32,
1198 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1199
1200 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1201 }
1202
1203 CU_ASSERT(success == TRUE);
1204 }
1205
1206 void
ags_synth_util_test_triangle_s64()1207 ags_synth_util_test_triangle_s64()
1208 {
1209 gint64 *buffer;
1210
1211 guint xcross_count;
1212 guint i;
1213 gboolean success;
1214
1215 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1216 AGS_SOUNDCARD_SIGNED_64_BIT);
1217
1218 success = FALSE;
1219
1220 for(i = 0; test_freq[i] != -1.0; i++){
1221 ags_audio_buffer_util_clear_buffer(buffer, 1,
1222 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S64);
1223
1224 ags_synth_util_triangle_s64(buffer,
1225 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1226 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1227 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1228
1229 xcross_count = ags_synth_util_get_xcross_count(buffer,
1230 AGS_AUDIO_BUFFER_UTIL_S64,
1231 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1232
1233 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1234 }
1235
1236 CU_ASSERT(success == TRUE);
1237 }
1238
1239 void
ags_synth_util_test_triangle_float()1240 ags_synth_util_test_triangle_float()
1241 {
1242 gfloat *buffer;
1243
1244 guint xcross_count;
1245 guint i;
1246 gboolean success;
1247
1248 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1249 AGS_SOUNDCARD_FLOAT);
1250
1251 success = FALSE;
1252
1253 for(i = 0; test_freq[i] != -1.0; i++){
1254 ags_audio_buffer_util_clear_buffer(buffer, 1,
1255 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_FLOAT);
1256
1257 ags_synth_util_triangle_float(buffer,
1258 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1259 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1260 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1261
1262 xcross_count = ags_synth_util_get_xcross_count(buffer,
1263 AGS_AUDIO_BUFFER_UTIL_FLOAT,
1264 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1265
1266 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1267 }
1268
1269 CU_ASSERT(success == TRUE);
1270 }
1271
1272 void
ags_synth_util_test_triangle_double()1273 ags_synth_util_test_triangle_double()
1274 {
1275 gdouble *buffer;
1276
1277 guint xcross_count;
1278 guint i;
1279 gboolean success;
1280
1281 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1282 AGS_SOUNDCARD_DOUBLE);
1283
1284 success = FALSE;
1285
1286 for(i = 0; test_freq[i] != -1.0; i++){
1287 ags_audio_buffer_util_clear_buffer(buffer, 1,
1288 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_DOUBLE);
1289
1290 ags_synth_util_triangle_double(buffer,
1291 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1292 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1293 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1294
1295 xcross_count = ags_synth_util_get_xcross_count(buffer,
1296 AGS_AUDIO_BUFFER_UTIL_DOUBLE,
1297 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1298
1299 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1300 }
1301
1302 CU_ASSERT(success == TRUE);
1303 }
1304
1305 void
ags_synth_util_test_triangle_complex()1306 ags_synth_util_test_triangle_complex()
1307 {
1308 AgsComplex *buffer;
1309
1310 guint xcross_count;
1311 guint i;
1312 gboolean success;
1313
1314 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1315 AGS_SOUNDCARD_COMPLEX);
1316
1317 success = FALSE;
1318
1319 for(i = 0; test_freq[i] != -1.0; i++){
1320 ags_audio_buffer_util_clear_buffer(buffer, 1,
1321 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_COMPLEX);
1322
1323 ags_synth_util_triangle_complex(buffer,
1324 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1325 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1326 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1327
1328 xcross_count = ags_synth_util_get_xcross_count(buffer,
1329 AGS_AUDIO_BUFFER_UTIL_COMPLEX,
1330 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1331
1332 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1333 }
1334
1335 CU_ASSERT(success == TRUE);
1336 }
1337
1338 void
ags_synth_util_test_compute_square_s8()1339 ags_synth_util_test_compute_square_s8()
1340 {
1341 //TODO:JK: implement me
1342 }
1343
1344 void
ags_synth_util_test_compute_square_s16()1345 ags_synth_util_test_compute_square_s16()
1346 {
1347 //TODO:JK: implement me
1348 }
1349
1350 void
ags_synth_util_test_compute_square_s24()1351 ags_synth_util_test_compute_square_s24()
1352 {
1353 //TODO:JK: implement me
1354 }
1355
1356 void
ags_synth_util_test_compute_square_s32()1357 ags_synth_util_test_compute_square_s32()
1358 {
1359 //TODO:JK: implement me
1360 }
1361
1362 void
ags_synth_util_test_compute_square_s64()1363 ags_synth_util_test_compute_square_s64()
1364 {
1365 //TODO:JK: implement me
1366 }
1367
1368 void
ags_synth_util_test_compute_square_float()1369 ags_synth_util_test_compute_square_float()
1370 {
1371 //TODO:JK: implement me
1372 }
1373
1374 void
ags_synth_util_test_compute_square_double()1375 ags_synth_util_test_compute_square_double()
1376 {
1377 //TODO:JK: implement me
1378 }
1379
1380 void
ags_synth_util_test_compute_square_complex()1381 ags_synth_util_test_compute_square_complex()
1382 {
1383 //TODO:JK: implement me
1384 }
1385
1386
1387 void
ags_synth_util_test_square_s8()1388 ags_synth_util_test_square_s8()
1389 {
1390 gint8 *buffer;
1391
1392 guint xcross_count;
1393 guint i;
1394 gboolean success;
1395
1396 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1397 AGS_SOUNDCARD_SIGNED_8_BIT);
1398
1399 success = FALSE;
1400
1401 for(i = 0; test_freq[i] != -1.0; i++){
1402 ags_audio_buffer_util_clear_buffer(buffer, 1,
1403 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S8);
1404
1405 ags_synth_util_square_s8(buffer,
1406 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1407 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1408 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1409
1410 xcross_count = ags_synth_util_get_xcross_count(buffer,
1411 AGS_AUDIO_BUFFER_UTIL_S8,
1412 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1413
1414 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1415 }
1416
1417 CU_ASSERT(success == TRUE);
1418 }
1419
1420 void
ags_synth_util_test_square_s16()1421 ags_synth_util_test_square_s16()
1422 {
1423 gint16 *buffer;
1424
1425 guint xcross_count;
1426 guint i;
1427 gboolean success;
1428
1429 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1430 AGS_SOUNDCARD_SIGNED_16_BIT);
1431
1432 success = FALSE;
1433
1434 for(i = 0; test_freq[i] != -1.0; i++){
1435 ags_audio_buffer_util_clear_buffer(buffer, 1,
1436 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S16);
1437
1438 ags_synth_util_square_s16(buffer,
1439 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1440 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1441 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1442
1443 xcross_count = ags_synth_util_get_xcross_count(buffer,
1444 AGS_AUDIO_BUFFER_UTIL_S16,
1445 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1446
1447 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1448 }
1449
1450 CU_ASSERT(success == TRUE);
1451 }
1452
1453 void
ags_synth_util_test_square_s24()1454 ags_synth_util_test_square_s24()
1455 {
1456 gint32 *buffer;
1457
1458 guint xcross_count;
1459 guint i;
1460 gboolean success;
1461
1462 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1463 AGS_SOUNDCARD_SIGNED_24_BIT);
1464
1465 success = FALSE;
1466
1467 for(i = 0; test_freq[i] != -1.0; i++){
1468 ags_audio_buffer_util_clear_buffer(buffer, 1,
1469 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S24);
1470
1471 ags_synth_util_square_s24(buffer,
1472 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1473 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1474 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1475
1476 xcross_count = ags_synth_util_get_xcross_count(buffer,
1477 AGS_AUDIO_BUFFER_UTIL_S24,
1478 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1479
1480 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1481 }
1482
1483 CU_ASSERT(success == TRUE);
1484 }
1485
1486 void
ags_synth_util_test_square_s32()1487 ags_synth_util_test_square_s32()
1488 {
1489 gint32 *buffer;
1490
1491 guint xcross_count;
1492 guint i;
1493 gboolean success;
1494
1495 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1496 AGS_SOUNDCARD_SIGNED_32_BIT);
1497
1498 success = FALSE;
1499
1500 for(i = 0; test_freq[i] != -1.0; i++){
1501 ags_audio_buffer_util_clear_buffer(buffer, 1,
1502 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S32);
1503
1504 ags_synth_util_square_s32(buffer,
1505 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1506 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1507 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1508
1509 xcross_count = ags_synth_util_get_xcross_count(buffer,
1510 AGS_AUDIO_BUFFER_UTIL_S32,
1511 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1512
1513 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1514 }
1515
1516 CU_ASSERT(success == TRUE);
1517 }
1518
1519 void
ags_synth_util_test_square_s64()1520 ags_synth_util_test_square_s64()
1521 {
1522 gint64 *buffer;
1523
1524 guint xcross_count;
1525 guint i;
1526 gboolean success;
1527
1528 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1529 AGS_SOUNDCARD_SIGNED_64_BIT);
1530
1531 success = FALSE;
1532
1533 for(i = 0; test_freq[i] != -1.0; i++){
1534 ags_audio_buffer_util_clear_buffer(buffer, 1,
1535 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S64);
1536
1537 ags_synth_util_square_s64(buffer,
1538 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1539 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1540 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1541
1542 xcross_count = ags_synth_util_get_xcross_count(buffer,
1543 AGS_AUDIO_BUFFER_UTIL_S64,
1544 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1545
1546 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1547 }
1548
1549 CU_ASSERT(success == TRUE);
1550 }
1551
1552 void
ags_synth_util_test_square_float()1553 ags_synth_util_test_square_float()
1554 {
1555 gfloat *buffer;
1556
1557 guint xcross_count;
1558 guint i;
1559 gboolean success;
1560
1561 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1562 AGS_SOUNDCARD_FLOAT);
1563
1564 success = FALSE;
1565
1566 for(i = 0; test_freq[i] != -1.0; i++){
1567 ags_audio_buffer_util_clear_buffer(buffer, 1,
1568 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_FLOAT);
1569
1570 ags_synth_util_square_float(buffer,
1571 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1572 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1573 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1574
1575 xcross_count = ags_synth_util_get_xcross_count(buffer,
1576 AGS_AUDIO_BUFFER_UTIL_FLOAT,
1577 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1578
1579 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1580 }
1581
1582 CU_ASSERT(success == TRUE);
1583 }
1584
1585 void
ags_synth_util_test_square_double()1586 ags_synth_util_test_square_double()
1587 {
1588 gdouble *buffer;
1589
1590 guint xcross_count;
1591 guint i;
1592 gboolean success;
1593
1594 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1595 AGS_SOUNDCARD_DOUBLE);
1596
1597 success = FALSE;
1598
1599 for(i = 0; test_freq[i] != -1.0; i++){
1600 ags_audio_buffer_util_clear_buffer(buffer, 1,
1601 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_DOUBLE);
1602
1603 ags_synth_util_square_double(buffer,
1604 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1605 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1606 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1607
1608 xcross_count = ags_synth_util_get_xcross_count(buffer,
1609 AGS_AUDIO_BUFFER_UTIL_DOUBLE,
1610 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1611
1612 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1613 }
1614
1615 CU_ASSERT(success == TRUE);
1616 }
1617
1618 void
ags_synth_util_test_square_complex()1619 ags_synth_util_test_square_complex()
1620 {
1621 AgsComplex *buffer;
1622
1623 guint xcross_count;
1624 guint i;
1625 gboolean success;
1626
1627 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1628 AGS_SOUNDCARD_COMPLEX);
1629
1630 success = FALSE;
1631
1632 for(i = 0; test_freq[i] != -1.0; i++){
1633 ags_audio_buffer_util_clear_buffer(buffer, 1,
1634 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_COMPLEX);
1635
1636 ags_synth_util_square_complex(buffer,
1637 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1638 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1639 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1640
1641 xcross_count = ags_synth_util_get_xcross_count(buffer,
1642 AGS_AUDIO_BUFFER_UTIL_COMPLEX,
1643 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1644
1645 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1646 }
1647
1648 CU_ASSERT(success == TRUE);
1649 }
1650
1651 void
ags_synth_util_test_compute_impulse_s8()1652 ags_synth_util_test_compute_impulse_s8()
1653 {
1654 //TODO:JK: implement me
1655 }
1656
1657 void
ags_synth_util_test_compute_impulse_s16()1658 ags_synth_util_test_compute_impulse_s16()
1659 {
1660 //TODO:JK: implement me
1661 }
1662
1663 void
ags_synth_util_test_compute_impulse_s24()1664 ags_synth_util_test_compute_impulse_s24()
1665 {
1666 //TODO:JK: implement me
1667 }
1668
1669 void
ags_synth_util_test_compute_impulse_s32()1670 ags_synth_util_test_compute_impulse_s32()
1671 {
1672 //TODO:JK: implement me
1673 }
1674
1675 void
ags_synth_util_test_compute_impulse_s64()1676 ags_synth_util_test_compute_impulse_s64()
1677 {
1678 //TODO:JK: implement me
1679 }
1680
1681 void
ags_synth_util_test_compute_impulse_float()1682 ags_synth_util_test_compute_impulse_float()
1683 {
1684 //TODO:JK: implement me
1685 }
1686
1687 void
ags_synth_util_test_compute_impulse_double()1688 ags_synth_util_test_compute_impulse_double()
1689 {
1690 //TODO:JK: implement me
1691 }
1692
1693 void
ags_synth_util_test_compute_impulse_complex()1694 ags_synth_util_test_compute_impulse_complex()
1695 {
1696 //TODO:JK: implement me
1697 }
1698
1699
1700 void
ags_synth_util_test_impulse_s8()1701 ags_synth_util_test_impulse_s8()
1702 {
1703 gint8 *buffer;
1704
1705 guint xcross_count;
1706 guint i;
1707 gboolean success;
1708
1709 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1710 AGS_SOUNDCARD_SIGNED_8_BIT);
1711
1712 success = FALSE;
1713
1714 for(i = 0; test_freq[i] != -1.0; i++){
1715 ags_audio_buffer_util_clear_buffer(buffer, 1,
1716 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S8);
1717
1718 ags_synth_util_impulse_s8(buffer,
1719 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1720 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1721 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1722
1723 xcross_count = ags_synth_util_get_xcross_count(buffer,
1724 AGS_AUDIO_BUFFER_UTIL_S8,
1725 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1726
1727 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1728 }
1729
1730 CU_ASSERT(success == TRUE);
1731 }
1732
1733 void
ags_synth_util_test_impulse_s16()1734 ags_synth_util_test_impulse_s16()
1735 {
1736 gint16 *buffer;
1737
1738 guint xcross_count;
1739 guint i;
1740 gboolean success;
1741
1742 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1743 AGS_SOUNDCARD_SIGNED_16_BIT);
1744
1745 success = FALSE;
1746
1747 for(i = 0; test_freq[i] != -1.0; i++){
1748 ags_audio_buffer_util_clear_buffer(buffer, 1,
1749 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S16);
1750
1751 ags_synth_util_impulse_s16(buffer,
1752 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1753 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1754 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1755
1756 xcross_count = ags_synth_util_get_xcross_count(buffer,
1757 AGS_AUDIO_BUFFER_UTIL_S16,
1758 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1759
1760 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1761 }
1762
1763 CU_ASSERT(success == TRUE);
1764 }
1765
1766 void
ags_synth_util_test_impulse_s24()1767 ags_synth_util_test_impulse_s24()
1768 {
1769 gint32 *buffer;
1770
1771 guint xcross_count;
1772 guint i;
1773 gboolean success;
1774
1775 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1776 AGS_SOUNDCARD_SIGNED_24_BIT);
1777
1778 success = FALSE;
1779
1780 for(i = 0; test_freq[i] != -1.0; i++){
1781 ags_audio_buffer_util_clear_buffer(buffer, 1,
1782 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S24);
1783
1784 ags_synth_util_impulse_s24(buffer,
1785 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1786 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1787 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1788
1789 xcross_count = ags_synth_util_get_xcross_count(buffer,
1790 AGS_AUDIO_BUFFER_UTIL_S24,
1791 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1792
1793 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1794 }
1795
1796 CU_ASSERT(success == TRUE);
1797 }
1798
1799 void
ags_synth_util_test_impulse_s32()1800 ags_synth_util_test_impulse_s32()
1801 {
1802 gint32 *buffer;
1803
1804 guint xcross_count;
1805 guint i;
1806 gboolean success;
1807
1808 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1809 AGS_SOUNDCARD_SIGNED_32_BIT);
1810
1811 success = FALSE;
1812
1813 for(i = 0; test_freq[i] != -1.0; i++){
1814 ags_audio_buffer_util_clear_buffer(buffer, 1,
1815 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S32);
1816
1817 ags_synth_util_impulse_s32(buffer,
1818 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1819 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1820 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1821
1822 xcross_count = ags_synth_util_get_xcross_count(buffer,
1823 AGS_AUDIO_BUFFER_UTIL_S32,
1824 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1825
1826 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1827 }
1828
1829 CU_ASSERT(success == TRUE);
1830 }
1831
1832 void
ags_synth_util_test_impulse_s64()1833 ags_synth_util_test_impulse_s64()
1834 {
1835 gint64 *buffer;
1836
1837 guint xcross_count;
1838 guint i;
1839 gboolean success;
1840
1841 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1842 AGS_SOUNDCARD_SIGNED_64_BIT);
1843
1844 success = FALSE;
1845
1846 for(i = 0; test_freq[i] != -1.0; i++){
1847 ags_audio_buffer_util_clear_buffer(buffer, 1,
1848 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_S64);
1849
1850 ags_synth_util_impulse_s64(buffer,
1851 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1852 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1853 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1854
1855 xcross_count = ags_synth_util_get_xcross_count(buffer,
1856 AGS_AUDIO_BUFFER_UTIL_S64,
1857 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1858
1859 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1860 }
1861
1862 CU_ASSERT(success == TRUE);
1863 }
1864
1865 void
ags_synth_util_test_impulse_float()1866 ags_synth_util_test_impulse_float()
1867 {
1868 gfloat *buffer;
1869
1870 guint xcross_count;
1871 guint i;
1872 gboolean success;
1873
1874 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1875 AGS_SOUNDCARD_FLOAT);
1876
1877 success = FALSE;
1878
1879 for(i = 0; test_freq[i] != -1.0; i++){
1880 ags_audio_buffer_util_clear_buffer(buffer, 1,
1881 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_FLOAT);
1882
1883 ags_synth_util_impulse_float(buffer,
1884 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1885 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1886 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1887
1888 xcross_count = ags_synth_util_get_xcross_count(buffer,
1889 AGS_AUDIO_BUFFER_UTIL_FLOAT,
1890 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1891
1892 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1893 }
1894
1895 CU_ASSERT(success == TRUE);
1896 }
1897
1898 void
ags_synth_util_test_impulse_double()1899 ags_synth_util_test_impulse_double()
1900 {
1901 gdouble *buffer;
1902
1903 guint xcross_count;
1904 guint i;
1905 gboolean success;
1906
1907 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1908 AGS_SOUNDCARD_DOUBLE);
1909
1910 success = FALSE;
1911
1912 for(i = 0; test_freq[i] != -1.0; i++){
1913 ags_audio_buffer_util_clear_buffer(buffer, 1,
1914 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_DOUBLE);
1915
1916 ags_synth_util_impulse_double(buffer,
1917 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1918 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1919 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1920
1921 xcross_count = ags_synth_util_get_xcross_count(buffer,
1922 AGS_AUDIO_BUFFER_UTIL_DOUBLE,
1923 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1924
1925 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1926 }
1927
1928 CU_ASSERT(success == TRUE);
1929 }
1930
1931 void
ags_synth_util_test_impulse_complex()1932 ags_synth_util_test_impulse_complex()
1933 {
1934 AgsComplex *buffer;
1935
1936 guint xcross_count;
1937 guint i;
1938 gboolean success;
1939
1940 buffer = ags_stream_alloc(AGS_SYNTH_UTIL_TEST_FRAME_COUNT,
1941 AGS_SOUNDCARD_COMPLEX);
1942
1943 success = FALSE;
1944
1945 for(i = 0; test_freq[i] != -1.0; i++){
1946 ags_audio_buffer_util_clear_buffer(buffer, 1,
1947 AGS_SYNTH_UTIL_TEST_FRAME_COUNT, AGS_AUDIO_BUFFER_UTIL_COMPLEX);
1948
1949 ags_synth_util_impulse_complex(buffer,
1950 test_freq[i], AGS_SYNTH_UTIL_TEST_PHASE, AGS_SYNTH_UTIL_TEST_VOLUME,
1951 AGS_SYNTH_UTIL_TEST_SAMPLERATE,
1952 AGS_SYNTH_UTIL_TEST_OFFSET, AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1953
1954 xcross_count = ags_synth_util_get_xcross_count(buffer,
1955 AGS_AUDIO_BUFFER_UTIL_COMPLEX,
1956 AGS_SYNTH_UTIL_TEST_FRAME_COUNT);
1957
1958 success = (xcross_count + 2 > ((gdouble) AGS_SYNTH_UTIL_TEST_FRAME_COUNT / (gdouble) AGS_SYNTH_UTIL_TEST_SAMPLERATE) * test_freq[i]) ? TRUE: FALSE;
1959 }
1960
1961 CU_ASSERT(success == TRUE);
1962 }
1963
1964 int
main(int argc,char ** argv)1965 main(int argc, char **argv)
1966 {
1967 CU_pSuite pSuite = NULL;
1968
1969 /* initialize the CUnit test registry */
1970 if(CUE_SUCCESS != CU_initialize_registry()){
1971 return CU_get_error();
1972 }
1973
1974 /* add a suite to the registry */
1975 pSuite = CU_add_suite("AgsSynthUtilTest", ags_synth_util_test_init_suite, ags_synth_util_test_clean_suite);
1976
1977 if(pSuite == NULL){
1978 CU_cleanup_registry();
1979
1980 return CU_get_error();
1981 }
1982
1983 /* add the tests to the suite */
1984 if((CU_add_test(pSuite, "test of ags_synth_util.c alloc", ags_synth_util_test_alloc) == NULL) ||
1985 (CU_add_test(pSuite, "test of ags_synth_util.c copy", ags_synth_util_test_copy) == NULL) ||
1986 (CU_add_test(pSuite, "test of ags_synth_util.c free", ags_synth_util_test_free) == NULL) ||
1987 (CU_add_test(pSuite, "test of ags_synth_util.c get source", ags_synth_util_test_get_source) == NULL) ||
1988 (CU_add_test(pSuite, "test of ags_synth_util.c set source", ags_synth_util_test_set_source) == NULL) ||
1989 (CU_add_test(pSuite, "test of ags_synth_util.c get source stride", ags_synth_util_test_get_source_stride) == NULL) ||
1990 (CU_add_test(pSuite, "test of ags_synth_util.c set source stride", ags_synth_util_test_set_source_stride) == NULL) ||
1991 (CU_add_test(pSuite, "test of ags_synth_util.c get buffer length", ags_synth_util_test_get_buffer_length) == NULL) ||
1992 (CU_add_test(pSuite, "test of ags_synth_util.c set buffer length", ags_synth_util_test_set_buffer_length) == NULL) ||
1993 (CU_add_test(pSuite, "test of ags_synth_util.c get audio buffer util format", ags_synth_util_test_get_audio_buffer_util_format) == NULL) ||
1994 (CU_add_test(pSuite, "test of ags_synth_util.c set audio buffer util format", ags_synth_util_test_set_audio_buffer_util_format) == NULL) ||
1995 (CU_add_test(pSuite, "test of ags_synth_util.c get samplerate", ags_synth_util_test_get_samplerate) == NULL) ||
1996 (CU_add_test(pSuite, "test of ags_synth_util.c set samplerate", ags_synth_util_test_set_samplerate) == NULL) ||
1997 (CU_add_test(pSuite, "test of ags_synth_util.c get synth oscillator mode", ags_synth_util_test_get_synth_oscillator_mode) == NULL) ||
1998 (CU_add_test(pSuite, "test of ags_synth_util.c set synth oscillator mode", ags_synth_util_test_set_synth_oscillator_mode) == NULL) ||
1999 (CU_add_test(pSuite, "test of ags_synth_util.c get frequency", ags_synth_util_test_get_frequency) == NULL) ||
2000 (CU_add_test(pSuite, "test of ags_synth_util.c set frequency", ags_synth_util_test_set_frequency) == NULL) ||
2001 (CU_add_test(pSuite, "test of ags_synth_util.c get phase", ags_synth_util_test_get_phase) == NULL) ||
2002 (CU_add_test(pSuite, "test of ags_synth_util.c set phase", ags_synth_util_test_set_phase) == NULL) ||
2003 (CU_add_test(pSuite, "test of ags_synth_util.c get volume", ags_synth_util_test_get_volume) == NULL) ||
2004 (CU_add_test(pSuite, "test of ags_synth_util.c set volume", ags_synth_util_test_set_volume) == NULL) ||
2005 (CU_add_test(pSuite, "test of ags_synth_util.c get frame count", ags_synth_util_test_get_frame_count) == NULL) ||
2006 (CU_add_test(pSuite, "test of ags_synth_util.c set frame count", ags_synth_util_test_set_frame_count) == NULL) ||
2007 (CU_add_test(pSuite, "test of ags_synth_util.c get offset", ags_synth_util_test_get_offset) == NULL) ||
2008 (CU_add_test(pSuite, "test of ags_synth_util.c set offset", ags_synth_util_test_set_offset) == NULL) ||
2009 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin s8", ags_synth_util_test_compute_sin_s8) == NULL) ||
2010 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin s16", ags_synth_util_test_compute_sin_s16) == NULL) ||
2011 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin s24", ags_synth_util_test_compute_sin_s24) == NULL) ||
2012 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin s32", ags_synth_util_test_compute_sin_s32) == NULL) ||
2013 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin s64", ags_synth_util_test_compute_sin_s64) == NULL) ||
2014 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin float", ags_synth_util_test_compute_sin_float) == NULL) ||
2015 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin double", ags_synth_util_test_compute_sin_double) == NULL) ||
2016 (CU_add_test(pSuite, "test of ags_synth_util.c compute sin complex", ags_synth_util_test_compute_sin_complex) == NULL) ||
2017 (CU_add_test(pSuite, "test of ags_synth_util.c sin s8", ags_synth_util_test_sin_s8) == NULL) ||
2018 (CU_add_test(pSuite, "test of ags_synth_util.c sin s16", ags_synth_util_test_sin_s16) == NULL) ||
2019 (CU_add_test(pSuite, "test of ags_synth_util.c sin s24", ags_synth_util_test_sin_s24) == NULL) ||
2020 (CU_add_test(pSuite, "test of ags_synth_util.c sin s32", ags_synth_util_test_sin_s32) == NULL) ||
2021 (CU_add_test(pSuite, "test of ags_synth_util.c sin s64", ags_synth_util_test_sin_s64) == NULL) ||
2022 (CU_add_test(pSuite, "test of ags_synth_util.c sin float", ags_synth_util_test_sin_float) == NULL) ||
2023 (CU_add_test(pSuite, "test of ags_synth_util.c sin double", ags_synth_util_test_sin_double) == NULL) ||
2024 (CU_add_test(pSuite, "test of ags_synth_util.c sin complex", ags_synth_util_test_sin_complex) == NULL) ||
2025 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth s8", ags_synth_util_test_compute_sawtooth_s8) == NULL) ||
2026 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth s16", ags_synth_util_test_compute_sawtooth_s16) == NULL) ||
2027 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth s24", ags_synth_util_test_compute_sawtooth_s24) == NULL) ||
2028 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth s32", ags_synth_util_test_compute_sawtooth_s32) == NULL) ||
2029 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth s64", ags_synth_util_test_compute_sawtooth_s64) == NULL) ||
2030 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth float", ags_synth_util_test_compute_sawtooth_float) == NULL) ||
2031 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth double", ags_synth_util_test_compute_sawtooth_double) == NULL) ||
2032 (CU_add_test(pSuite, "test of ags_synth_util.c compute sawtooth complex", ags_synth_util_test_compute_sawtooth_complex) == NULL) ||
2033 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth s8", ags_synth_util_test_sawtooth_s8) == NULL) ||
2034 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth s16", ags_synth_util_test_sawtooth_s16) == NULL) ||
2035 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth s24", ags_synth_util_test_sawtooth_s24) == NULL) ||
2036 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth s32", ags_synth_util_test_sawtooth_s32) == NULL) ||
2037 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth s64", ags_synth_util_test_sawtooth_s64) == NULL) ||
2038 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth float", ags_synth_util_test_sawtooth_float) == NULL) ||
2039 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth double", ags_synth_util_test_sawtooth_double) == NULL) ||
2040 (CU_add_test(pSuite, "test of ags_synth_util.c sawtooth complex", ags_synth_util_test_sawtooth_complex) == NULL) ||
2041 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle s8", ags_synth_util_test_compute_triangle_s8) == NULL) ||
2042 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle s16", ags_synth_util_test_compute_triangle_s16) == NULL) ||
2043 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle s24", ags_synth_util_test_compute_triangle_s24) == NULL) ||
2044 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle s32", ags_synth_util_test_compute_triangle_s32) == NULL) ||
2045 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle s64", ags_synth_util_test_compute_triangle_s64) == NULL) ||
2046 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle float", ags_synth_util_test_compute_triangle_float) == NULL) ||
2047 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle double", ags_synth_util_test_compute_triangle_double) == NULL) ||
2048 (CU_add_test(pSuite, "test of ags_synth_util.c compute triangle complex", ags_synth_util_test_compute_triangle_complex) == NULL) ||
2049 (CU_add_test(pSuite, "test of ags_synth_util.c triangle s8", ags_synth_util_test_triangle_s8) == NULL) ||
2050 (CU_add_test(pSuite, "test of ags_synth_util.c triangle s16", ags_synth_util_test_triangle_s16) == NULL) ||
2051 (CU_add_test(pSuite, "test of ags_synth_util.c triangle s24", ags_synth_util_test_triangle_s24) == NULL) ||
2052 (CU_add_test(pSuite, "test of ags_synth_util.c triangle s32", ags_synth_util_test_triangle_s32) == NULL) ||
2053 (CU_add_test(pSuite, "test of ags_synth_util.c triangle s64", ags_synth_util_test_triangle_s64) == NULL) ||
2054 (CU_add_test(pSuite, "test of ags_synth_util.c triangle float", ags_synth_util_test_triangle_float) == NULL) ||
2055 (CU_add_test(pSuite, "test of ags_synth_util.c triangle double", ags_synth_util_test_triangle_double) == NULL) ||
2056 (CU_add_test(pSuite, "test of ags_synth_util.c triangle complex", ags_synth_util_test_triangle_complex) == NULL) ||
2057 (CU_add_test(pSuite, "test of ags_synth_util.c compute square s8", ags_synth_util_test_compute_square_s8) == NULL) ||
2058 (CU_add_test(pSuite, "test of ags_synth_util.c compute square s16", ags_synth_util_test_compute_square_s16) == NULL) ||
2059 (CU_add_test(pSuite, "test of ags_synth_util.c compute square s24", ags_synth_util_test_compute_square_s24) == NULL) ||
2060 (CU_add_test(pSuite, "test of ags_synth_util.c compute square s32", ags_synth_util_test_compute_square_s32) == NULL) ||
2061 (CU_add_test(pSuite, "test of ags_synth_util.c compute square s64", ags_synth_util_test_compute_square_s64) == NULL) ||
2062 (CU_add_test(pSuite, "test of ags_synth_util.c compute square float", ags_synth_util_test_compute_square_float) == NULL) ||
2063 (CU_add_test(pSuite, "test of ags_synth_util.c compute square double", ags_synth_util_test_compute_square_double) == NULL) ||
2064 (CU_add_test(pSuite, "test of ags_synth_util.c compute square complex", ags_synth_util_test_compute_square_complex) == NULL) ||
2065 (CU_add_test(pSuite, "test of ags_synth_util.c square s8", ags_synth_util_test_square_s8) == NULL) ||
2066 (CU_add_test(pSuite, "test of ags_synth_util.c square s16", ags_synth_util_test_square_s16) == NULL) ||
2067 (CU_add_test(pSuite, "test of ags_synth_util.c square s24", ags_synth_util_test_square_s24) == NULL) ||
2068 (CU_add_test(pSuite, "test of ags_synth_util.c square s32", ags_synth_util_test_square_s32) == NULL) ||
2069 (CU_add_test(pSuite, "test of ags_synth_util.c square s64", ags_synth_util_test_square_s64) == NULL) ||
2070 (CU_add_test(pSuite, "test of ags_synth_util.c square float", ags_synth_util_test_square_float) == NULL) ||
2071 (CU_add_test(pSuite, "test of ags_synth_util.c square double", ags_synth_util_test_square_double) == NULL) ||
2072 (CU_add_test(pSuite, "test of ags_synth_util.c square complex", ags_synth_util_test_square_complex) == NULL) ||
2073 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse s16", ags_synth_util_test_compute_impulse_s16) == NULL) ||
2074 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse s24", ags_synth_util_test_compute_impulse_s24) == NULL) ||
2075 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse s32", ags_synth_util_test_compute_impulse_s32) == NULL) ||
2076 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse s64", ags_synth_util_test_compute_impulse_s64) == NULL) ||
2077 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse float", ags_synth_util_test_compute_impulse_float) == NULL) ||
2078 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse double", ags_synth_util_test_compute_impulse_double) == NULL) ||
2079 (CU_add_test(pSuite, "test of ags_synth_util.c compute impulse complex", ags_synth_util_test_compute_impulse_complex) == NULL) ||
2080 (CU_add_test(pSuite, "test of ags_synth_util.c impulse s16", ags_synth_util_test_impulse_s16) == NULL) ||
2081 (CU_add_test(pSuite, "test of ags_synth_util.c impulse s24", ags_synth_util_test_impulse_s24) == NULL) ||
2082 (CU_add_test(pSuite, "test of ags_synth_util.c impulse s32", ags_synth_util_test_impulse_s32) == NULL) ||
2083 (CU_add_test(pSuite, "test of ags_synth_util.c impulse s64", ags_synth_util_test_impulse_s64) == NULL) ||
2084 (CU_add_test(pSuite, "test of ags_synth_util.c impulse float", ags_synth_util_test_impulse_float) == NULL) ||
2085 (CU_add_test(pSuite, "test of ags_synth_util.c impulse double", ags_synth_util_test_impulse_double) == NULL) ||
2086 (CU_add_test(pSuite, "test of ags_synth_util.c impulse complex", ags_synth_util_test_impulse_complex) == NULL)){
2087 CU_cleanup_registry();
2088
2089 return CU_get_error();
2090 }
2091
2092 /* Run all tests using the CUnit Basic interface */
2093 CU_basic_set_mode(CU_BRM_VERBOSE);
2094 CU_basic_run_tests();
2095
2096 CU_cleanup_registry();
2097
2098 return(CU_get_error());
2099 }
2100