src/test_streams/main.c

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