Update Makefile.lite build system.
[flac.git] / src / test_streams / main.c
1 /* test_streams - Simple test pattern generator
2  * Copyright (C) 2000-2009  Josh Coalson
3  * Copyright (C) 2011-2013  Xiph.Org Foundation
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include <config.h>
22 #endif
23
24 #include <math.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include "share/compat.h"
28 #if defined _MSC_VER || defined __MINGW32__
29 #include <time.h>
30 #else
31 #include <sys/time.h>
32 #endif
33 #include "FLAC/assert.h"
34 #include "FLAC/ordinals.h"
35 #include "share/compat.h"
36
37 #if !defined _MSC_VER && !defined __MINGW32__
38 #define GET_RANDOM_BYTE (((unsigned)random()) & 0xff)
39 #else
40 #define GET_RANDOM_BYTE (((unsigned)rand()) & 0xff)
41 #endif
42
43 static FLAC__bool is_big_endian_host;
44
45
46 static FLAC__bool write_little_endian(FILE *f, FLAC__int32 x, size_t bytes)
47 {
48         while(bytes) {
49                 if(fputc(x, f) == EOF)
50                         return false;
51                 x >>= 8;
52                 bytes--;
53         }
54         return true;
55 }
56
57 static FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 x)
58 {
59         return
60                 fputc(x, f) != EOF &&
61                 fputc(x >> 8, f) != EOF
62         ;
63 }
64
65 static FLAC__bool write_little_endian_int16(FILE *f, FLAC__int16 x)
66 {
67         return write_little_endian_uint16(f, (FLAC__uint16)x);
68 }
69
70 static FLAC__bool write_little_endian_uint24(FILE *f, FLAC__uint32 x)
71 {
72         return
73                 fputc(x, f) != EOF &&
74                 fputc(x >> 8, f) != EOF &&
75                 fputc(x >> 16, f) != EOF
76         ;
77 }
78
79 static FLAC__bool write_little_endian_int24(FILE *f, FLAC__int32 x)
80 {
81         return write_little_endian_uint24(f, (FLAC__uint32)x);
82 }
83
84 static FLAC__bool write_little_endian_uint32(FILE *f, FLAC__uint32 x)
85 {
86         return
87                 fputc(x, f) != EOF &&
88                 fputc(x >> 8, f) != EOF &&
89                 fputc(x >> 16, f) != EOF &&
90                 fputc(x >> 24, f) != EOF
91         ;
92 }
93
94 #if 0
95 /* @@@ not used (yet) */
96 static FLAC__bool write_little_endian_int32(FILE *f, FLAC__int32 x)
97 {
98         return write_little_endian_uint32(f, (FLAC__uint32)x);
99 }
100 #endif
101
102 static FLAC__bool write_little_endian_uint64(FILE *f, FLAC__uint64 x)
103 {
104         return
105                 fputc(x, f) != EOF &&
106                 fputc(x >> 8, f) != EOF &&
107                 fputc(x >> 16, f) != EOF &&
108                 fputc(x >> 24, f) != EOF &&
109                 fputc(x >> 32, f) != EOF &&
110                 fputc(x >> 40, f) != EOF &&
111                 fputc(x >> 48, f) != EOF &&
112                 fputc(x >> 56, f) != EOF
113         ;
114 }
115
116 static FLAC__bool write_big_endian(FILE *f, FLAC__int32 x, size_t bytes)
117 {
118         if(bytes < 4)
119                 x <<= 8*(4-bytes);
120         while(bytes) {
121                 if(fputc(x>>24, f) == EOF)
122                         return false;
123                 x <<= 8;
124                 bytes--;
125         }
126         return true;
127 }
128
129 static FLAC__bool write_big_endian_uint16(FILE *f, FLAC__uint16 x)
130 {
131         return
132                 fputc(x >> 8, f) != EOF &&
133                 fputc(x, f) != EOF
134         ;
135 }
136
137 #if 0
138 /* @@@ not used (yet) */
139 static FLAC__bool write_big_endian_int16(FILE *f, FLAC__int16 x)
140 {
141         return write_big_endian_uint16(f, (FLAC__uint16)x);
142 }
143 #endif
144
145 #if 0
146 /* @@@ not used (yet) */
147 static FLAC__bool write_big_endian_uint24(FILE *f, FLAC__uint32 x)
148 {
149         return
150                 fputc(x >> 16, f) != EOF &&
151                 fputc(x >> 8, f) != EOF &&
152                 fputc(x, f) != EOF
153         ;
154 }
155 #endif
156
157 #if 0
158 /* @@@ not used (yet) */
159 static FLAC__bool write_big_endian_int24(FILE *f, FLAC__int32 x)
160 {
161         return write_big_endian_uint24(f, (FLAC__uint32)x);
162 }
163 #endif
164
165 static FLAC__bool write_big_endian_uint32(FILE *f, FLAC__uint32 x)
166 {
167         return
168                 fputc(x >> 24, f) != EOF &&
169                 fputc(x >> 16, f) != EOF &&
170                 fputc(x >> 8, f) != EOF &&
171                 fputc(x, f) != EOF
172         ;
173 }
174
175 #if 0
176 /* @@@ not used (yet) */
177 static FLAC__bool write_big_endian_int32(FILE *f, FLAC__int32 x)
178 {
179         return write_big_endian_uint32(f, (FLAC__uint32)x);
180 }
181 #endif
182
183 static FLAC__bool write_sane_extended(FILE *f, unsigned val)
184         /* Write to 'f' a SANE extended representation of 'val'.  Return false if
185         * the write succeeds; return true otherwise.
186         *
187         * SANE extended is an 80-bit IEEE-754 representation with sign bit, 15 bits
188         * of exponent, and 64 bits of significand (mantissa).  Unlike most IEEE-754
189         * representations, it does not imply a 1 above the MSB of the significand.
190         *
191         * Preconditions:
192         *  val!=0U
193         */
194 {
195         unsigned int shift, exponent;
196
197         FLAC__ASSERT(val!=0U); /* handling 0 would require a special case */
198
199         for(shift= 0U; (val>>(31-shift))==0U; ++shift)
200                 ;
201         val<<= shift;
202         exponent= 63U-(shift+32U); /* add 32 for unused second word */
203
204         if(!write_big_endian_uint16(f, (FLAC__uint16)(exponent+0x3FFF)))
205                 return false;
206         if(!write_big_endian_uint32(f, val))
207                 return false;
208         if(!write_big_endian_uint32(f, 0)) /* unused second word */
209                 return false;
210
211         return true;
212 }
213
214 /* a mono one-sample 16bps stream */
215 static FLAC__bool generate_01(void)
216 {
217         FILE *f;
218         FLAC__int16 x = -32768;
219
220         if(0 == (f = flac_fopen("test01.raw", "wb")))
221                 return false;
222
223         if(!write_little_endian_int16(f, x))
224                 goto foo;
225
226         fclose(f);
227         return true;
228 foo:
229         fclose(f);
230         return false;
231 }
232
233 /* a stereo one-sample 16bps stream */
234 static FLAC__bool generate_02(void)
235 {
236         FILE *f;
237         FLAC__int16 xl = -32768, xr = 32767;
238
239         if(0 == (f = flac_fopen("test02.raw", "wb")))
240                 return false;
241
242         if(!write_little_endian_int16(f, xl))
243                 goto foo;
244         if(!write_little_endian_int16(f, xr))
245                 goto foo;
246
247         fclose(f);
248         return true;
249 foo:
250         fclose(f);
251         return false;
252 }
253
254 /* a mono five-sample 16bps stream */
255 static FLAC__bool generate_03(void)
256 {
257         FILE *f;
258         FLAC__int16 x[] = { -25, 0, 25, 50, 100 };
259         unsigned i;
260
261         if(0 == (f = flac_fopen("test03.raw", "wb")))
262                 return false;
263
264         for(i = 0; i < 5; i++)
265                 if(!write_little_endian_int16(f, x[i]))
266                         goto foo;
267
268         fclose(f);
269         return true;
270 foo:
271         fclose(f);
272         return false;
273 }
274
275 /* a stereo five-sample 16bps stream */
276 static FLAC__bool generate_04(void)
277 {
278         FILE *f;
279         FLAC__int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
280         unsigned i;
281
282         if(0 == (f = flac_fopen("test04.raw", "wb")))
283                 return false;
284
285         for(i = 0; i < 10; i++)
286                 if(!write_little_endian_int16(f, x[i]))
287                         goto foo;
288
289         fclose(f);
290         return true;
291 foo:
292         fclose(f);
293         return false;
294 }
295
296 /* a mono full-scale deflection 8bps stream */
297 static FLAC__bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
298 {
299         FILE *f;
300         unsigned rep, p;
301
302         FLAC__ASSERT(pattern != 0);
303
304         if(0 == (f = flac_fopen(fn, "wb")))
305                 return false;
306
307         for(rep = 0; rep < reps; rep++) {
308                 for(p = 0; pattern[p]; p++) {
309                         signed char x = pattern[p] > 0? 127 : -128;
310                         if(fwrite(&x, sizeof(x), 1, f) < 1)
311                                 goto foo;
312                 }
313         }
314
315         fclose(f);
316         return true;
317 foo:
318         fclose(f);
319         return false;
320 }
321
322 /* a mono full-scale deflection 16bps stream */
323 static FLAC__bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
324 {
325         FILE *f;
326         unsigned rep, p;
327
328         FLAC__ASSERT(pattern != 0);
329
330         if(0 == (f = flac_fopen(fn, "wb")))
331                 return false;
332
333         for(rep = 0; rep < reps; rep++) {
334                 for(p = 0; pattern[p]; p++) {
335                         FLAC__int16 x = pattern[p] > 0? 32767 : -32768;
336                         if(!write_little_endian_int16(f, x))
337                                 goto foo;
338                 }
339         }
340
341         fclose(f);
342         return true;
343 foo:
344         fclose(f);
345         return false;
346 }
347
348 /* a stereo wasted-bits-per-sample 16bps stream */
349 static FLAC__bool generate_wbps16(const char *fn, unsigned samples)
350 {
351         FILE *f;
352         unsigned sample;
353
354         if(0 == (f = flac_fopen(fn, "wb")))
355                 return false;
356
357         for(sample = 0; sample < samples; sample++) {
358                 FLAC__int16 l = (sample % 2000) << 2;
359                 FLAC__int16 r = (sample % 1000) << 3;
360                 if(!write_little_endian_int16(f, l))
361                         goto foo;
362                 if(!write_little_endian_int16(f, r))
363                         goto foo;
364         }
365
366         fclose(f);
367         return true;
368 foo:
369         fclose(f);
370         return false;
371 }
372
373 /* a mono full-scale deflection 24bps stream */
374 static FLAC__bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
375 {
376         FILE *f;
377         unsigned rep, p;
378
379         FLAC__ASSERT(pattern != 0);
380
381         if(0 == (f = flac_fopen(fn, "wb")))
382                 return false;
383
384         for(rep = 0; rep < reps; rep++) {
385                 for(p = 0; pattern[p]; p++) {
386                         FLAC__int32 x = pattern[p] > 0? 8388607 : -8388608;
387                         if(!write_little_endian_int24(f, x))
388                                 goto foo;
389                 }
390         }
391
392         fclose(f);
393         return true;
394 foo:
395         fclose(f);
396         return false;
397 }
398
399 /* a mono sine-wave 8bps stream */
400 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)
401 {
402         const FLAC__int8 full_scale = 127;
403         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
404         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
405         FILE *f;
406         double theta1, theta2;
407         unsigned i;
408
409         if(0 == (f = flac_fopen(fn, "wb")))
410                 return false;
411
412         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
413                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
414                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
415                 if(fwrite(&v, sizeof(v), 1, f) < 1)
416                         goto foo;
417         }
418
419         fclose(f);
420         return true;
421 foo:
422         fclose(f);
423         return false;
424 }
425
426 /* a stereo sine-wave 8bps stream */
427 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)
428 {
429         const FLAC__int8 full_scale = 127;
430         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
431         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
432         FILE *f;
433         double theta1, theta2;
434         unsigned i;
435
436         if(0 == (f = flac_fopen(fn, "wb")))
437                 return false;
438
439         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
440                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
441                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
442                 if(fwrite(&v, sizeof(v), 1, f) < 1)
443                         goto foo;
444                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
445                 v = (FLAC__int8)(val + 0.5);
446                 if(fwrite(&v, sizeof(v), 1, f) < 1)
447                         goto foo;
448         }
449
450         fclose(f);
451         return true;
452 foo:
453         fclose(f);
454         return false;
455 }
456
457 /* a mono sine-wave 16bps stream */
458 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)
459 {
460         const FLAC__int16 full_scale = 32767;
461         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
462         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
463         FILE *f;
464         double theta1, theta2;
465         unsigned i;
466
467         if(0 == (f = flac_fopen(fn, "wb")))
468                 return false;
469
470         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
471                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
472                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
473                 if(!write_little_endian_int16(f, v))
474                         goto foo;
475         }
476
477         fclose(f);
478         return true;
479 foo:
480         fclose(f);
481         return false;
482 }
483
484 /* a stereo sine-wave 16bps stream */
485 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)
486 {
487         const FLAC__int16 full_scale = 32767;
488         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
489         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
490         FILE *f;
491         double theta1, theta2;
492         unsigned i;
493
494         if(0 == (f = flac_fopen(fn, "wb")))
495                 return false;
496
497         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
498                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
499                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
500                 if(!write_little_endian_int16(f, v))
501                         goto foo;
502                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
503                 v = (FLAC__int16)(val + 0.5);
504                 if(!write_little_endian_int16(f, v))
505                         goto foo;
506         }
507
508         fclose(f);
509         return true;
510 foo:
511         fclose(f);
512         return false;
513 }
514
515 /* a mono sine-wave 24bps stream */
516 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)
517 {
518         const FLAC__int32 full_scale = 0x7fffff;
519         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
520         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
521         FILE *f;
522         double theta1, theta2;
523         unsigned i;
524
525         if(0 == (f = flac_fopen(fn, "wb")))
526                 return false;
527
528         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
529                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
530                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
531                 if(!write_little_endian_int24(f, v))
532                         goto foo;
533         }
534
535         fclose(f);
536         return true;
537 foo:
538         fclose(f);
539         return false;
540 }
541
542 /* a stereo sine-wave 24bps stream */
543 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)
544 {
545         const FLAC__int32 full_scale = 0x7fffff;
546         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
547         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
548         FILE *f;
549         double theta1, theta2;
550         unsigned i;
551
552         if(0 == (f = flac_fopen(fn, "wb")))
553                 return false;
554
555         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
556                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
557                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
558                 if(!write_little_endian_int24(f, v))
559                         goto foo;
560                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
561                 v = (FLAC__int32)(val + 0.5);
562                 if(!write_little_endian_int24(f, v))
563                         goto foo;
564         }
565
566         fclose(f);
567         return true;
568 foo:
569         fclose(f);
570         return false;
571 }
572
573 static FLAC__bool generate_noise(const char *fn, unsigned bytes)
574 {
575         FILE *f;
576         unsigned b;
577
578         if(0 == (f = flac_fopen(fn, "wb")))
579                 return false;
580
581         for(b = 0; b < bytes; b++) {
582 #if !defined _MSC_VER && !defined __MINGW32__
583                 FLAC__byte x = (FLAC__byte)(((unsigned)random()) & 0xff);
584 #else
585                 FLAC__byte x = (FLAC__byte)(((unsigned)rand()) & 0xff);
586 #endif
587                 if(fwrite(&x, sizeof(x), 1, f) < 1)
588                         goto foo;
589         }
590
591         fclose(f);
592         return true;
593 foo:
594         fclose(f);
595         return false;
596 }
597
598 static FLAC__bool generate_raw(const char *filename, unsigned channels, unsigned bytes_per_sample, unsigned samples)
599 {
600         const FLAC__int32 full_scale = (1 << (bytes_per_sample*8-1)) - 1;
601         const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37;
602         const double delta1 = 2.0 * M_PI / ( 44100.0 / f1);
603         const double delta2 = 2.0 * M_PI / ( 44100.0 / f2);
604         double theta1, theta2;
605         FILE *f;
606         unsigned i, j;
607
608         if(0 == (f = flac_fopen(filename, "wb")))
609                 return false;
610
611         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
612                 for(j = 0; j < channels; j++) {
613                         double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
614                         FLAC__int32 v = (FLAC__int32)(val + 0.5) + ((GET_RANDOM_BYTE>>4)-8);
615                         if(!write_little_endian(f, v, bytes_per_sample))
616                                 goto foo;
617                 }
618         }
619
620         fclose(f);
621         return true;
622 foo:
623         fclose(f);
624         return false;
625 }
626
627 static FLAC__bool generate_aiff(const char *filename, unsigned sample_rate, unsigned channels, unsigned bps, unsigned samples)
628 {
629         const unsigned bytes_per_sample = (bps+7)/8;
630         const unsigned true_size = channels * bytes_per_sample * samples;
631         const unsigned padded_size = (true_size + 1) & (~1u);
632         const unsigned shift = (bps%8)? 8 - (bps%8) : 0;
633         const FLAC__int32 full_scale = (1 << (bps-1)) - 1;
634         const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37;
635         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
636         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
637         double theta1, theta2;
638         FILE *f;
639         unsigned i, j;
640
641         if(0 == (f = flac_fopen(filename, "wb")))
642                 return false;
643         if(fwrite("FORM", 1, 4, f) < 4)
644                 goto foo;
645         if(!write_big_endian_uint32(f, padded_size + 46))
646                 goto foo;
647         if(fwrite("AIFFCOMM\000\000\000\022", 1, 12, f) < 12)
648                 goto foo;
649         if(!write_big_endian_uint16(f, (FLAC__uint16)channels))
650                 goto foo;
651         if(!write_big_endian_uint32(f, samples))
652                 goto foo;
653         if(!write_big_endian_uint16(f, (FLAC__uint16)bps))
654                 goto foo;
655         if(!write_sane_extended(f, sample_rate))
656                 goto foo;
657         if(fwrite("SSND", 1, 4, f) < 4)
658                 goto foo;
659         if(!write_big_endian_uint32(f, true_size + 8))
660                 goto foo;
661         if(fwrite("\000\000\000\000\000\000\000\000", 1, 8, f) < 8)
662                 goto foo;
663
664         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
665                 for(j = 0; j < channels; j++) {
666                         double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
667                         FLAC__int32 v = ((FLAC__int32)(val + 0.5) + ((GET_RANDOM_BYTE>>4)-8)) << shift;
668                         if(!write_big_endian(f, v, bytes_per_sample))
669                                 goto foo;
670                 }
671         }
672         for(i = true_size; i < padded_size; i++)
673                 if(fputc(0, f) == EOF)
674                         goto foo;
675
676         fclose(f);
677         return true;
678 foo:
679         fclose(f);
680         return false;
681 }
682
683 /* flavor is: 0:WAVE, 1:RF64, 2:WAVE64 */
684 static FLAC__bool generate_wav(const char *filename, unsigned sample_rate, unsigned channels, unsigned bps, unsigned samples, FLAC__bool strict, int flavor)
685 {
686         const FLAC__bool waveformatextensible = strict && (channels > 2 || (bps%8));
687         /*                                                                 ^^^^^^^
688          * (bps%8) allows 24 bps which is technically supposed to be WAVEFORMATEXTENSIBLE but we
689          * write 24bps as WAVEFORMATEX since it's unambiguous and matches how flac writes it
690          */
691
692         const unsigned bytes_per_sample = (bps+7)/8;
693         const unsigned shift = (bps%8)? 8 - (bps%8) : 0;
694         /* this rig is not going over 4G so we're ok with 32-bit sizes here */
695         const FLAC__uint32 true_size = channels * bytes_per_sample * samples;
696         const FLAC__uint32 padded_size = flavor<2? (true_size + 1) & (~1u) : (true_size + 7) & (~7u);
697         const FLAC__int32 full_scale = (1 << (bps-1)) - 1;
698         const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37;
699         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
700         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
701         double theta1, theta2;
702         FILE *f;
703         unsigned i, j;
704
705         if(0 == (f = flac_fopen(filename, "wb")))
706                 return false;
707         /* RIFFxxxxWAVE or equivalent: */
708         switch(flavor) {
709                 case 0:
710                         if(fwrite("RIFF", 1, 4, f) < 4)
711                                 goto foo;
712                         /* +4 for WAVE */
713                         /* +8+{40,16} for fmt chunk */
714                         /* +8 for data chunk header */
715                         if(!write_little_endian_uint32(f, 4 + 8+(waveformatextensible?40:16) + 8 + padded_size))
716                                 goto foo;
717                         if(fwrite("WAVE", 1, 4, f) < 4)
718                                 goto foo;
719                         break;
720                 case 1:
721                         if(fwrite("RF64", 1, 4, f) < 4)
722                                 goto foo;
723                         if(!write_little_endian_uint32(f, 0xffffffff))
724                                 goto foo;
725                         if(fwrite("WAVE", 1, 4, f) < 4)
726                                 goto foo;
727                         break;
728                 case 2:
729                         /* RIFF GUID 66666972-912E-11CF-A5D6-28DB04C10000 */
730                         if(fwrite("\x72\x69\x66\x66\x2E\x91\xCF\x11\xA5\xD6\x28\xDB\x04\xC1\x00\x00", 1, 16, f) < 16)
731                                 goto foo;
732                         /* +(16+8) for RIFF GUID + size */
733                         /* +16 for WAVE GUID */
734                         /* +16+8+{40,16} for fmt chunk */
735                         /* +16+8 for data chunk header */
736                         if(!write_little_endian_uint64(f, (16+8) + 16 + 16+8+(waveformatextensible?40:16) + (16+8) + padded_size))
737                                 goto foo;
738                         /* WAVE GUID 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
739                         if(fwrite("\x77\x61\x76\x65\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) < 16)
740                                 goto foo;
741                         break;
742                 default:
743                         goto foo;
744         }
745         if(flavor == 1) { /* rf64 */
746                 if(fwrite("ds64", 1, 4, f) < 4)
747                         goto foo;
748                 if(!write_little_endian_uint32(f, 28)) /* ds64 chunk size */
749                         goto foo;
750                 if(!write_little_endian_uint64(f, 36 + padded_size + (waveformatextensible?60:36)))
751                         goto foo;
752                 if(!write_little_endian_uint64(f, true_size))
753                         goto foo;
754                 if(!write_little_endian_uint64(f, samples))
755                         goto foo;
756                 if(!write_little_endian_uint32(f, 0)) /* table size */
757                         goto foo;
758         }
759         /* fmt chunk */
760         if(flavor < 2) {
761                 if(fwrite("fmt ", 1, 4, f) < 4)
762                         goto foo;
763                 /* chunk size */
764                 if(!write_little_endian_uint32(f, waveformatextensible?40:16))
765                         goto foo;
766         }
767         else { /* wave64 */
768                 /* fmt GUID 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
769                 if(fwrite("\x66\x6D\x74\x20\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) < 16)
770                         goto foo;
771                 /* chunk size (+16+8 for GUID and size fields) */
772                 if(!write_little_endian_uint64(f, 16+8+(waveformatextensible?40:16)))
773                         goto foo;
774         }
775         if(!write_little_endian_uint16(f, (FLAC__uint16)(waveformatextensible?65534:1)))
776                 goto foo;
777         if(!write_little_endian_uint16(f, (FLAC__uint16)channels))
778                 goto foo;
779         if(!write_little_endian_uint32(f, sample_rate))
780                 goto foo;
781         if(!write_little_endian_uint32(f, sample_rate * channels * bytes_per_sample))
782                 goto foo;
783         if(!write_little_endian_uint16(f, (FLAC__uint16)(channels * bytes_per_sample))) /* block align */
784                 goto foo;
785         if(!write_little_endian_uint16(f, (FLAC__uint16)(bps+shift)))
786                 goto foo;
787         if(waveformatextensible) {
788                 if(!write_little_endian_uint16(f, (FLAC__uint16)22)) /* cbSize */
789                         goto foo;
790                 if(!write_little_endian_uint16(f, (FLAC__uint16)bps)) /* validBitsPerSample */
791                         goto foo;
792                 if(!write_little_endian_uint32(f, 0)) /* channelMask */
793                         goto foo;
794                 /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */
795                 if(fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f) != 16)
796                         goto foo;
797         }
798         /* data chunk */
799         if(flavor < 2) {
800                 if(fwrite("data", 1, 4, f) < 4)
801                         goto foo;
802                 if(!write_little_endian_uint32(f, flavor==1? 0xffffffff : true_size))
803                         goto foo;
804         }
805         else { /* wave64 */
806                 /* data GUID 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
807                 if(fwrite("\x64\x61\x74\x61\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) != 16)
808                         goto foo;
809                 /* +16+8 for GUID and size fields */
810                 if(!write_little_endian_uint64(f, 16+8 + true_size))
811                         goto foo;
812         }
813
814         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
815                 for(j = 0; j < channels; j++) {
816                         double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
817                         FLAC__int32 v = ((FLAC__int32)(val + 0.5) + ((GET_RANDOM_BYTE>>4)-8)) << shift;
818                         if(!write_little_endian(f, v, bytes_per_sample))
819                                 goto foo;
820                 }
821         }
822         for(i = true_size; i < padded_size; i++)
823                 if(fputc(0, f) == EOF)
824                         goto foo;
825
826         fclose(f);
827         return true;
828 foo:
829         fclose(f);
830         return false;
831 }
832
833 static FLAC__bool generate_wackywavs(void)
834 {
835         FILE *f;
836         FLAC__byte wav[] = {
837                 'R', 'I', 'F', 'F',  76,   0,   0,   0,
838                 'W', 'A', 'V', 'E', 'j', 'u', 'n', 'k',
839                   4,   0,   0,  0 , 'b', 'l', 'a', 'h',
840                 'p', 'a', 'd', ' ',   4,   0,   0,   0,
841                 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
842                  16,   0,   0,   0,   1,   0,   1,   0,
843                 0x44,0xAC,  0,   0,0x88,0x58,0x01,   0,
844                   2,   0,  16,   0, 'd', 'a', 't', 'a',
845                  16,   0,   0,   0,   0,   0,   1,   0,
846                   4,   0,   9,   0,  16,   0,  25,   0,
847                  36,   0,  49,   0, 'p', 'a', 'd', ' ',
848                   4,   0,   0,   0, 'b', 'l', 'a', 'h'
849         };
850
851         if(0 == (f = flac_fopen("wacky1.wav", "wb")))
852                 return false;
853         if(fwrite(wav, 1, 84, f) < 84)
854                 goto foo;
855         fclose(f);
856
857         wav[4] += 12;
858         if(0 == (f = flac_fopen("wacky2.wav", "wb")))
859                 return false;
860         if(fwrite(wav, 1, 96, f) < 96)
861                 goto foo;
862         fclose(f);
863
864         return true;
865 foo:
866         fclose(f);
867         return false;
868 }
869
870 static FLAC__bool generate_noisy_sine(void)
871 {
872         FILE *f;
873         FLAC__byte wav[] = {
874                 'R', 'I', 'F', 'F',  76,   0,   0,   0,
875                 'W', 'A', 'V', 'E', 'f', 'm', 't', ' ',
876                  16,   0,   0,   0,   1,   0,   1,   0,
877                 0x44,0xAC,  0,   0,0x88,0x58,0x01,   0,
878                   2,   0,  16,   0, 'd', 'a', 't', 'a',
879                 0xa8,   0xba,   0x6,   0
880         };
881         int32_t randstate = 0x1243456;
882         double sample, last_val = 0.0;
883         int k;
884
885         if(0 == (f = flac_fopen("noisy-sine.wav", "wb")))
886                 return false;
887         if(fwrite(wav, 1, sizeof (wav), f) < sizeof (wav))
888                 goto foo;
889
890         for (k = 0 ; k < 5 * 44100 ; k++) {
891                 /* Obvioulsy not a crypto quality RNG. */
892                 randstate = 11117 * randstate + 211231;
893                 randstate = 11117 * randstate + 211231;
894                 randstate = 11117 * randstate + 211231;
895
896                 sample = randstate / (0x7fffffff * 1.000001);
897                 sample = 0.2 * sample - 0.9 * last_val;
898
899                 last_val = sample;
900
901                 sample += sin (2.0 * k * M_PI * 1.0 / 32.0);
902                 sample *= 0.4;
903 #if !defined _MSC_VER
904                 write_little_endian_int16(f, lrintf(sample * 32700.0));
905 #else
906                 write_little_endian_int16(f, (FLAC__int16)(sample * 32700.0));
907 #endif
908         };
909
910         fclose(f);
911
912         return true;
913 foo:
914         fclose(f);
915         return false;
916 }
917
918 static FLAC__bool generate_wackywav64s(void)
919 {
920         FILE *f;
921         FLAC__byte wav[] = {
922                 0x72,0x69,0x66,0x66,0x2E,0x91,0xCF,0x11, /* RIFF GUID */
923                 0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,
924                  152,   0,   0,   0,   0,   0,   0,   0,
925                 0x77,0x61,0x76,0x65,0xF3,0xAC,0xD3,0x11, /* WAVE GUID */
926                 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
927                 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */
928                 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
929                   32,   0,   0,  0 ,   0,   0,   0,   0,
930                  'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h',
931                 0x66,0x6D,0x74,0x20,0xF3,0xAC,0xD3,0x11, /* fmt GUID */
932                 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
933                   40,   0,   0,  0 ,   0,   0,   0,   0,
934                    1,   0,   1,   0,0x44,0xAC,   0,   0,
935                 0x88,0x58,0x01,   0,   2,   0,  16,   0,
936                 0x64,0x61,0x74,0x61,0xF3,0xAC,0xD3,0x11, /* data GUID */
937                 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
938                   40,   0,   0,  0 ,   0,   0,   0,   0,
939                    0,   0,   1,   0,   4,   0,   9,   0,
940                   16,   0,  25,   0,  36,   0,  49,   0,
941                 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */
942                 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
943                   32,   0,   0,  0 ,   0,   0,   0,   0,
944                  'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h'
945         };
946
947         if(0 == (f = flac_fopen("wacky1.w64", "wb")))
948                 return false;
949         if(fwrite(wav, 1, wav[16], f) < wav[16])
950                 goto foo;
951         fclose(f);
952
953         wav[16] += 32;
954         if(0 == (f = flac_fopen("wacky2.w64", "wb")))
955                 return false;
956         if(fwrite(wav, 1, wav[16], f) < wav[16])
957                 goto foo;
958         fclose(f);
959
960         return true;
961 foo:
962         fclose(f);
963         return false;
964 }
965
966 static FLAC__bool generate_wackyrf64s(void)
967 {
968         FILE *f;
969         FLAC__byte wav[] = {
970                 'R', 'F', '6', '4', 255, 255, 255, 255,
971                 'W', 'A', 'V', 'E', 'd', 's', '6', '4',
972                  28,   0,   0,   0, 112,   0,   0,   0,
973                   0,   0,   0,   0,  16,   0,   0,   0,
974                   0,   0,   0,   0,   8,   0,   0,   0,
975                   0,   0,   0,   0,   0,   0,   0,   0,
976                                     'j', 'u', 'n', 'k',
977                   4,   0,   0,   0, 'b', 'l', 'a', 'h',
978                 'p', 'a', 'd', ' ',   4,   0,   0,   0,
979                 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
980                  16,   0,   0,   0,   1,   0,   1,   0,
981                 0x44,0xAC,  0,   0,0x88,0x58,0x01,   0,
982                   2,   0,  16,   0, 'd', 'a', 't', 'a',
983                 255, 255, 255, 255,   0,   0,   1,   0,
984                   4,   0,   9,   0,  16,   0,  25,   0,
985                  36,   0,  49,   0, 'p', 'a', 'd', ' ',
986                   4,   0,   0,   0, 'b', 'l', 'a', 'h'
987         };
988
989         if(0 == (f = flac_fopen("wacky1.rf64", "wb")))
990                 return false;
991         if(fwrite(wav, 1, 120, f) < 120)
992                 goto foo;
993         fclose(f);
994
995         wav[20] += 12;
996         if(0 == (f = flac_fopen("wacky2.rf64", "wb")))
997                 return false;
998         if(fwrite(wav, 1, 132, f) < 132)
999                 goto foo;
1000         fclose(f);
1001
1002         return true;
1003 foo:
1004         fclose(f);
1005         return false;
1006 }
1007
1008 int main(int argc, char *argv[])
1009 {
1010         FLAC__uint32 test = 1;
1011         unsigned channels;
1012
1013         int pattern01[] = { 1, -1, 0 };
1014         int pattern02[] = { 1, 1, -1, 0 };
1015         int pattern03[] = { 1, -1, -1, 0 };
1016         int pattern04[] = { 1, -1, 1, -1, 0 };
1017         int pattern05[] = { 1, -1, -1, 1, 0 };
1018         int pattern06[] = { 1, -1, 1, 1, -1, 0 };
1019         int pattern07[] = { 1, -1, -1, 1, -1, 0 };
1020
1021         (void)argc;
1022         (void)argv;
1023         is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
1024
1025 #if !defined _MSC_VER && !defined __MINGW32__
1026         {
1027                 struct timeval tv;
1028
1029                 if(gettimeofday(&tv, 0) < 0) {
1030                         fprintf(stderr, "WARNING: couldn't seed RNG with time\n");
1031                         tv.tv_usec = 4321;
1032                 }
1033                 srandom(tv.tv_usec);
1034         }
1035 #else
1036         srand((unsigned)time(0));
1037 #endif
1038
1039         if(!generate_01()) return 1;
1040         if(!generate_02()) return 1;
1041         if(!generate_03()) return 1;
1042         if(!generate_04()) return 1;
1043
1044         if(!generate_fsd8("fsd8-01.raw", pattern01, 100)) return 1;
1045         if(!generate_fsd8("fsd8-02.raw", pattern02, 100)) return 1;
1046         if(!generate_fsd8("fsd8-03.raw", pattern03, 100)) return 1;
1047         if(!generate_fsd8("fsd8-04.raw", pattern04, 100)) return 1;
1048         if(!generate_fsd8("fsd8-05.raw", pattern05, 100)) return 1;
1049         if(!generate_fsd8("fsd8-06.raw", pattern06, 100)) return 1;
1050         if(!generate_fsd8("fsd8-07.raw", pattern07, 100)) return 1;
1051
1052         if(!generate_fsd16("fsd16-01.raw", pattern01, 100)) return 1;
1053         if(!generate_fsd16("fsd16-02.raw", pattern02, 100)) return 1;
1054         if(!generate_fsd16("fsd16-03.raw", pattern03, 100)) return 1;
1055         if(!generate_fsd16("fsd16-04.raw", pattern04, 100)) return 1;
1056         if(!generate_fsd16("fsd16-05.raw", pattern05, 100)) return 1;
1057         if(!generate_fsd16("fsd16-06.raw", pattern06, 100)) return 1;
1058         if(!generate_fsd16("fsd16-07.raw", pattern07, 100)) return 1;
1059
1060         if(!generate_fsd24("fsd24-01.raw", pattern01, 100)) return 1;
1061         if(!generate_fsd24("fsd24-02.raw", pattern02, 100)) return 1;
1062         if(!generate_fsd24("fsd24-03.raw", pattern03, 100)) return 1;
1063         if(!generate_fsd24("fsd24-04.raw", pattern04, 100)) return 1;
1064         if(!generate_fsd24("fsd24-05.raw", pattern05, 100)) return 1;
1065         if(!generate_fsd24("fsd24-06.raw", pattern06, 100)) return 1;
1066         if(!generate_fsd24("fsd24-07.raw", pattern07, 100)) return 1;
1067
1068         if(!generate_wbps16("wbps16-01.raw", 1000)) return 1;
1069
1070         if(!generate_sine8_1("sine8-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1071         if(!generate_sine8_1("sine8-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1072         if(!generate_sine8_1("sine8-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1073         if(!generate_sine8_1("sine8-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1074         if(!generate_sine8_1("sine8-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1075
1076         if(!generate_sine8_2("sine8-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1077         if(!generate_sine8_2("sine8-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1078         if(!generate_sine8_2("sine8-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1079         if(!generate_sine8_2("sine8-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1080         if(!generate_sine8_2("sine8-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1081         if(!generate_sine8_2("sine8-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1082         if(!generate_sine8_2("sine8-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1083         if(!generate_sine8_2("sine8-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1084         if(!generate_sine8_2("sine8-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1085         if(!generate_sine8_2("sine8-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1086
1087         if(!generate_sine16_1("sine16-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1088         if(!generate_sine16_1("sine16-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1089         if(!generate_sine16_1("sine16-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1090         if(!generate_sine16_1("sine16-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1091         if(!generate_sine16_1("sine16-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1092
1093         if(!generate_sine16_2("sine16-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1094         if(!generate_sine16_2("sine16-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1095         if(!generate_sine16_2("sine16-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1096         if(!generate_sine16_2("sine16-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1097         if(!generate_sine16_2("sine16-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1098         if(!generate_sine16_2("sine16-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1099         if(!generate_sine16_2("sine16-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1100         if(!generate_sine16_2("sine16-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1101         if(!generate_sine16_2("sine16-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1102         if(!generate_sine16_2("sine16-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1103
1104         if(!generate_sine24_1("sine24-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1105         if(!generate_sine24_1("sine24-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1106         if(!generate_sine24_1("sine24-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1107         if(!generate_sine24_1("sine24-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1108         if(!generate_sine24_1("sine24-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1109
1110         if(!generate_sine24_2("sine24-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1111         if(!generate_sine24_2("sine24-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1112         if(!generate_sine24_2("sine24-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1113         if(!generate_sine24_2("sine24-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1114         if(!generate_sine24_2("sine24-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1115         if(!generate_sine24_2("sine24-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1116         if(!generate_sine24_2("sine24-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1117         if(!generate_sine24_2("sine24-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1118         if(!generate_sine24_2("sine24-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1119         if(!generate_sine24_2("sine24-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1120
1121         /* WATCHOUT: the size of noise.raw is hardcoded into test/test_flac.sh */
1122         if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1;
1123         if(!generate_noise("noise8m32.raw", 32)) return 1;
1124         if(!generate_wackywavs()) return 1;
1125         if(!generate_wackywav64s()) return 1;
1126         if(!generate_wackyrf64s()) return 1;
1127         if(!generate_noisy_sine()) return 1;
1128         for(channels = 1; channels <= 8; channels *= 2) {
1129                 unsigned bits_per_sample;
1130                 for(bits_per_sample = 8; bits_per_sample <= 24; bits_per_sample += 4) {
1131                         static const unsigned nsamples[] = { 1, 111, 4777 } ;
1132                         unsigned samples;
1133                         for(samples = 0; samples < sizeof(nsamples)/sizeof(nsamples[0]); samples++) {
1134                                 char fn[64];
1135
1136                                 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.aiff", channels, bits_per_sample, nsamples[samples]);
1137                                 if(!generate_aiff(fn, 44100, channels, bits_per_sample, nsamples[samples]))
1138                                         return 1;
1139
1140                                 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.wav", channels, bits_per_sample, nsamples[samples]);
1141                                 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/0))
1142                                         return 1;
1143
1144                                 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.rf64", channels, bits_per_sample, nsamples[samples]);
1145                                 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/1))
1146                                         return 1;
1147
1148                                 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.w64", channels, bits_per_sample, nsamples[samples]);
1149                                 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/2))
1150                                         return 1;
1151
1152                                 if(bits_per_sample % 8 == 0) {
1153                                         flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.raw", channels, bits_per_sample, nsamples[samples]);
1154                                         if(!generate_raw(fn, channels, bits_per_sample/8, nsamples[samples]))
1155                                                 return 1;
1156                                 }
1157                         }
1158                 }
1159         }
1160
1161         return 0;
1162 }