add notion of topdir to Makefile.lite build system
[flac.git] / src / test_streams / main.c
1 /* test_streams - Simple test pattern generator
2  * Copyright (C) 2000,2001,2002  Josh Coalson
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  */
18
19 #include <math.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #if !defined _MSC_VER && !defined __MINGW32__
23 #include <sys/time.h>
24 #endif
25 #include "FLAC/assert.h"
26 #include "FLAC/ordinals.h"
27
28 #ifndef M_PI
29 /* math.h in VC++ doesn't seem to have this (how Microsoft is that?) */
30 #define M_PI 3.14159265358979323846
31 #endif
32
33 #ifdef _WIN32
34         static const char *mode = "wb";
35 #else
36         static const char *mode = "w";
37 #endif
38
39 static FLAC__bool is_big_endian_host;
40
41 /* some flavors of UNIX #define this */
42 #ifdef swap16
43 #undef swap16
44 #endif
45 static void swap16(FLAC__int16 *i)
46 {
47         unsigned char *x = (unsigned char *)i, b;
48         if(!is_big_endian_host) {
49                 b = x[0];
50                 x[0] = x[1];
51                 x[1] = b;
52         }
53 }
54
55 static void swap24(FLAC__byte *x)
56 {
57         if(is_big_endian_host) {
58                 x[0] = x[1];
59                 x[1] = x[2];
60                 x[2] = x[3];
61         }
62         else {
63                 FLAC__byte b = x[0];
64                 x[0] = x[2];
65                 x[2] = b;
66         }
67 }
68
69 /* a mono one-sample 16bps stream */
70 static FLAC__bool generate_01()
71 {
72         FILE *f;
73         FLAC__int16 x = -32768;
74
75         if(0 == (f = fopen("test01.raw", mode)))
76                 return false;
77
78         swap16(&x);
79         if(fwrite(&x, sizeof(x), 1, f) < 1)
80                 goto foo;
81
82         fclose(f);
83         return true;
84 foo:
85         fclose(f);
86         return false;
87 }
88
89 /* a stereo one-sample 16bps stream */
90 static FLAC__bool generate_02()
91 {
92         FILE *f;
93         FLAC__int16 xl = -32768, xr = 32767;
94
95         if(0 == (f = fopen("test02.raw", mode)))
96                 return false;
97
98         swap16(&xl);
99         swap16(&xr);
100
101         if(fwrite(&xl, sizeof(xl), 1, f) < 1)
102                 goto foo;
103         if(fwrite(&xr, sizeof(xr), 1, f) < 1)
104                 goto foo;
105
106         fclose(f);
107         return true;
108 foo:
109         fclose(f);
110         return false;
111 }
112
113 /* a mono five-sample 16bps stream */
114 static FLAC__bool generate_03()
115 {
116         FILE *f;
117         FLAC__int16 x[] = { -25, 0, 25, 50, 100 };
118         unsigned i;
119
120         if(0 == (f = fopen("test03.raw", mode)))
121                 return false;
122
123         for(i = 0; i < 5; i++)
124                 swap16(x+i);
125
126         if(fwrite(&x, sizeof(FLAC__int16), 5, f) < 5)
127                 goto foo;
128
129         fclose(f);
130         return true;
131 foo:
132         fclose(f);
133         return false;
134 }
135
136 /* a stereo five-sample 16bps stream */
137 static FLAC__bool generate_04()
138 {
139         FILE *f;
140         FLAC__int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
141         unsigned i;
142
143         if(0 == (f = fopen("test04.raw", mode)))
144                 return false;
145
146         for(i = 0; i < 10; i++)
147                 swap16(x+i);
148
149         if(fwrite(&x, sizeof(FLAC__int16), 10, f) < 10)
150                 goto foo;
151
152         fclose(f);
153         return true;
154 foo:
155         fclose(f);
156         return false;
157 }
158
159 /* a mono full-scale deflection 8bps stream */
160 static FLAC__bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
161 {
162         FILE *f;
163         unsigned rep, p;
164
165         FLAC__ASSERT(pattern != 0);
166
167         if(0 == (f = fopen(fn, mode)))
168                 return false;
169
170         for(rep = 0; rep < reps; rep++) {
171                 for(p = 0; pattern[p]; p++) {
172                         signed char x = pattern[p] > 0? 127 : -128;
173                         if(fwrite(&x, sizeof(x), 1, f) < 1)
174                                 goto foo;
175                 }
176         }
177
178         fclose(f);
179         return true;
180 foo:
181         fclose(f);
182         return false;
183 }
184
185 /* a mono full-scale deflection 16bps stream */
186 static FLAC__bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
187 {
188         FILE *f;
189         unsigned rep, p;
190
191         FLAC__ASSERT(pattern != 0);
192
193         if(0 == (f = fopen(fn, mode)))
194                 return false;
195
196         for(rep = 0; rep < reps; rep++) {
197                 for(p = 0; pattern[p]; p++) {
198                         FLAC__int16 x = pattern[p] > 0? 32767 : -32768;
199                         swap16(&x);
200                         if(fwrite(&x, sizeof(x), 1, f) < 1)
201                                 goto foo;
202                 }
203         }
204
205         fclose(f);
206         return true;
207 foo:
208         fclose(f);
209         return false;
210 }
211
212 /* a stereo wasted-bits-per-sample 16bps stream */
213 static FLAC__bool generate_wbps16(const char *fn, unsigned samples)
214 {
215         FILE *f;
216         unsigned sample;
217
218         if(0 == (f = fopen(fn, mode)))
219                 return false;
220
221         for(sample = 0; sample < samples; sample++) {
222                 FLAC__int16 l = (sample % 2000) << 2;
223                 FLAC__int16 r = (sample % 1000) << 3;
224                 swap16(&l);
225                 swap16(&r);
226                 if(fwrite(&l, sizeof(l), 1, f) < 1)
227                         goto foo;
228                 if(fwrite(&r, sizeof(r), 1, f) < 1)
229                         goto foo;
230         }
231
232         fclose(f);
233         return true;
234 foo:
235         fclose(f);
236         return false;
237 }
238
239 /* a mono full-scale deflection 24bps stream */
240 static FLAC__bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
241 {
242         FILE *f;
243         unsigned rep, p;
244
245         FLAC__ASSERT(pattern != 0);
246
247         if(0 == (f = fopen(fn, mode)))
248                 return false;
249
250         for(rep = 0; rep < reps; rep++) {
251                 for(p = 0; pattern[p]; p++) {
252                         FLAC__int32 x = pattern[p] > 0? 8388607 : -8388608;
253                         FLAC__byte *b = (FLAC__byte*)(&x);
254                         swap24(b);
255                         if(fwrite(b, 3, 1, f) < 1)
256                                 goto foo;
257                 }
258         }
259
260         fclose(f);
261         return true;
262 foo:
263         fclose(f);
264         return false;
265 }
266
267 /* a mono sine-wave 8bps stream */
268 static FLAC__bool generate_sine8_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
269 {
270         const FLAC__int8 full_scale = 127;
271         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
272         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
273         FILE *f;
274         double theta1, theta2;
275         unsigned i;
276
277         if(0 == (f = fopen(fn, mode)))
278                 return false;
279
280         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
281                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
282                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
283                 if(fwrite(&v, sizeof(v), 1, f) < 1)
284                         goto foo;
285         }
286
287         fclose(f);
288         return true;
289 foo:
290         fclose(f);
291         return false;
292 }
293
294 /* a stereo sine-wave 8bps stream */
295 static FLAC__bool generate_sine8_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
296 {
297         const FLAC__int8 full_scale = 127;
298         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
299         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
300         FILE *f;
301         double theta1, theta2;
302         unsigned i;
303
304         if(0 == (f = fopen(fn, mode)))
305                 return false;
306
307         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
308                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
309                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
310                 if(fwrite(&v, sizeof(v), 1, f) < 1)
311                         goto foo;
312                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
313                 v = (FLAC__int8)(val + 0.5);
314                 if(fwrite(&v, sizeof(v), 1, f) < 1)
315                         goto foo;
316         }
317
318         fclose(f);
319         return true;
320 foo:
321         fclose(f);
322         return false;
323 }
324
325 /* a mono sine-wave 16bps stream */
326 static FLAC__bool generate_sine16_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
327 {
328         const FLAC__int16 full_scale = 32767;
329         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
330         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
331         FILE *f;
332         double theta1, theta2;
333         unsigned i;
334
335         if(0 == (f = fopen(fn, mode)))
336                 return false;
337
338         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
339                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
340                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
341                 swap16(&v);
342                 if(fwrite(&v, sizeof(v), 1, f) < 1)
343                         goto foo;
344         }
345
346         fclose(f);
347         return true;
348 foo:
349         fclose(f);
350         return false;
351 }
352
353 /* a stereo sine-wave 16bps stream */
354 static FLAC__bool generate_sine16_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
355 {
356         const FLAC__int16 full_scale = 32767;
357         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
358         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
359         FILE *f;
360         double theta1, theta2;
361         unsigned i;
362
363         if(0 == (f = fopen(fn, mode)))
364                 return false;
365
366         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
367                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
368                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
369                 swap16(&v);
370                 if(fwrite(&v, sizeof(v), 1, f) < 1)
371                         goto foo;
372                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
373                 v = (FLAC__int16)(val + 0.5);
374                 swap16(&v);
375                 if(fwrite(&v, sizeof(v), 1, f) < 1)
376                         goto foo;
377         }
378
379         fclose(f);
380         return true;
381 foo:
382         fclose(f);
383         return false;
384 }
385
386 /* a mono sine-wave 24bps stream */
387 static FLAC__bool generate_sine24_1(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2)
388 {
389         const FLAC__int32 full_scale = 0x7fffff;
390         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
391         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
392         FILE *f;
393         double theta1, theta2;
394         unsigned i;
395
396         if(0 == (f = fopen(fn, mode)))
397                 return false;
398
399         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
400                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
401                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
402                 FLAC__byte *b = (FLAC__byte*)(&v);
403                 swap24(b);
404                 if(fwrite(b, 3, 1, f) < 1)
405                         goto foo;
406         }
407
408         fclose(f);
409         return true;
410 foo:
411         fclose(f);
412         return false;
413 }
414
415 /* a stereo sine-wave 24bps stream */
416 static FLAC__bool generate_sine24_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult)
417 {
418         const FLAC__int32 full_scale = 0x7fffff;
419         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
420         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
421         FILE *f;
422         double theta1, theta2;
423         unsigned i;
424
425         if(0 == (f = fopen(fn, mode)))
426                 return false;
427
428         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
429                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
430                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
431                 FLAC__byte *b = (FLAC__byte*)(&v);
432                 swap24(b);
433                 if(fwrite(b, 3, 1, f) < 1)
434                         goto foo;
435                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
436                 v = (FLAC__int32)(val + 0.5);
437                 swap24(b);
438                 if(fwrite(b, 3, 1, f) < 1)
439                         goto foo;
440         }
441
442         fclose(f);
443         return true;
444 foo:
445         fclose(f);
446         return false;
447 }
448
449 static FLAC__bool generate_noise(const char *fn, unsigned bytes)
450 {
451         FILE *f;
452         unsigned b;
453 #if !defined _MSC_VER && !defined __MINGW32__
454         struct timeval tv;
455
456         if(gettimeofday(&tv, 0) < 0) {
457                 fprintf(stderr, "WARNING: couldn't seed RNG with time\n");
458                 tv.tv_usec = 4321;
459         }
460         srandom(tv.tv_usec);
461 #else
462         /* who has the patience to figure out how to do RNG with VC++? */
463 #endif
464
465         if(0 == (f = fopen(fn, mode)))
466                 return false;
467
468         for(b = 0; b < bytes; b++) {
469 #if !defined _MSC_VER && !defined __MINGW32__
470                 FLAC__byte x = (FLAC__byte)(((unsigned)random()) & 0xff);
471 #else
472                 FLAC__byte x = (FLAC__byte)((((unsigned)generate_noise) >> 8) ^ (b * 17)); /* fake it */
473 #endif
474                 if(fwrite(&x, sizeof(x), 1, f) < 1)
475                         goto foo;
476         }
477
478         fclose(f);
479         return true;
480 foo:
481         fclose(f);
482         return false;
483 }
484
485 static FLAC__bool generate_wackywavs()
486 {
487         FILE *f;
488         FLAC__byte wav[] = {
489                 'R', 'I', 'F', 'F',  76,   0,   0,   0,
490                 'W', 'A', 'V', 'E', 'f', 'a', 'c', 't',
491                   4,   0,   0,  0 , 'b', 'l', 'a', 'h',
492                 'p', 'a', 'd', ' ',   4,   0,   0,   0,
493                 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
494                  16,   0,   0,   0,   1,   0,   1,   0,
495                 0x44,0xAC,  0,   0,   0,   0,   0,   0,
496                   2,   0,  16,   0, 'd', 'a', 't', 'a',
497                  16,   0,   0,   0,   0,   0,   1,   0,
498                   4,   0,   9,   0,  16,   0,  25,   0,
499                  36,   0,  49,   0, 'p', 'a', 'd', ' ',
500                   4,   0,   0,   0, 'b', 'l', 'a', 'h'
501         };
502
503         if(0 == (f = fopen("wacky1.wav", mode)))
504                 return false;
505         if(fwrite(wav, 1, 84, f) < 84)
506                 goto foo;
507         fclose(f);
508
509         wav[4] += 12;
510         if(0 == (f = fopen("wacky2.wav", mode)))
511                 return false;
512         if(fwrite(wav, 1, 96, f) < 96)
513                 goto foo;
514         fclose(f);
515
516         return true;
517 foo:
518         fclose(f);
519         return false;
520 }
521
522 int main(int argc, char *argv[])
523 {
524         FLAC__uint32 test = 1;
525
526         int pattern01[] = { 1, -1, 0 };
527         int pattern02[] = { 1, 1, -1, 0 };
528         int pattern03[] = { 1, -1, -1, 0 };
529         int pattern04[] = { 1, -1, 1, -1, 0 };
530         int pattern05[] = { 1, -1, -1, 1, 0 };
531         int pattern06[] = { 1, -1, 1, 1, -1, 0 };
532         int pattern07[] = { 1, -1, -1, 1, -1, 0 };
533
534         (void)argc;
535         (void)argv;
536         is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
537
538         if(!generate_01()) return 1;
539         if(!generate_02()) return 1;
540         if(!generate_03()) return 1;
541         if(!generate_04()) return 1;
542
543         if(!generate_fsd8("fsd8-01.raw", pattern01, 100)) return 1;
544         if(!generate_fsd8("fsd8-02.raw", pattern02, 100)) return 1;
545         if(!generate_fsd8("fsd8-03.raw", pattern03, 100)) return 1;
546         if(!generate_fsd8("fsd8-04.raw", pattern04, 100)) return 1;
547         if(!generate_fsd8("fsd8-05.raw", pattern05, 100)) return 1;
548         if(!generate_fsd8("fsd8-06.raw", pattern06, 100)) return 1;
549         if(!generate_fsd8("fsd8-07.raw", pattern07, 100)) return 1;
550
551         if(!generate_fsd16("fsd16-01.raw", pattern01, 100)) return 1;
552         if(!generate_fsd16("fsd16-02.raw", pattern02, 100)) return 1;
553         if(!generate_fsd16("fsd16-03.raw", pattern03, 100)) return 1;
554         if(!generate_fsd16("fsd16-04.raw", pattern04, 100)) return 1;
555         if(!generate_fsd16("fsd16-05.raw", pattern05, 100)) return 1;
556         if(!generate_fsd16("fsd16-06.raw", pattern06, 100)) return 1;
557         if(!generate_fsd16("fsd16-07.raw", pattern07, 100)) return 1;
558
559         if(!generate_fsd24("fsd24-01.raw", pattern01, 100)) return 1;
560         if(!generate_fsd24("fsd24-02.raw", pattern02, 100)) return 1;
561         if(!generate_fsd24("fsd24-03.raw", pattern03, 100)) return 1;
562         if(!generate_fsd24("fsd24-04.raw", pattern04, 100)) return 1;
563         if(!generate_fsd24("fsd24-05.raw", pattern05, 100)) return 1;
564         if(!generate_fsd24("fsd24-06.raw", pattern06, 100)) return 1;
565         if(!generate_fsd24("fsd24-07.raw", pattern07, 100)) return 1;
566
567         if(!generate_wbps16("wbps16-01.raw", 1000)) return 1;
568
569         if(!generate_sine8_1("sine8-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
570         if(!generate_sine8_1("sine8-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
571         if(!generate_sine8_1("sine8-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
572         if(!generate_sine8_1("sine8-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
573         if(!generate_sine8_1("sine8-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
574
575         if(!generate_sine8_2("sine8-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
576         if(!generate_sine8_2("sine8-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
577         if(!generate_sine8_2("sine8-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
578         if(!generate_sine8_2("sine8-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
579         if(!generate_sine8_2("sine8-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
580         if(!generate_sine8_2("sine8-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
581         if(!generate_sine8_2("sine8-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
582         if(!generate_sine8_2("sine8-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
583         if(!generate_sine8_2("sine8-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
584         if(!generate_sine8_2("sine8-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
585
586         if(!generate_sine16_1("sine16-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
587         if(!generate_sine16_1("sine16-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
588         if(!generate_sine16_1("sine16-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
589         if(!generate_sine16_1("sine16-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
590         if(!generate_sine16_1("sine16-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
591
592         if(!generate_sine16_2("sine16-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
593         if(!generate_sine16_2("sine16-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
594         if(!generate_sine16_2("sine16-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
595         if(!generate_sine16_2("sine16-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
596         if(!generate_sine16_2("sine16-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
597         if(!generate_sine16_2("sine16-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
598         if(!generate_sine16_2("sine16-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
599         if(!generate_sine16_2("sine16-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
600         if(!generate_sine16_2("sine16-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
601         if(!generate_sine16_2("sine16-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
602
603         if(!generate_sine24_1("sine24-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
604         if(!generate_sine24_1("sine24-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
605         if(!generate_sine24_1("sine24-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
606         if(!generate_sine24_1("sine24-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
607         if(!generate_sine24_1("sine24-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
608
609         if(!generate_sine24_2("sine24-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
610         if(!generate_sine24_2("sine24-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
611         if(!generate_sine24_2("sine24-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
612         if(!generate_sine24_2("sine24-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
613         if(!generate_sine24_2("sine24-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
614         if(!generate_sine24_2("sine24-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
615         if(!generate_sine24_2("sine24-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
616         if(!generate_sine24_2("sine24-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
617         if(!generate_sine24_2("sine24-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
618         if(!generate_sine24_2("sine24-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
619
620         if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1;
621         if(!generate_noise("noise8m32.raw", 32)) return 1;
622         if(!generate_wackywavs()) return 1;
623
624         return 0;
625 }