src/test_streams/main.c

   1 /* test_streams - Simple test pattern generator
   2  * Copyright (C) 2000,2001,2002,2003,2004,2005,2006  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <math.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #if defined _MSC_VER || defined __MINGW32__
  27 #include <time.h>
  28 #else
  29 #include <sys/time.h>
  30 #endif
  31 #include "FLAC/assert.h"
  32 #include "FLAC/ordinals.h"
  33
  34 #ifndef M_PI
  35 /* math.h in VC++ doesn't seem to have this (how Microsoft is that?) */
  36 #define M_PI 3.14159265358979323846
  37 #endif
  38
  39 #if defined _WIN32 || defined __EMX__
  40         static const char *mode = "wb";
  41 #else
  42         static const char *mode = "w";
  43 #endif
  44
  45 static FLAC__bool is_big_endian_host;
  46
  47
  48 static FLAC__bool write_little_endian_uint16(FILE *f, FLAC__uint16 x)
  49 {
  50         return
  51                 fputc(x, f) != EOF &&
  52                 fputc(x >> 8, f) != EOF
  53         ;
  54 }
  55
  56 static FLAC__bool write_little_endian_int16(FILE *f, FLAC__int16 x)
  57 {
  58         return write_little_endian_uint16(f, (FLAC__uint16)x);
  59 }
  60
  61 static FLAC__bool write_little_endian_uint24(FILE *f, FLAC__uint32 x)
  62 {
  63         return
  64                 fputc(x, f) != EOF &&
  65                 fputc(x >> 8, f) != EOF &&
  66                 fputc(x >> 16, f) != EOF
  67         ;
  68 }
  69
  70 static FLAC__bool write_little_endian_int24(FILE *f, FLAC__int32 x)
  71 {
  72         return write_little_endian_uint24(f, (FLAC__uint32)x);
  73 }
  74
  75 static FLAC__bool write_little_endian_uint32(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                 fputc(x >> 24, f) != EOF
  82         ;
  83 }
  84
  85 #if 0
  86 /* @@@ not used (yet) */
  87 static FLAC__bool write_little_endian_int32(FILE *f, FLAC__int32 x)
  88 {
  89         return write_little_endian_uint32(f, (FLAC__uint32)x);
  90 }
  91 #endif
  92
  93 static FLAC__bool write_big_endian_uint16(FILE *f, FLAC__uint16 x)
  94 {
  95         return
  96                 fputc(x >> 8, f) != EOF &&
  97                 fputc(x, f) != EOF
  98         ;
  99 }
 100
 101 #if 0
 102 /* @@@ not used (yet) */
 103 static FLAC__bool write_big_endian_int16(FILE *f, FLAC__int16 x)
 104 {
 105         return write_big_endian_uint16(f, (FLAC__uint16)x);
 106 }
 107 #endif
 108
 109 #if 0
 110 /* @@@ not used (yet) */
 111 static FLAC__bool write_big_endian_uint24(FILE *f, FLAC__uint32 x)
 112 {
 113         return
 114                 fputc(x >> 16, f) != EOF &&
 115                 fputc(x >> 8, f) != EOF &&
 116                 fputc(x, f) != EOF
 117         ;
 118 }
 119 #endif
 120
 121 #if 0
 122 /* @@@ not used (yet) */
 123 static FLAC__bool write_big_endian_int24(FILE *f, FLAC__int32 x)
 124 {
 125         return write_big_endian_uint24(f, (FLAC__uint32)x);
 126 }
 127 #endif
 128
 129 static FLAC__bool write_big_endian_uint32(FILE *f, FLAC__uint32 x)
 130 {
 131         return
 132                 fputc(x >> 24, f) != EOF &&
 133                 fputc(x >> 16, f) != EOF &&
 134                 fputc(x >> 8, f) != EOF &&
 135                 fputc(x, f) != EOF
 136         ;
 137 }
 138
 139 #if 0
 140 /* @@@ not used (yet) */
 141 static FLAC__bool write_big_endian_int32(FILE *f, FLAC__int32 x)
 142 {
 143         return write_big_endian_uint32(f, (FLAC__uint32)x);
 144 }
 145 #endif
 146
 147 static FLAC__bool write_sane_extended(FILE *f, unsigned val)
 148         /* Write to 'f' a SANE extended representation of 'val'.  Return false if
 149         * the write succeeds; return true otherwise.
 150         *
 151         * SANE extended is an 80-bit IEEE-754 representation with sign bit, 15 bits
 152         * of exponent, and 64 bits of significand (mantissa).  Unlike most IEEE-754
 153         * representations, it does not imply a 1 above the MSB of the significand.
 154         *
 155         * Preconditions:
 156         *  val!=0U
 157         */
 158 {
 159         unsigned int shift, exponent;
 160
 161         FLAC__ASSERT(val!=0U); /* handling 0 would require a special case */
 162
 163         for(shift= 0U; (val>>(31-shift))==0U; ++shift)
 164                 ;
 165         val<<= shift;
 166         exponent= 63U-(shift+32U); /* add 32 for unused second word */
 167
 168         if(!write_big_endian_uint16(f, (FLAC__uint16)(exponent+0x3FFF)))
 169                 return false;
 170         if(!write_big_endian_uint32(f, val))
 171                 return false;
 172         if(!write_big_endian_uint32(f, 0)) /* unused second word */
 173                 return false;
 174
 175         return true;
 176 }
 177
 178 /* a mono one-sample 16bps stream */
 179 static FLAC__bool generate_01()
 180 {
 181         FILE *f;
 182         FLAC__int16 x = -32768;
 183
 184         if(0 == (f = fopen("test01.raw", mode)))
 185                 return false;
 186
 187         if(!write_little_endian_int16(f, x))
 188                 goto foo;
 189
 190         fclose(f);
 191         return true;
 192 foo:
 193         fclose(f);
 194         return false;
 195 }
 196
 197 /* a stereo one-sample 16bps stream */
 198 static FLAC__bool generate_02()
 199 {
 200         FILE *f;
 201         FLAC__int16 xl = -32768, xr = 32767;
 202
 203         if(0 == (f = fopen("test02.raw", mode)))
 204                 return false;
 205
 206         if(!write_little_endian_int16(f, xl))
 207                 goto foo;
 208         if(!write_little_endian_int16(f, xr))
 209                 goto foo;
 210
 211         fclose(f);
 212         return true;
 213 foo:
 214         fclose(f);
 215         return false;
 216 }
 217
 218 /* a mono five-sample 16bps stream */
 219 static FLAC__bool generate_03()
 220 {
 221         FILE *f;
 222         FLAC__int16 x[] = { -25, 0, 25, 50, 100 };
 223         unsigned i;
 224
 225         if(0 == (f = fopen("test03.raw", mode)))
 226                 return false;
 227
 228         for(i = 0; i < 5; i++)
 229                 if(!write_little_endian_int16(f, x[i]))
 230                         goto foo;
 231
 232         fclose(f);
 233         return true;
 234 foo:
 235         fclose(f);
 236         return false;
 237 }
 238
 239 /* a stereo five-sample 16bps stream */
 240 static FLAC__bool generate_04()
 241 {
 242         FILE *f;
 243         FLAC__int16 x[] = { -25, 500, 0, 400, 25, 300, 50, 200, 100, 100 };
 244         unsigned i;
 245
 246         if(0 == (f = fopen("test04.raw", mode)))
 247                 return false;
 248
 249         for(i = 0; i < 10; i++)
 250                 if(!write_little_endian_int16(f, x[i]))
 251                         goto foo;
 252
 253         fclose(f);
 254         return true;
 255 foo:
 256         fclose(f);
 257         return false;
 258 }
 259
 260 /* a mono full-scale deflection 8bps stream */
 261 static FLAC__bool generate_fsd8(const char *fn, const int pattern[], unsigned reps)
 262 {
 263         FILE *f;
 264         unsigned rep, p;
 265
 266         FLAC__ASSERT(pattern != 0);
 267
 268         if(0 == (f = fopen(fn, mode)))
 269                 return false;
 270
 271         for(rep = 0; rep < reps; rep++) {
 272                 for(p = 0; pattern[p]; p++) {
 273                         signed char x = pattern[p] > 0? 127 : -128;
 274                         if(fwrite(&x, sizeof(x), 1, f) < 1)
 275                                 goto foo;
 276                 }
 277         }
 278
 279         fclose(f);
 280         return true;
 281 foo:
 282         fclose(f);
 283         return false;
 284 }
 285
 286 /* a mono full-scale deflection 16bps stream */
 287 static FLAC__bool generate_fsd16(const char *fn, const int pattern[], unsigned reps)
 288 {
 289         FILE *f;
 290         unsigned rep, p;
 291
 292         FLAC__ASSERT(pattern != 0);
 293
 294         if(0 == (f = fopen(fn, mode)))
 295                 return false;
 296
 297         for(rep = 0; rep < reps; rep++) {
 298                 for(p = 0; pattern[p]; p++) {
 299                         FLAC__int16 x = pattern[p] > 0? 32767 : -32768;
 300                         if(!write_little_endian_int16(f, x))
 301                                 goto foo;
 302                 }
 303         }
 304
 305         fclose(f);
 306         return true;
 307 foo:
 308         fclose(f);
 309         return false;
 310 }
 311
 312 /* a stereo wasted-bits-per-sample 16bps stream */
 313 static FLAC__bool generate_wbps16(const char *fn, unsigned samples)
 314 {
 315         FILE *f;
 316         unsigned sample;
 317
 318         if(0 == (f = fopen(fn, mode)))
 319                 return false;
 320
 321         for(sample = 0; sample < samples; sample++) {
 322                 FLAC__int16 l = (sample % 2000) << 2;
 323                 FLAC__int16 r = (sample % 1000) << 3;
 324                 if(!write_little_endian_int16(f, l))
 325                         goto foo;
 326                 if(!write_little_endian_int16(f, r))
 327                         goto foo;
 328         }
 329
 330         fclose(f);
 331         return true;
 332 foo:
 333         fclose(f);
 334         return false;
 335 }
 336
 337 /* a mono full-scale deflection 24bps stream */
 338 static FLAC__bool generate_fsd24(const char *fn, const int pattern[], unsigned reps)
 339 {
 340         FILE *f;
 341         unsigned rep, p;
 342
 343         FLAC__ASSERT(pattern != 0);
 344
 345         if(0 == (f = fopen(fn, mode)))
 346                 return false;
 347
 348         for(rep = 0; rep < reps; rep++) {
 349                 for(p = 0; pattern[p]; p++) {
 350                         FLAC__int32 x = pattern[p] > 0? 8388607 : -8388608;
 351                         if(!write_little_endian_int24(f, x))
 352                                 goto foo;
 353                 }
 354         }
 355
 356         fclose(f);
 357         return true;
 358 foo:
 359         fclose(f);
 360         return false;
 361 }
 362
 363 /* a mono sine-wave 8bps stream */
 364 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)
 365 {
 366         const FLAC__int8 full_scale = 127;
 367         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 368         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 369         FILE *f;
 370         double theta1, theta2;
 371         unsigned i;
 372
 373         if(0 == (f = fopen(fn, mode)))
 374                 return false;
 375
 376         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 377                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 378                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
 379                 if(fwrite(&v, sizeof(v), 1, f) < 1)
 380                         goto foo;
 381         }
 382
 383         fclose(f);
 384         return true;
 385 foo:
 386         fclose(f);
 387         return false;
 388 }
 389
 390 /* a stereo sine-wave 8bps stream */
 391 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)
 392 {
 393         const FLAC__int8 full_scale = 127;
 394         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 395         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 396         FILE *f;
 397         double theta1, theta2;
 398         unsigned i;
 399
 400         if(0 == (f = fopen(fn, mode)))
 401                 return false;
 402
 403         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 404                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 405                 FLAC__int8 v = (FLAC__int8)(val + 0.5);
 406                 if(fwrite(&v, sizeof(v), 1, f) < 1)
 407                         goto foo;
 408                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
 409                 v = (FLAC__int8)(val + 0.5);
 410                 if(fwrite(&v, sizeof(v), 1, f) < 1)
 411                         goto foo;
 412         }
 413
 414         fclose(f);
 415         return true;
 416 foo:
 417         fclose(f);
 418         return false;
 419 }
 420
 421 /* a mono sine-wave 16bps stream */
 422 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)
 423 {
 424         const FLAC__int16 full_scale = 32767;
 425         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 426         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 427         FILE *f;
 428         double theta1, theta2;
 429         unsigned i;
 430
 431         if(0 == (f = fopen(fn, mode)))
 432                 return false;
 433
 434         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 435                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 436                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
 437                 if(!write_little_endian_int16(f, v))
 438                         goto foo;
 439         }
 440
 441         fclose(f);
 442         return true;
 443 foo:
 444         fclose(f);
 445         return false;
 446 }
 447
 448 /* a stereo sine-wave 16bps stream */
 449 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)
 450 {
 451         const FLAC__int16 full_scale = 32767;
 452         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 453         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 454         FILE *f;
 455         double theta1, theta2;
 456         unsigned i;
 457
 458         if(0 == (f = fopen(fn, mode)))
 459                 return false;
 460
 461         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 462                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 463                 FLAC__int16 v = (FLAC__int16)(val + 0.5);
 464                 if(!write_little_endian_int16(f, v))
 465                         goto foo;
 466                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
 467                 v = (FLAC__int16)(val + 0.5);
 468                 if(!write_little_endian_int16(f, v))
 469                         goto foo;
 470         }
 471
 472         fclose(f);
 473         return true;
 474 foo:
 475         fclose(f);
 476         return false;
 477 }
 478
 479 /* a mono sine-wave 24bps stream */
 480 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)
 481 {
 482         const FLAC__int32 full_scale = 0x7fffff;
 483         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 484         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 485         FILE *f;
 486         double theta1, theta2;
 487         unsigned i;
 488
 489         if(0 == (f = fopen(fn, mode)))
 490                 return false;
 491
 492         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 493                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 494                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
 495                 if(!write_little_endian_int24(f, v))
 496                         goto foo;
 497         }
 498
 499         fclose(f);
 500         return true;
 501 foo:
 502         fclose(f);
 503         return false;
 504 }
 505
 506 /* a stereo sine-wave 24bps stream */
 507 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)
 508 {
 509         const FLAC__int32 full_scale = 0x7fffff;
 510         const double delta1 = 2.0 * M_PI / ( sample_rate / f1);
 511         const double delta2 = 2.0 * M_PI / ( sample_rate / f2);
 512         FILE *f;
 513         double theta1, theta2;
 514         unsigned i;
 515
 516         if(0 == (f = fopen(fn, mode)))
 517                 return false;
 518
 519         for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) {
 520                 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale;
 521                 FLAC__int32 v = (FLAC__int32)(val + 0.5);
 522                 if(!write_little_endian_int24(f, v))
 523                         goto foo;
 524                 val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale;
 525                 v = (FLAC__int32)(val + 0.5);
 526                 if(!write_little_endian_int24(f, v))
 527                         goto foo;
 528         }
 529
 530         fclose(f);
 531         return true;
 532 foo:
 533         fclose(f);
 534         return false;
 535 }
 536
 537 static FLAC__bool generate_noise(const char *fn, unsigned bytes)
 538 {
 539         FILE *f;
 540         unsigned b;
 541 #if !defined _MSC_VER && !defined __MINGW32__
 542         struct timeval tv;
 543
 544         if(gettimeofday(&tv, 0) < 0) {
 545                 fprintf(stderr, "WARNING: couldn't seed RNG with time\n");
 546                 tv.tv_usec = 4321;
 547         }
 548         srandom(tv.tv_usec);
 549 #else
 550         srand(time(0));
 551 #endif
 552
 553         if(0 == (f = fopen(fn, mode)))
 554                 return false;
 555
 556         for(b = 0; b < bytes; b++) {
 557 #if !defined _MSC_VER && !defined __MINGW32__
 558                 FLAC__byte x = (FLAC__byte)(((unsigned)random()) & 0xff);
 559 #else
 560                 FLAC__byte x = (FLAC__byte)(((unsigned)rand()) & 0xff);
 561 #endif
 562                 if(fwrite(&x, sizeof(x), 1, f) < 1)
 563                         goto foo;
 564         }
 565
 566         fclose(f);
 567         return true;
 568 foo:
 569         fclose(f);
 570         return false;
 571 }
 572
 573 static FLAC__bool generate_aiff(const char *filename, unsigned sample_rate, unsigned channels, unsigned bytes_per_sample, unsigned samples)
 574 {
 575         const unsigned true_size = channels * bytes_per_sample * samples;
 576         const unsigned padded_size = (true_size + 1) & (~1u);
 577         FILE *f;
 578         unsigned i;
 579
 580         if(0 == (f = fopen(filename, mode)))
 581                 return false;
 582         if(fwrite("FORM", 1, 4, f) < 4)
 583                 goto foo;
 584         if(!write_big_endian_uint32(f, padded_size + 46))
 585                 goto foo;
 586         if(fwrite("AIFFCOMM\000\000\000\022", 1, 12, f) < 12)
 587                 goto foo;
 588         if(!write_big_endian_uint16(f, (FLAC__uint16)channels))
 589                 goto foo;
 590         if(!write_big_endian_uint32(f, samples))
 591                 goto foo;
 592         if(!write_big_endian_uint16(f, (FLAC__uint16)(8 * bytes_per_sample)))
 593                 goto foo;
 594         if(!write_sane_extended(f, sample_rate))
 595                 goto foo;
 596         if(fwrite("SSND", 1, 4, f) < 4)
 597                 goto foo;
 598         if(!write_big_endian_uint32(f, true_size + 8))
 599                 goto foo;
 600         if(fwrite("\000\000\000\000\000\000\000\000", 1, 8, f) < 8)
 601                 goto foo;
 602
 603         for(i = 0; i < true_size; i++)
 604                 if(fputc(i, f) == EOF)
 605                         goto foo;
 606         for( ; i < padded_size; i++)
 607                 if(fputc(0, f) == EOF)
 608                         goto foo;
 609
 610         fclose(f);
 611         return true;
 612 foo:
 613         fclose(f);
 614         return false;
 615 }
 616
 617 static FLAC__bool generate_wav(const char *filename, unsigned sample_rate, unsigned channels, unsigned bytes_per_sample, unsigned samples)
 618 {
 619         const unsigned true_size = channels * bytes_per_sample * samples;
 620         const unsigned padded_size = (true_size + 1) & (~1u);
 621         FILE *f;
 622         unsigned i;
 623
 624         if(0 == (f = fopen(filename, mode)))
 625                 return false;
 626         if(fwrite("RIFF", 1, 4, f) < 4)
 627                 goto foo;
 628         if(!write_little_endian_uint32(f, padded_size + 36))
 629                 goto foo;
 630         if(fwrite("WAVEfmt \020\000\000\000\001\000", 1, 14, f) < 14)
 631                 goto foo;
 632         if(!write_little_endian_uint16(f, (FLAC__uint16)channels))
 633                 goto foo;
 634         if(!write_little_endian_uint32(f, sample_rate))
 635                 goto foo;
 636         if(!write_little_endian_uint32(f, sample_rate * channels * bytes_per_sample))
 637                 goto foo;
 638         if(!write_little_endian_uint16(f, (FLAC__uint16)(channels * bytes_per_sample))) /* block align */
 639                 goto foo;
 640         if(!write_little_endian_uint16(f, (FLAC__uint16)(8 * bytes_per_sample)))
 641                 goto foo;
 642         if(fwrite("data", 1, 4, f) < 4)
 643                 goto foo;
 644         if(!write_little_endian_uint32(f, true_size))
 645                 goto foo;
 646
 647         for(i = 0; i < true_size; i++)
 648                 if(fputc(i, f) == EOF)
 649                         goto foo;
 650         for( ; i < padded_size; i++)
 651                 if(fputc(0, f) == EOF)
 652                         goto foo;
 653
 654         fclose(f);
 655         return true;
 656 foo:
 657         fclose(f);
 658         return false;
 659 }
 660
 661 static FLAC__bool generate_wackywavs()
 662 {
 663         FILE *f;
 664         FLAC__byte wav[] = {
 665                 'R', 'I', 'F', 'F',  76,   0,   0,   0,
 666                 'W', 'A', 'V', 'E', 'f', 'a', 'c', 't',
 667                   4,   0,   0,  0 , 'b', 'l', 'a', 'h',
 668                 'p', 'a', 'd', ' ',   4,   0,   0,   0,
 669                 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ',
 670                  16,   0,   0,   0,   1,   0,   1,   0,
 671                 0x44,0xAC,  0,   0,   0,   0,   0,   0,
 672                   2,   0,  16,   0, 'd', 'a', 't', 'a',
 673                  16,   0,   0,   0,   0,   0,   1,   0,
 674                   4,   0,   9,   0,  16,   0,  25,   0,
 675                  36,   0,  49,   0, 'p', 'a', 'd', ' ',
 676                   4,   0,   0,   0, 'b', 'l', 'a', 'h'
 677         };
 678
 679         if(0 == (f = fopen("wacky1.wav", mode)))
 680                 return false;
 681         if(fwrite(wav, 1, 84, f) < 84)
 682                 goto foo;
 683         fclose(f);
 684
 685         wav[4] += 12;
 686         if(0 == (f = fopen("wacky2.wav", mode)))
 687                 return false;
 688         if(fwrite(wav, 1, 96, f) < 96)
 689                 goto foo;
 690         fclose(f);
 691
 692         return true;
 693 foo:
 694         fclose(f);
 695         return false;
 696 }
 697
 698 int main(int argc, char *argv[])
 699 {
 700         FLAC__uint32 test = 1;
 701         unsigned channels;
 702
 703         int pattern01[] = { 1, -1, 0 };
 704         int pattern02[] = { 1, 1, -1, 0 };
 705         int pattern03[] = { 1, -1, -1, 0 };
 706         int pattern04[] = { 1, -1, 1, -1, 0 };
 707         int pattern05[] = { 1, -1, -1, 1, 0 };
 708         int pattern06[] = { 1, -1, 1, 1, -1, 0 };
 709         int pattern07[] = { 1, -1, -1, 1, -1, 0 };
 710
 711         (void)argc;
 712         (void)argv;
 713         is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true;
 714
 715         if(!generate_01()) return 1;
 716         if(!generate_02()) return 1;
 717         if(!generate_03()) return 1;
 718         if(!generate_04()) return 1;
 719
 720         if(!generate_fsd8("fsd8-01.raw", pattern01, 100)) return 1;
 721         if(!generate_fsd8("fsd8-02.raw", pattern02, 100)) return 1;
 722         if(!generate_fsd8("fsd8-03.raw", pattern03, 100)) return 1;
 723         if(!generate_fsd8("fsd8-04.raw", pattern04, 100)) return 1;
 724         if(!generate_fsd8("fsd8-05.raw", pattern05, 100)) return 1;
 725         if(!generate_fsd8("fsd8-06.raw", pattern06, 100)) return 1;
 726         if(!generate_fsd8("fsd8-07.raw", pattern07, 100)) return 1;
 727
 728         if(!generate_fsd16("fsd16-01.raw", pattern01, 100)) return 1;
 729         if(!generate_fsd16("fsd16-02.raw", pattern02, 100)) return 1;
 730         if(!generate_fsd16("fsd16-03.raw", pattern03, 100)) return 1;
 731         if(!generate_fsd16("fsd16-04.raw", pattern04, 100)) return 1;
 732         if(!generate_fsd16("fsd16-05.raw", pattern05, 100)) return 1;
 733         if(!generate_fsd16("fsd16-06.raw", pattern06, 100)) return 1;
 734         if(!generate_fsd16("fsd16-07.raw", pattern07, 100)) return 1;
 735
 736         if(!generate_fsd24("fsd24-01.raw", pattern01, 100)) return 1;
 737         if(!generate_fsd24("fsd24-02.raw", pattern02, 100)) return 1;
 738         if(!generate_fsd24("fsd24-03.raw", pattern03, 100)) return 1;
 739         if(!generate_fsd24("fsd24-04.raw", pattern04, 100)) return 1;
 740         if(!generate_fsd24("fsd24-05.raw", pattern05, 100)) return 1;
 741         if(!generate_fsd24("fsd24-06.raw", pattern06, 100)) return 1;
 742         if(!generate_fsd24("fsd24-07.raw", pattern07, 100)) return 1;
 743
 744         if(!generate_wbps16("wbps16-01.raw", 1000)) return 1;
 745
 746         if(!generate_sine8_1("sine8-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
 747         if(!generate_sine8_1("sine8-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
 748         if(!generate_sine8_1("sine8-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
 749         if(!generate_sine8_1("sine8-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
 750         if(!generate_sine8_1("sine8-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
 751
 752         if(!generate_sine8_2("sine8-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
 753         if(!generate_sine8_2("sine8-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
 754         if(!generate_sine8_2("sine8-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
 755         if(!generate_sine8_2("sine8-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
 756         if(!generate_sine8_2("sine8-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
 757         if(!generate_sine8_2("sine8-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
 758         if(!generate_sine8_2("sine8-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
 759         if(!generate_sine8_2("sine8-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
 760         if(!generate_sine8_2("sine8-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
 761         if(!generate_sine8_2("sine8-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
 762
 763         if(!generate_sine16_1("sine16-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
 764         if(!generate_sine16_1("sine16-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
 765         if(!generate_sine16_1("sine16-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
 766         if(!generate_sine16_1("sine16-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
 767         if(!generate_sine16_1("sine16-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
 768
 769         if(!generate_sine16_2("sine16-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
 770         if(!generate_sine16_2("sine16-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
 771         if(!generate_sine16_2("sine16-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
 772         if(!generate_sine16_2("sine16-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
 773         if(!generate_sine16_2("sine16-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
 774         if(!generate_sine16_2("sine16-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
 775         if(!generate_sine16_2("sine16-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
 776         if(!generate_sine16_2("sine16-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
 777         if(!generate_sine16_2("sine16-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
 778         if(!generate_sine16_2("sine16-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
 779
 780         if(!generate_sine24_1("sine24-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1;
 781         if(!generate_sine24_1("sine24-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1;
 782         if(!generate_sine24_1("sine24-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1;
 783         if(!generate_sine24_1("sine24-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1;
 784         if(!generate_sine24_1("sine24-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1;
 785
 786         if(!generate_sine24_2("sine24-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1;
 787         if(!generate_sine24_2("sine24-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1;
 788         if(!generate_sine24_2("sine24-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1;
 789         if(!generate_sine24_2("sine24-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1;
 790         if(!generate_sine24_2("sine24-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1;
 791         if(!generate_sine24_2("sine24-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1;
 792         if(!generate_sine24_2("sine24-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1;
 793         if(!generate_sine24_2("sine24-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1;
 794         if(!generate_sine24_2("sine24-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1;
 795         if(!generate_sine24_2("sine24-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1;
 796
 797         /* WATCHOUT: the size of noise.raw is hardcoded into test/test_flac.sh */
 798         if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1;
 799         if(!generate_noise("noise8m32.raw", 32)) return 1;
 800         if(!generate_wackywavs()) return 1;
 801         for(channels = 1; channels <= 8; channels++) {
 802                 unsigned bytes_per_sample;
 803                 for(bytes_per_sample = 1; bytes_per_sample <= 3; bytes_per_sample++) {
 804                         static const unsigned nsamples[] = { 1, 111, 5555 } ;
 805                         unsigned samples;
 806                         for(samples = 0; samples < sizeof(nsamples)/sizeof(nsamples[0]); samples++) {
 807                                 char fn[64];
 808
 809                                 sprintf(fn, "rt-%u-%u-%u.aiff", channels, bytes_per_sample, nsamples[samples]);
 810                                 if(!generate_aiff(fn, 44100, channels, bytes_per_sample, nsamples[samples]))
 811                                         return 1;
 812
 813                                 sprintf(fn, "rt-%u-%u-%u.raw", channels, bytes_per_sample, nsamples[samples]);
 814                                 if(!generate_noise(fn, channels * bytes_per_sample * nsamples[samples]))
 815                                         return 1;
 816
 817                                 sprintf(fn, "rt-%u-%u-%u.wav", channels, bytes_per_sample, nsamples[samples]);
 818                                 if(!generate_wav(fn, 44100, channels, bytes_per_sample, nsamples[samples]))
 819                                         return 1;
 820                         }
 821                 }
 822         }
 823
 824         return 0;
 825 }