add support for new 24-bit streams
[flac.git] / src / test_streams / main.c
1 /* test_streams - Simple test pattern generator
2  * Copyright (C) 2000,2001  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 #include <assert.h>
23 #include <sys/time.h>
24 #include "FLAC/ordinals.h"
25
26 #ifdef _WIN32
27         static const char *mode = "wb";
28 #else
29         static const char *mode = "w";
30 #endif
31
32 static bool is_big_endian_host;
33
34 static void swap16(int16 *i)
35 {
36         unsigned char *x = (unsigned char *)i, b;
37         if(!is_big_endian_host) {
38                 b = x[0];
39                 x[0] = x[1];
40                 x[1] = b;
41         }
42 }
43
44 static void swap24(byte *x)
45 {
46         if(is_big_endian_host) {
47                 x[0] = x[1];
48                 x[1] = x[2];
49                 x[2] = x[3];
50         }
51         else {
52                 byte b = x[0];
53                 x[0] = x[2];
54                 x[2] = b;
55         }
56 }
57
58 /* a mono one-sample 16bps stream */
59 static bool generate_01()
60 {
61         FILE *f;
62         int16 x = -32768;
63
64         if(0 == (f = fopen("test01.raw", mode)))
65                 return false;
66
67         swap16(&x);
68         if(fwrite(&x, sizeof(x), 1, f) < 1)
69                 goto foo;
70
71         fclose(f);
72         return true;
73 foo:
74         fclose(f);
75         return false;
76 }
77
78 /* a stereo one-sample 16bps stream */
79 static bool generate_02()
80 {
81         FILE *f;
82         int16 xl = -32768, xr = 32767;
83
84         if(0 == (f = fopen("test02.raw", mode)))
85                 return false;
86
87         swap16(&xl);
88         swap16(&xr);
89
90         if(fwrite(&xl, sizeof(xl), 1, f) < 1)
91                 goto foo;
92         if(fwrite(&xr, sizeof(xr), 1, f) < 1)
93                 goto foo;
94
95         fclose(f);
96         return true;
97 foo:
98         fclose(f);
99         return false;
100 }
101
102 /* a mono five-sample 16bps stream */
103 static bool generate_03()
104 {
105         FILE *f;
106         int16 x[] = { -25, 0, 25, 50, 100 };
107         unsigned i;
108
109         if(0 == (f = fopen("test03.raw", mode)))
110                 return false;
111
112         for(i = 0; i < 5; i++)
113                 swap16(x+i);
114
115         if(fwrite(&x, sizeof(int16), 5, f) < 5)
116                 goto foo;
117
118         fclose(f);
119         return true;
120 foo:
121         fclose(f);
122         return false;
123 }
124
125 /* a stereo five-sample 16bps stream */
126 static bool generate_04()
127 {
128         FILE *f;
129         int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
130         unsigned i;
131
132         if(0 == (f = fopen("test04.raw", mode)))
133                 return false;
134
135         for(i = 0; i < 10; i++)
136                 swap16(x+i);
137
138         if(fwrite(&x, sizeof(int16), 10, f) < 10)
139                 goto foo;
140
141         fclose(f);
142         return true;
143 foo:
144         fclose(f);
145         return false;
146 }
147
148 /* a mono full-scale deflection 8bps stream */
149 static bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
150 {
151         FILE *f;
152         unsigned rep, p;
153
154         assert(pattern != 0);
155
156         if(0 == (f = fopen(fn, mode)))
157                 return false;
158
159         for(rep = 0; rep < reps; rep++) {
160                 for(p = 0; pattern[p]; p++) {
161                         signed char x = pattern[p] > 0? 127 : -128;
162                         if(fwrite(&x, sizeof(x), 1, f) < 1)
163                                 goto foo;
164                 }
165         }
166
167         fclose(f);
168         return true;
169 foo:
170         fclose(f);
171         return false;
172 }
173
174 /* a mono full-scale deflection 16bps stream */
175 static bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
176 {
177         FILE *f;
178         unsigned rep, p;
179
180         assert(pattern != 0);
181
182         if(0 == (f = fopen(fn, mode)))
183                 return false;
184
185         for(rep = 0; rep < reps; rep++) {
186                 for(p = 0; pattern[p]; p++) {
187                         int16 x = pattern[p] > 0? 32767 : -32768;
188                         swap16(&x);
189                         if(fwrite(&x, sizeof(x), 1, f) < 1)
190                                 goto foo;
191                 }
192         }
193
194         fclose(f);
195         return true;
196 foo:
197         fclose(f);
198         return false;
199 }
200
201 /* a mono full-scale deflection 24bps stream */
202 static bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
203 {
204         FILE *f;
205         unsigned rep, p;
206
207         assert(pattern != 0);
208
209         if(0 == (f = fopen(fn, mode)))
210                 return false;
211
212         for(rep = 0; rep < reps; rep++) {
213                 for(p = 0; pattern[p]; p++) {
214                         int32 x = pattern[p] > 0? 8388607 : -8388608;
215                         byte *b = (byte*)(&x);
216                         swap24(b);
217                         if(fwrite(b, 3, 1, f) < 1)
218                                 goto foo;
219                 }
220         }
221
222         fclose(f);
223         return true;
224 foo:
225         fclose(f);
226         return false;
227 }
228
229 /* a mono sine-wave 16bps stream */
230 static 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)
231 {
232         const int16 full_scale = 32767;
233         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
234         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
235         FILE *f;
236         double theta1, theta2;
237         unsigned i;
238
239         if(0 == (f = fopen(fn, mode)))
240                 return false;
241
242         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
243                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
244                 int16 v = (int16)(val + 0.5);
245                 swap16(&v);
246                 if(fwrite(&v, sizeof(v), 1, f) < 1)
247                         goto foo;
248         }
249
250         fclose(f);
251         return true;
252 foo:
253         fclose(f);
254         return false;
255 }
256
257 /* a stereo sine-wave 16bps stream */
258 static 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)
259 {
260         const int16 full_scale = 32767;
261         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
262         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
263         FILE *f;
264         double theta1, theta2;
265         unsigned i;
266
267         if(0 == (f = fopen(fn, mode)))
268                 return false;
269
270         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
271                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
272                 int16 v = (int16)(val + 0.5);
273                 swap16(&v);
274                 if(fwrite(&v, sizeof(v), 1, f) < 1)
275                         goto foo;
276                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
277                 v = (int16)(val + 0.5);
278                 swap16(&v);
279                 if(fwrite(&v, sizeof(v), 1, f) < 1)
280                         goto foo;
281         }
282
283         fclose(f);
284         return true;
285 foo:
286         fclose(f);
287         return false;
288 }
289
290 /* a mono sine-wave 24bps stream */
291 static 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)
292 {
293         const int32 full_scale = 0x7fffff;
294         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
295         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
296         FILE *f;
297         double theta1, theta2;
298         unsigned i;
299
300         if(0 == (f = fopen(fn, mode)))
301                 return false;
302
303         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
304                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
305                 int32 v = (int32)(val + 0.5);
306                 byte *b = (byte*)(&v);
307                 swap24(b);
308                 if(fwrite(b, 3, 1, f) < 1)
309                         goto foo;
310         }
311
312         fclose(f);
313         return true;
314 foo:
315         fclose(f);
316         return false;
317 }
318
319 /* a stereo sine-wave 24bps stream */
320 static 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)
321 {
322         const int32 full_scale = 0x7fffff;
323         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
324         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
325         FILE *f;
326         double theta1, theta2;
327         unsigned i;
328
329         if(0 == (f = fopen(fn, mode)))
330                 return false;
331
332         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
333                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
334                 int32 v = (int32)(val + 0.5);
335                 byte *b = (byte*)(&v);
336                 swap24(b);
337                 if(fwrite(b, 3, 1, f) < 1)
338                         goto foo;
339                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
340                 v = (int32)(val + 0.5);
341                 swap24(b);
342                 if(fwrite(b, 3, 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 static bool generate_noise(const char *fn, unsigned bytes)
354 {
355         FILE *f;
356         struct timeval tv;
357         unsigned b;
358
359         if(gettimeofday(&tv, 0) < 0) {
360                 fprintf(stderr, "WARNING: couldn't seed RNG with time\n");
361                 tv.tv_usec = 4321;
362         }
363         srandom(tv.tv_usec);
364
365         if(0 == (f = fopen(fn, mode)))
366                 return false;
367
368         for(b = 0; b < bytes; b++) {
369                 byte x = (byte)(((unsigned)random()) & 0xff);
370                 if(fwrite(&x, sizeof(x), 1, f) < 1)
371                         goto foo;
372         }
373
374         fclose(f);
375         return true;
376 foo:
377         fclose(f);
378         return false;
379 }
380
381 int main(int argc, char *argv[])
382 {
383         uint32 test = 1;
384
385         int pattern01[] = { 1, -1, 0 };
386         int pattern02[] = { 1, 1, -1, 0 };
387         int pattern03[] = { 1, -1, -1, 0 };
388         int pattern04[] = { 1, -1, 1, -1, 0 };
389         int pattern05[] = { 1, -1, -1, 1, 0 };
390         int pattern06[] = { 1, -1, 1, 1, -1, 0 };
391         int pattern07[] = { 1, -1, -1, 1, -1, 0 };
392
393         (void)argc;
394         (void)argv;
395         is_big_endian_host = (*((byte*)(&test)))? false : true;
396
397         if(!generate_01()) return 1;
398         if(!generate_02()) return 1;
399         if(!generate_03()) return 1;
400         if(!generate_04()) return 1;
401
402         if(!generate_fsd8("fsd8-01.raw", pattern01, 100)) return 1;
403         if(!generate_fsd8("fsd8-02.raw", pattern02, 100)) return 1;
404         if(!generate_fsd8("fsd8-03.raw", pattern03, 100)) return 1;
405         if(!generate_fsd8("fsd8-04.raw", pattern04, 100)) return 1;
406         if(!generate_fsd8("fsd8-05.raw", pattern05, 100)) return 1;
407         if(!generate_fsd8("fsd8-06.raw", pattern06, 100)) return 1;
408         if(!generate_fsd8("fsd8-07.raw", pattern07, 100)) return 1;
409
410         if(!generate_fsd16("fsd16-01.raw", pattern01, 100)) return 1;
411         if(!generate_fsd16("fsd16-02.raw", pattern02, 100)) return 1;
412         if(!generate_fsd16("fsd16-03.raw", pattern03, 100)) return 1;
413         if(!generate_fsd16("fsd16-04.raw", pattern04, 100)) return 1;
414         if(!generate_fsd16("fsd16-05.raw", pattern05, 100)) return 1;
415         if(!generate_fsd16("fsd16-06.raw", pattern06, 100)) return 1;
416         if(!generate_fsd16("fsd16-07.raw", pattern07, 100)) return 1;
417
418         if(!generate_fsd24("fsd24-01.raw", pattern01, 100)) return 1;
419         if(!generate_fsd24("fsd24-02.raw", pattern02, 100)) return 1;
420         if(!generate_fsd24("fsd24-03.raw", pattern03, 100)) return 1;
421         if(!generate_fsd24("fsd24-04.raw", pattern04, 100)) return 1;
422         if(!generate_fsd24("fsd24-05.raw", pattern05, 100)) return 1;
423         if(!generate_fsd24("fsd24-06.raw", pattern06, 100)) return 1;
424         if(!generate_fsd24("fsd24-07.raw", pattern07, 100)) return 1;
425
426         if(!generate_sine16_1("sine16-00.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49)) return 1;
427         if(!generate_sine16_1("sine16-01.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37)) return 1;
428         if(!generate_sine16_1("sine16-02.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49)) return 1;
429         if(!generate_sine16_1("sine16-03.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49)) return 1;
430         if(!generate_sine16_1("sine16-04.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
431
432         if(!generate_sine16_2("sine16-10.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
433         if(!generate_sine16_2("sine16-11.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
434         if(!generate_sine16_2("sine16-12.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
435         if(!generate_sine16_2("sine16-13.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
436         if(!generate_sine16_2("sine16-14.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
437         if(!generate_sine16_2("sine16-15.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
438         if(!generate_sine16_2("sine16-16.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
439         if(!generate_sine16_2("sine16-17.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
440         if(!generate_sine16_2("sine16-18.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
441         if(!generate_sine16_2("sine16-19.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
442
443         if(!generate_sine24_1("sine24-00.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49)) return 1;
444         if(!generate_sine24_1("sine24-01.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37)) return 1;
445         if(!generate_sine24_1("sine24-02.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49)) return 1;
446         if(!generate_sine24_1("sine24-03.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49)) return 1;
447         if(!generate_sine24_1("sine24-04.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
448
449         if(!generate_sine24_2("sine24-10.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
450         if(!generate_sine24_2("sine24-11.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
451         if(!generate_sine24_2("sine24-12.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
452         if(!generate_sine24_2("sine24-13.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
453         if(!generate_sine24_2("sine24-14.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
454         if(!generate_sine24_2("sine24-15.raw", 44100.0, 80000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
455         if(!generate_sine24_2("sine24-16.raw", 44100.0, 80000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
456         if(!generate_sine24_2("sine24-17.raw", 44100.0, 80000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
457         if(!generate_sine24_2("sine24-18.raw", 44100.0, 80000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
458         if(!generate_sine24_2("sine24-19.raw", 44100.0, 50000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
459
460         if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1;
461
462         return 0;
463 }