src/test_streams/main.c

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