1 /* test_streams - Simple test pattern generator
2 * Copyright (C) 2000-2009 Josh Coalson
3 * Copyright (C) 2011-2016 Xiph.Org Foundation
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.
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.
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.
27 #include "share/compat.h"
28 #if defined _MSC_VER || defined __MINGW32__
33 #include "FLAC/assert.h"
34 #include "FLAC/ordinals.h"
35 #include "share/compat.h"
37 #if !defined _MSC_VER && !defined __MINGW32__
38 #define GET_RANDOM_BYTE (((unsigned)random()) & 0xff)
40 #define GET_RANDOM_BYTE (((unsigned)rand()) & 0xff)
43 static FLAC__bool is_big_endian_host
;
46 static FLAC__bool
write_little_endian_unsigned(FILE *f
, FLAC__uint32 x
, size_t bytes
)
49 if(fputc(x
, f
) == EOF
)
57 static FLAC__bool
write_little_endian_signed(FILE *f
, FLAC__int32 x
, size_t bytes
)
59 return write_little_endian_unsigned(f
, (FLAC__uint32
) x
, bytes
);
62 static FLAC__bool
write_little_endian_uint16(FILE *f
, FLAC__uint16 x
)
66 fputc(x
>> 8, f
) != EOF
70 static FLAC__bool
write_little_endian_int16(FILE *f
, FLAC__int16 x
)
72 return write_little_endian_uint16(f
, (FLAC__uint16
)x
);
75 static FLAC__bool
write_little_endian_uint24(FILE *f
, FLAC__uint32 x
)
79 fputc(x
>> 8, f
) != EOF
&&
80 fputc(x
>> 16, f
) != EOF
84 static FLAC__bool
write_little_endian_int24(FILE *f
, FLAC__int32 x
)
86 return write_little_endian_uint24(f
, (FLAC__uint32
)x
);
89 static FLAC__bool
write_little_endian_uint32(FILE *f
, FLAC__uint32 x
)
93 fputc(x
>> 8, f
) != EOF
&&
94 fputc(x
>> 16, f
) != EOF
&&
95 fputc(x
>> 24, f
) != EOF
100 /* @@@ not used (yet) */
101 static FLAC__bool
write_little_endian_int32(FILE *f
, FLAC__int32 x
)
103 return write_little_endian_uint32(f
, (FLAC__uint32
)x
);
107 static FLAC__bool
write_little_endian_uint64(FILE *f
, FLAC__uint64 x
)
110 fputc(x
, f
) != EOF
&&
111 fputc(x
>> 8, f
) != EOF
&&
112 fputc(x
>> 16, f
) != EOF
&&
113 fputc(x
>> 24, f
) != EOF
&&
114 fputc(x
>> 32, f
) != EOF
&&
115 fputc(x
>> 40, f
) != EOF
&&
116 fputc(x
>> 48, f
) != EOF
&&
117 fputc(x
>> 56, f
) != EOF
121 static FLAC__bool
write_big_endian(FILE *f
, FLAC__int32 x
, size_t bytes
)
126 if(fputc(x
>>24, f
) == EOF
)
134 static FLAC__bool
write_big_endian_uint16(FILE *f
, FLAC__uint16 x
)
137 fputc(x
>> 8, f
) != EOF
&&
143 /* @@@ not used (yet) */
144 static FLAC__bool
write_big_endian_int16(FILE *f
, FLAC__int16 x
)
146 return write_big_endian_uint16(f
, (FLAC__uint16
)x
);
151 /* @@@ not used (yet) */
152 static FLAC__bool
write_big_endian_uint24(FILE *f
, FLAC__uint32 x
)
155 fputc(x
>> 16, f
) != EOF
&&
156 fputc(x
>> 8, f
) != EOF
&&
163 /* @@@ not used (yet) */
164 static FLAC__bool
write_big_endian_int24(FILE *f
, FLAC__int32 x
)
166 return write_big_endian_uint24(f
, (FLAC__uint32
)x
);
170 static FLAC__bool
write_big_endian_uint32(FILE *f
, FLAC__uint32 x
)
173 fputc(x
>> 24, f
) != EOF
&&
174 fputc(x
>> 16, f
) != EOF
&&
175 fputc(x
>> 8, f
) != EOF
&&
181 /* @@@ not used (yet) */
182 static FLAC__bool
write_big_endian_int32(FILE *f
, FLAC__int32 x
)
184 return write_big_endian_uint32(f
, (FLAC__uint32
)x
);
188 static FLAC__bool
write_sane_extended(FILE *f
, unsigned val
)
189 /* Write to 'f' a SANE extended representation of 'val'. Return false if
190 * the write succeeds; return true otherwise.
192 * SANE extended is an 80-bit IEEE-754 representation with sign bit, 15 bits
193 * of exponent, and 64 bits of significand (mantissa). Unlike most IEEE-754
194 * representations, it does not imply a 1 above the MSB of the significand.
200 unsigned int shift
, exponent
;
202 FLAC__ASSERT(val
!=0U); /* handling 0 would require a special case */
204 for(shift
= 0U; (val
>>(31-shift
))==0U; ++shift
)
207 exponent
= 63U-(shift
+32U); /* add 32 for unused second word */
209 if(!write_big_endian_uint16(f
, (FLAC__uint16
)(exponent
+0x3FFF)))
211 if(!write_big_endian_uint32(f
, val
))
213 if(!write_big_endian_uint32(f
, 0)) /* unused second word */
219 /* a mono one-sample 16bps stream */
220 static FLAC__bool
generate_01(void)
223 FLAC__int16 x
= -32768;
225 if(0 == (f
= fopen("test01.raw", "wb")))
228 if(!write_little_endian_int16(f
, x
))
238 /* a stereo one-sample 16bps stream */
239 static FLAC__bool
generate_02(void)
242 FLAC__int16 xl
= -32768, xr
= 32767;
244 if(0 == (f
= fopen("test02.raw", "wb")))
247 if(!write_little_endian_int16(f
, xl
))
249 if(!write_little_endian_int16(f
, xr
))
259 /* a mono five-sample 16bps stream */
260 static FLAC__bool
generate_03(void)
263 FLAC__int16 x
[] = { -25, 0, 25, 50, 100 };
266 if(0 == (f
= fopen("test03.raw", "wb")))
269 for(i
= 0; i
< 5; i
++)
270 if(!write_little_endian_int16(f
, x
[i
]))
280 /* a stereo five-sample 16bps stream */
281 static FLAC__bool
generate_04(void)
284 FLAC__int16 x
[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
287 if(0 == (f
= fopen("test04.raw", "wb")))
290 for(i
= 0; i
< 10; i
++)
291 if(!write_little_endian_int16(f
, x
[i
]))
301 /* a mono full-scale deflection 8bps stream */
302 static FLAC__bool
generate_fsd8(const char *fn
, const int pattern
[], unsigned reps
)
307 FLAC__ASSERT(pattern
!= 0);
309 if(0 == (f
= fopen(fn
, "wb")))
312 for(rep
= 0; rep
< reps
; rep
++) {
313 for(p
= 0; pattern
[p
]; p
++) {
314 signed char x
= pattern
[p
] > 0? 127 : -128;
315 if(fwrite(&x
, sizeof(x
), 1, f
) < 1)
327 /* a mono full-scale deflection 16bps stream */
328 static FLAC__bool
generate_fsd16(const char *fn
, const int pattern
[], unsigned reps
)
333 FLAC__ASSERT(pattern
!= 0);
335 if(0 == (f
= fopen(fn
, "wb")))
338 for(rep
= 0; rep
< reps
; rep
++) {
339 for(p
= 0; pattern
[p
]; p
++) {
340 FLAC__int16 x
= pattern
[p
] > 0? 32767 : -32768;
341 if(!write_little_endian_int16(f
, x
))
353 /* a stereo wasted-bits-per-sample 16bps stream */
354 static FLAC__bool
generate_wbps16(const char *fn
, unsigned samples
)
359 if(0 == (f
= fopen(fn
, "wb")))
362 for(sample
= 0; sample
< samples
; sample
++) {
363 FLAC__int16 l
= (sample
% 2000) << 2;
364 FLAC__int16 r
= (sample
% 1000) << 3;
365 if(!write_little_endian_int16(f
, l
))
367 if(!write_little_endian_int16(f
, r
))
378 /* a mono full-scale deflection 24bps stream */
379 static FLAC__bool
generate_fsd24(const char *fn
, const int pattern
[], unsigned reps
)
384 FLAC__ASSERT(pattern
!= 0);
386 if(0 == (f
= fopen(fn
, "wb")))
389 for(rep
= 0; rep
< reps
; rep
++) {
390 for(p
= 0; pattern
[p
]; p
++) {
391 FLAC__int32 x
= pattern
[p
] > 0? 8388607 : -8388608;
392 if(!write_little_endian_int24(f
, x
))
404 /* a mono sine-wave 8bps stream */
405 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
)
407 const FLAC__int8 full_scale
= 127;
408 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
409 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
411 double theta1
, theta2
;
414 if(0 == (f
= fopen(fn
, "wb")))
417 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
418 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
419 FLAC__int8 v
= (FLAC__int8
)(val
+ 0.5);
420 if(fwrite(&v
, sizeof(v
), 1, f
) < 1)
431 /* a stereo sine-wave 8bps stream */
432 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
)
434 const FLAC__int8 full_scale
= 127;
435 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
436 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
438 double theta1
, theta2
;
441 if(0 == (f
= fopen(fn
, "wb")))
444 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
445 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
446 FLAC__int8 v
= (FLAC__int8
)(val
+ 0.5);
447 if(fwrite(&v
, sizeof(v
), 1, f
) < 1)
449 val
= -(a1
*sin(theta1
*fmult
) + a2
*sin(theta2
*fmult
))*(double)full_scale
;
450 v
= (FLAC__int8
)(val
+ 0.5);
451 if(fwrite(&v
, sizeof(v
), 1, f
) < 1)
462 /* a mono sine-wave 16bps stream */
463 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
)
465 const FLAC__int16 full_scale
= 32767;
466 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
467 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
469 double theta1
, theta2
;
472 if(0 == (f
= fopen(fn
, "wb")))
475 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
476 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
477 FLAC__int16 v
= (FLAC__int16
)(val
+ 0.5);
478 if(!write_little_endian_int16(f
, v
))
489 /* a stereo sine-wave 16bps stream */
490 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
)
492 const FLAC__int16 full_scale
= 32767;
493 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
494 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
496 double theta1
, theta2
;
499 if(0 == (f
= fopen(fn
, "wb")))
502 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
503 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
504 FLAC__int16 v
= (FLAC__int16
)(val
+ 0.5);
505 if(!write_little_endian_int16(f
, v
))
507 val
= -(a1
*sin(theta1
*fmult
) + a2
*sin(theta2
*fmult
))*(double)full_scale
;
508 v
= (FLAC__int16
)(val
+ 0.5);
509 if(!write_little_endian_int16(f
, v
))
520 /* a mono sine-wave 24bps stream */
521 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
)
523 const FLAC__int32 full_scale
= 0x7fffff;
524 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
525 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
527 double theta1
, theta2
;
530 if(0 == (f
= fopen(fn
, "wb")))
533 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
534 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
535 FLAC__int32 v
= (FLAC__int32
)(val
+ 0.5);
536 if(!write_little_endian_int24(f
, v
))
547 /* a stereo sine-wave 24bps stream */
548 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
)
550 const FLAC__int32 full_scale
= 0x7fffff;
551 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
552 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
554 double theta1
, theta2
;
557 if(0 == (f
= fopen(fn
, "wb")))
560 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
561 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
562 FLAC__int32 v
= (FLAC__int32
)(val
+ 0.5);
563 if(!write_little_endian_int24(f
, v
))
565 val
= -(a1
*sin(theta1
*fmult
) + a2
*sin(theta2
*fmult
))*(double)full_scale
;
566 v
= (FLAC__int32
)(val
+ 0.5);
567 if(!write_little_endian_int24(f
, v
))
578 static FLAC__bool
generate_noise(const char *fn
, unsigned bytes
)
583 if(0 == (f
= fopen(fn
, "wb")))
586 for(b
= 0; b
< bytes
; b
++) {
587 #if !defined _MSC_VER && !defined __MINGW32__
588 FLAC__byte x
= (FLAC__byte
)(((unsigned)random()) & 0xff);
590 FLAC__byte x
= (FLAC__byte
)(((unsigned)rand()) & 0xff);
592 if(fwrite(&x
, sizeof(x
), 1, f
) < 1)
603 static FLAC__bool
generate_signed_raw(const char *filename
, unsigned channels
, unsigned bytes_per_sample
, unsigned samples
)
605 const FLAC__int32 full_scale
= (1 << (bytes_per_sample
*8-1)) - 1;
606 const double f1
= 441.0, a1
= 0.61, f2
= 661.5, a2
= 0.37;
607 const double delta1
= 2.0 * M_PI
/ ( 44100.0 / f1
);
608 const double delta2
= 2.0 * M_PI
/ ( 44100.0 / f2
);
609 double theta1
, theta2
;
613 if(0 == (f
= fopen(filename
, "wb")))
616 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
617 for(j
= 0; j
< channels
; j
++) {
618 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
619 FLAC__int32 v
= (FLAC__int32
)(val
+ 0.5) + ((GET_RANDOM_BYTE
>>4)-8);
620 if(!write_little_endian_signed(f
, v
, bytes_per_sample
))
632 static FLAC__bool
generate_unsigned_raw(const char *filename
, unsigned channels
, unsigned bytes_per_sample
, unsigned samples
)
634 const FLAC__int32 full_scale
= (1 << (bytes_per_sample
*8-1)) - 1;
635 const double f1
= 441.0, a1
= 0.61, f2
= 661.5, a2
= 0.37;
636 const double delta1
= 2.0 * M_PI
/ ( 44100.0 / f1
);
637 const double delta2
= 2.0 * M_PI
/ ( 44100.0 / f2
);
638 const double half_scale
= 0.5 * full_scale
;
639 double theta1
, theta2
;
643 if(0 == (f
= fopen(filename
, "wb")))
646 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
647 for(j
= 0; j
< channels
; j
++) {
648 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
649 FLAC__int32 v
= (FLAC__int32
)(half_scale
+ val
+ 0.5) + ((GET_RANDOM_BYTE
>>4)-8);
650 if(!write_little_endian_unsigned(f
, v
, bytes_per_sample
))
662 static FLAC__bool
generate_aiff(const char *filename
, unsigned sample_rate
, unsigned channels
, unsigned bps
, unsigned samples
)
664 const unsigned bytes_per_sample
= (bps
+7)/8;
665 const unsigned true_size
= channels
* bytes_per_sample
* samples
;
666 const unsigned padded_size
= (true_size
+ 1) & (~1u);
667 const unsigned shift
= (bps
%8)? 8 - (bps
%8) : 0;
668 const FLAC__int32 full_scale
= (1 << (bps
-1)) - 1;
669 const double f1
= 441.0, a1
= 0.61, f2
= 661.5, a2
= 0.37;
670 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
671 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
672 double theta1
, theta2
;
676 if(0 == (f
= fopen(filename
, "wb")))
678 if(fwrite("FORM", 1, 4, f
) < 4)
680 if(!write_big_endian_uint32(f
, padded_size
+ 46))
682 if(fwrite("AIFFCOMM\000\000\000\022", 1, 12, f
) < 12)
684 if(!write_big_endian_uint16(f
, (FLAC__uint16
)channels
))
686 if(!write_big_endian_uint32(f
, samples
))
688 if(!write_big_endian_uint16(f
, (FLAC__uint16
)bps
))
690 if(!write_sane_extended(f
, sample_rate
))
692 if(fwrite("SSND", 1, 4, f
) < 4)
694 if(!write_big_endian_uint32(f
, true_size
+ 8))
696 if(fwrite("\000\000\000\000\000\000\000\000", 1, 8, f
) < 8)
699 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
700 for(j
= 0; j
< channels
; j
++) {
701 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
702 FLAC__int32 v
= ((FLAC__int32
)(val
+ 0.5) + ((GET_RANDOM_BYTE
>>4)-8)) << shift
;
703 if(!write_big_endian(f
, v
, bytes_per_sample
))
707 for(i
= true_size
; i
< padded_size
; i
++)
708 if(fputc(0, f
) == EOF
)
718 /* flavor is: 0:WAVE, 1:RF64, 2:WAVE64 */
719 static FLAC__bool
generate_wav(const char *filename
, unsigned sample_rate
, unsigned channels
, unsigned bps
, unsigned samples
, FLAC__bool strict
, int flavor
)
721 const FLAC__bool waveformatextensible
= strict
&& (channels
> 2 || (bps
!= 8 && bps
!= 16));
723 const unsigned bytes_per_sample
= (bps
+7)/8;
724 const unsigned shift
= (bps
%8)? 8 - (bps
%8) : 0;
725 /* this rig is not going over 4G so we're ok with 32-bit sizes here */
726 const FLAC__uint32 true_size
= channels
* bytes_per_sample
* samples
;
727 const FLAC__uint32 padded_size
= flavor
<2? (true_size
+ 1) & (~1u) : (true_size
+ 7) & (~7u);
728 const FLAC__int32 full_scale
= (1 << (bps
-1)) - 1;
729 const double f1
= 441.0, a1
= 0.61, f2
= 661.5, a2
= 0.37;
730 const double delta1
= 2.0 * M_PI
/ ( sample_rate
/ f1
);
731 const double delta2
= 2.0 * M_PI
/ ( sample_rate
/ f2
);
732 double theta1
, theta2
;
736 if(0 == (f
= fopen(filename
, "wb")))
738 /* RIFFxxxxWAVE or equivalent: */
741 if(fwrite("RIFF", 1, 4, f
) < 4)
744 /* +8+{40,16} for fmt chunk */
745 /* +8 for data chunk header */
746 if(!write_little_endian_uint32(f
, 4 + 8+(waveformatextensible
?40:16) + 8 + padded_size
))
748 if(fwrite("WAVE", 1, 4, f
) < 4)
752 if(fwrite("RF64", 1, 4, f
) < 4)
754 if(!write_little_endian_uint32(f
, 0xffffffff))
756 if(fwrite("WAVE", 1, 4, f
) < 4)
760 /* RIFF GUID 66666972-912E-11CF-A5D6-28DB04C10000 */
761 if(fwrite("\x72\x69\x66\x66\x2E\x91\xCF\x11\xA5\xD6\x28\xDB\x04\xC1\x00\x00", 1, 16, f
) < 16)
763 /* +(16+8) for RIFF GUID + size */
764 /* +16 for WAVE GUID */
765 /* +16+8+{40,16} for fmt chunk */
766 /* +16+8 for data chunk header */
767 if(!write_little_endian_uint64(f
, (16+8) + 16 + 16+8+(waveformatextensible
?40:16) + (16+8) + padded_size
))
769 /* WAVE GUID 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
770 if(fwrite("\x77\x61\x76\x65\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f
) < 16)
776 if(flavor
== 1) { /* rf64 */
777 if(fwrite("ds64", 1, 4, f
) < 4)
779 if(!write_little_endian_uint32(f
, 28)) /* ds64 chunk size */
781 if(!write_little_endian_uint64(f
, 36 + padded_size
+ (waveformatextensible
?60:36)))
783 if(!write_little_endian_uint64(f
, true_size
))
785 if(!write_little_endian_uint64(f
, samples
))
787 if(!write_little_endian_uint32(f
, 0)) /* table size */
792 if(fwrite("fmt ", 1, 4, f
) < 4)
795 if(!write_little_endian_uint32(f
, waveformatextensible
?40:16))
799 /* fmt GUID 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
800 if(fwrite("\x66\x6D\x74\x20\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f
) < 16)
802 /* chunk size (+16+8 for GUID and size fields) */
803 if(!write_little_endian_uint64(f
, 16+8+(waveformatextensible
?40:16)))
806 if(!write_little_endian_uint16(f
, (FLAC__uint16
)(waveformatextensible
?65534:1)))
808 if(!write_little_endian_uint16(f
, (FLAC__uint16
)channels
))
810 if(!write_little_endian_uint32(f
, sample_rate
))
812 if(!write_little_endian_uint32(f
, sample_rate
* channels
* bytes_per_sample
))
814 if(!write_little_endian_uint16(f
, (FLAC__uint16
)(channels
* bytes_per_sample
))) /* block align */
816 if(!write_little_endian_uint16(f
, (FLAC__uint16
)(bps
+shift
)))
818 if(waveformatextensible
) {
819 if(!write_little_endian_uint16(f
, (FLAC__uint16
)22)) /* cbSize */
821 if(!write_little_endian_uint16(f
, (FLAC__uint16
)bps
)) /* validBitsPerSample */
823 if(!write_little_endian_uint32(f
, 0)) /* channelMask */
825 /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */
826 if(fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f
) != 16)
831 if(fwrite("data", 1, 4, f
) < 4)
833 if(!write_little_endian_uint32(f
, flavor
==1? 0xffffffff : true_size
))
837 /* data GUID 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
838 if(fwrite("\x64\x61\x74\x61\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f
) != 16)
840 /* +16+8 for GUID and size fields */
841 if(!write_little_endian_uint64(f
, 16+8 + true_size
))
845 for(i
= 0, theta1
= theta2
= 0.0; i
< samples
; i
++, theta1
+= delta1
, theta2
+= delta2
) {
846 for(j
= 0; j
< channels
; j
++) {
847 double val
= (a1
*sin(theta1
) + a2
*sin(theta2
))*(double)full_scale
;
848 FLAC__int32 v
= ((FLAC__int32
)(val
+ 0.5) + ((GET_RANDOM_BYTE
>>4)-8)) << shift
;
849 if(!write_little_endian_signed(f
, v
, bytes_per_sample
))
853 for(i
= true_size
; i
< padded_size
; i
++)
854 if(fputc(0, f
) == EOF
)
864 static FLAC__bool
generate_wackywavs(void)
868 'R', 'I', 'F', 'F', 76, 0, 0, 0,
869 'W', 'A', 'V', 'E', 'j', 'u', 'n', 'k',
870 4, 0, 0, 0 , 'b', 'l', 'a', 'h',
871 'p', 'a', 'd', ' ', 4, 0, 0, 0,
872 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
873 16, 0, 0, 0, 1, 0, 1, 0,
874 0x44,0xAC, 0, 0,0x88,0x58,0x01, 0,
875 2, 0, 16, 0, 'd', 'a', 't', 'a',
876 16, 0, 0, 0, 0, 0, 1, 0,
877 4, 0, 9, 0, 16, 0, 25, 0,
878 36, 0, 49, 0, 'p', 'a', 'd', ' ',
879 4, 0, 0, 0, 'b', 'l', 'a', 'h'
882 if(0 == (f
= fopen("wacky1.wav", "wb")))
884 if(fwrite(wav
, 1, 84, f
) < 84)
889 if(0 == (f
= fopen("wacky2.wav", "wb")))
891 if(fwrite(wav
, 1, 96, f
) < 96)
901 static FLAC__bool
write_simple_wavex_header (FILE * f
, unsigned samplerate
, unsigned channels
, unsigned bytespersample
, unsigned frames
)
903 unsigned datalen
= channels
* bytespersample
* frames
;
905 if (fwrite("RIFF", 1, 4, f
) != 4)
907 if (!write_little_endian_uint32(f
, 40 + 4 + 4 + datalen
))
910 if (fwrite("WAVEfmt ", 8, 1, f
) != 1)
912 if (!write_little_endian_uint32(f
, 40))
915 if(!write_little_endian_uint16(f
, 65534)) /* WAVEFORMATEXTENSIBLE tag */
917 if(!write_little_endian_uint16(f
, channels
))
919 if(!write_little_endian_uint32(f
, samplerate
))
921 if(!write_little_endian_uint32(f
, samplerate
* channels
* bytespersample
))
923 if(!write_little_endian_uint16(f
, channels
* bytespersample
)) /* block align */
925 if(!write_little_endian_uint16(f
, bytespersample
* 8))
928 if(!write_little_endian_uint16(f
, 22)) /* cbSize */
930 if(!write_little_endian_uint16(f
, bytespersample
* 8)) /* validBitsPerSample */
932 if(!write_little_endian_uint32(f
, 0)) /* channelMask */
934 /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */
935 if(fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f
) != 16)
938 if (fwrite("data", 1, 4, f
) != 4)
940 if (!write_little_endian_uint32(f
, datalen
))
946 static FLAC__bool
generate_noisy_sine(void)
949 int64_t randstate
= 0x1243456;
950 double sample
, last_val
= 0.0;
953 if(0 == (f
= fopen("noisy-sine.wav", "wb")))
956 if(!write_simple_wavex_header (f
, 44100, 1, 2, 220500))
959 for (k
= 0 ; k
< 5 * 44100 ; k
++) {
960 /* Obvioulsy not a crypto quality RNG. */
961 randstate
= 11117 * randstate
+ 211231;
962 randstate
= 11117 * randstate
+ 211231;
963 randstate
= 11117 * randstate
+ 211231;
965 sample
= ((int32_t) randstate
) / (0x7fffffff * 1.000001);
966 sample
= 0.2 * sample
- 0.9 * last_val
;
970 sample
+= sin (2.0 * k
* M_PI
* 1.0 / 32.0);
972 #if !defined _MSC_VER
973 write_little_endian_int16(f
, lrintf(sample
* 32700.0));
975 write_little_endian_int16(f
, (FLAC__int16
)(sample
* 32700.0));
987 static FLAC__bool
generate_wackywav64s(void)
991 0x72,0x69,0x66,0x66,0x2E,0x91,0xCF,0x11, /* RIFF GUID */
992 0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00,
993 152, 0, 0, 0, 0, 0, 0, 0,
994 0x77,0x61,0x76,0x65,0xF3,0xAC,0xD3,0x11, /* WAVE GUID */
995 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
996 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */
997 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
998 32, 0, 0, 0 , 0, 0, 0, 0,
999 'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h',
1000 0x66,0x6D,0x74,0x20,0xF3,0xAC,0xD3,0x11, /* fmt GUID */
1001 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
1002 40, 0, 0, 0 , 0, 0, 0, 0,
1003 1, 0, 1, 0,0x44,0xAC, 0, 0,
1004 0x88,0x58,0x01, 0, 2, 0, 16, 0,
1005 0x64,0x61,0x74,0x61,0xF3,0xAC,0xD3,0x11, /* data GUID */
1006 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
1007 40, 0, 0, 0 , 0, 0, 0, 0,
1008 0, 0, 1, 0, 4, 0, 9, 0,
1009 16, 0, 25, 0, 36, 0, 49, 0,
1010 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */
1011 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A,
1012 32, 0, 0, 0 , 0, 0, 0, 0,
1013 'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h'
1016 if(0 == (f
= fopen("wacky1.w64", "wb")))
1018 if(fwrite(wav
, 1, wav
[16], f
) < wav
[16])
1023 if(0 == (f
= fopen("wacky2.w64", "wb")))
1025 if(fwrite(wav
, 1, wav
[16], f
) < wav
[16])
1035 static FLAC__bool
generate_wackyrf64s(void)
1038 FLAC__byte wav
[] = {
1039 'R', 'F', '6', '4', 255, 255, 255, 255,
1040 'W', 'A', 'V', 'E', 'd', 's', '6', '4',
1041 28, 0, 0, 0, 112, 0, 0, 0,
1042 0, 0, 0, 0, 16, 0, 0, 0,
1043 0, 0, 0, 0, 8, 0, 0, 0,
1044 0, 0, 0, 0, 0, 0, 0, 0,
1046 4, 0, 0, 0, 'b', 'l', 'a', 'h',
1047 'p', 'a', 'd', ' ', 4, 0, 0, 0,
1048 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
1049 16, 0, 0, 0, 1, 0, 1, 0,
1050 0x44,0xAC, 0, 0,0x88,0x58,0x01, 0,
1051 2, 0, 16, 0, 'd', 'a', 't', 'a',
1052 255, 255, 255, 255, 0, 0, 1, 0,
1053 4, 0, 9, 0, 16, 0, 25, 0,
1054 36, 0, 49, 0, 'p', 'a', 'd', ' ',
1055 4, 0, 0, 0, 'b', 'l', 'a', 'h'
1058 if(0 == (f
= fopen("wacky1.rf64", "wb")))
1060 if(fwrite(wav
, 1, 120, f
) < 120)
1065 if(0 == (f
= fopen("wacky2.rf64", "wb")))
1067 if(fwrite(wav
, 1, 132, f
) < 132)
1077 static FLAC__bool
generate_replaygain_tone (unsigned samplerate
)
1081 double tone
, sample
, samplerange
;
1084 flac_snprintf(fname
, sizeof(fname
), "rpg-tone-%u.wav", samplerate
);
1086 if(0 == (f
= fopen(fname
, "wb")))
1089 if(!write_simple_wavex_header (f
, samplerate
, 1, 3, 220500))
1093 samplerange
= 0x7fffff; /* Largest sample value allowed for a 24 bit PCM file. */
1094 tone
= 1000.0; /* 1 kHz */
1096 for (k
= 0 ; k
< 5 * 44100 ; k
++) {
1097 sample
= sin(2 * M_PI
* tone
* k
/ samplerate
);
1098 sample
*= samplerange
;
1099 if (!write_little_endian_uint24(f
, (FLAC__int32
) sample
))
1111 int main(int argc
, char *argv
[])
1113 FLAC__uint32 test
= 1;
1116 int pattern01
[] = { 1, -1, 0 };
1117 int pattern02
[] = { 1, 1, -1, 0 };
1118 int pattern03
[] = { 1, -1, -1, 0 };
1119 int pattern04
[] = { 1, -1, 1, -1, 0 };
1120 int pattern05
[] = { 1, -1, -1, 1, 0 };
1121 int pattern06
[] = { 1, -1, 1, 1, -1, 0 };
1122 int pattern07
[] = { 1, -1, -1, 1, -1, 0 };
1126 is_big_endian_host
= (*((FLAC__byte
*)(&test
)))? false : true;
1128 #if !defined _MSC_VER && !defined __MINGW32__
1132 if(gettimeofday(&tv
, 0) < 0) {
1133 fprintf(stderr
, "WARNING: couldn't seed RNG with time\n");
1136 srandom(tv
.tv_usec
);
1139 srand((unsigned)time(0));
1142 if(!generate_01()) return 1;
1143 if(!generate_02()) return 1;
1144 if(!generate_03()) return 1;
1145 if(!generate_04()) return 1;
1147 if(!generate_fsd8("fsd8-01.raw", pattern01
, 100)) return 1;
1148 if(!generate_fsd8("fsd8-02.raw", pattern02
, 100)) return 1;
1149 if(!generate_fsd8("fsd8-03.raw", pattern03
, 100)) return 1;
1150 if(!generate_fsd8("fsd8-04.raw", pattern04
, 100)) return 1;
1151 if(!generate_fsd8("fsd8-05.raw", pattern05
, 100)) return 1;
1152 if(!generate_fsd8("fsd8-06.raw", pattern06
, 100)) return 1;
1153 if(!generate_fsd8("fsd8-07.raw", pattern07
, 100)) return 1;
1155 if(!generate_fsd16("fsd16-01.raw", pattern01
, 100)) return 1;
1156 if(!generate_fsd16("fsd16-02.raw", pattern02
, 100)) return 1;
1157 if(!generate_fsd16("fsd16-03.raw", pattern03
, 100)) return 1;
1158 if(!generate_fsd16("fsd16-04.raw", pattern04
, 100)) return 1;
1159 if(!generate_fsd16("fsd16-05.raw", pattern05
, 100)) return 1;
1160 if(!generate_fsd16("fsd16-06.raw", pattern06
, 100)) return 1;
1161 if(!generate_fsd16("fsd16-07.raw", pattern07
, 100)) return 1;
1163 if(!generate_fsd24("fsd24-01.raw", pattern01
, 100)) return 1;
1164 if(!generate_fsd24("fsd24-02.raw", pattern02
, 100)) return 1;
1165 if(!generate_fsd24("fsd24-03.raw", pattern03
, 100)) return 1;
1166 if(!generate_fsd24("fsd24-04.raw", pattern04
, 100)) return 1;
1167 if(!generate_fsd24("fsd24-05.raw", pattern05
, 100)) return 1;
1168 if(!generate_fsd24("fsd24-06.raw", pattern06
, 100)) return 1;
1169 if(!generate_fsd24("fsd24-07.raw", pattern07
, 100)) return 1;
1171 if(!generate_wbps16("wbps16-01.raw", 1000)) return 1;
1173 if(!generate_sine8_1("sine8-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1174 if(!generate_sine8_1("sine8-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1175 if(!generate_sine8_1("sine8-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1176 if(!generate_sine8_1("sine8-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1177 if(!generate_sine8_1("sine8-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1179 if(!generate_sine8_2("sine8-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1180 if(!generate_sine8_2("sine8-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1181 if(!generate_sine8_2("sine8-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1182 if(!generate_sine8_2("sine8-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1183 if(!generate_sine8_2("sine8-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1184 if(!generate_sine8_2("sine8-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1185 if(!generate_sine8_2("sine8-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1186 if(!generate_sine8_2("sine8-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1187 if(!generate_sine8_2("sine8-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1188 if(!generate_sine8_2("sine8-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1190 if(!generate_sine16_1("sine16-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1191 if(!generate_sine16_1("sine16-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1192 if(!generate_sine16_1("sine16-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1193 if(!generate_sine16_1("sine16-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1194 if(!generate_sine16_1("sine16-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1196 if(!generate_sine16_2("sine16-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1197 if(!generate_sine16_2("sine16-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1198 if(!generate_sine16_2("sine16-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1199 if(!generate_sine16_2("sine16-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1200 if(!generate_sine16_2("sine16-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1201 if(!generate_sine16_2("sine16-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1202 if(!generate_sine16_2("sine16-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1203 if(!generate_sine16_2("sine16-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1204 if(!generate_sine16_2("sine16-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1205 if(!generate_sine16_2("sine16-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1207 if(!generate_sine24_1("sine24-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
1208 if(!generate_sine24_1("sine24-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
1209 if(!generate_sine24_1("sine24-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
1210 if(!generate_sine24_1("sine24-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
1211 if(!generate_sine24_1("sine24-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
1213 if(!generate_sine24_2("sine24-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
1214 if(!generate_sine24_2("sine24-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
1215 if(!generate_sine24_2("sine24-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
1216 if(!generate_sine24_2("sine24-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
1217 if(!generate_sine24_2("sine24-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
1218 if(!generate_sine24_2("sine24-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
1219 if(!generate_sine24_2("sine24-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
1220 if(!generate_sine24_2("sine24-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
1221 if(!generate_sine24_2("sine24-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
1222 if(!generate_sine24_2("sine24-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
1224 if(!generate_replaygain_tone(8000)) return 1;
1225 if(!generate_replaygain_tone(11025)) return 1;
1226 if(!generate_replaygain_tone(12000)) return 1;
1227 if(!generate_replaygain_tone(16000)) return 1;
1228 if(!generate_replaygain_tone(18900)) return 1;
1229 if(!generate_replaygain_tone(22050)) return 1;
1230 if(!generate_replaygain_tone(24000)) return 1;
1231 if(!generate_replaygain_tone(28000)) return 1;
1232 if(!generate_replaygain_tone(32000)) return 1;
1233 if(!generate_replaygain_tone(36000)) return 1;
1234 if(!generate_replaygain_tone(37800)) return 1;
1235 if(!generate_replaygain_tone(44100)) return 1;
1236 if(!generate_replaygain_tone(48000)) return 1;
1237 if(!generate_replaygain_tone(96000)) return 1;
1238 if(!generate_replaygain_tone(192000)) return 1;
1240 /* WATCHOUT: the size of noise.raw is hardcoded into test/test_flac.sh */
1241 if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1;
1242 if(!generate_noise("noise8m32.raw", 32)) return 1;
1243 if(!generate_wackywavs()) return 1;
1244 if(!generate_wackywav64s()) return 1;
1245 if(!generate_wackyrf64s()) return 1;
1246 if(!generate_noisy_sine()) return 1;
1247 for(channels
= 1; channels
<= 8; channels
*= 2) {
1248 unsigned bits_per_sample
;
1249 for(bits_per_sample
= 8; bits_per_sample
<= 24; bits_per_sample
+= 4) {
1250 static const unsigned nsamples
[] = { 1, 111, 4777 } ;
1252 for(samples
= 0; samples
< sizeof(nsamples
)/sizeof(nsamples
[0]); samples
++) {
1255 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-%u.aiff", channels
, bits_per_sample
, nsamples
[samples
]);
1256 if(!generate_aiff(fn
, 44100, channels
, bits_per_sample
, nsamples
[samples
]))
1259 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-%u.wav", channels
, bits_per_sample
, nsamples
[samples
]);
1260 if(!generate_wav(fn
, 44100, channels
, bits_per_sample
, nsamples
[samples
], /*strict=*/true, /*flavor=*/0))
1263 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-%u.rf64", channels
, bits_per_sample
, nsamples
[samples
]);
1264 if(!generate_wav(fn
, 44100, channels
, bits_per_sample
, nsamples
[samples
], /*strict=*/true, /*flavor=*/1))
1267 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-%u.w64", channels
, bits_per_sample
, nsamples
[samples
]);
1268 if(!generate_wav(fn
, 44100, channels
, bits_per_sample
, nsamples
[samples
], /*strict=*/true, /*flavor=*/2))
1271 if(bits_per_sample
% 8 == 0) {
1272 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-signed-%u.raw", channels
, bits_per_sample
, nsamples
[samples
]);
1273 if(!generate_signed_raw(fn
, channels
, bits_per_sample
/8, nsamples
[samples
]))
1275 flac_snprintf(fn
, sizeof (fn
), "rt-%u-%u-unsigned-%u.raw", channels
, bits_per_sample
, nsamples
[samples
]);
1276 if(!generate_unsigned_raw(fn
, channels
, bits_per_sample
/8, nsamples
[samples
]))