1 /* test_streams - Simple test pattern generator 2 * Copyright (C) 2000-2009 Josh Coalson 3 * Copyright (C) 2011-2016 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 #ifdef 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 #if !defined _MSC_VER && !defined __MINGW32__ 38 #define GET_RANDOM_BYTE (((unsigned)random()) & 0xff) 39 #else 40 #define GET_RANDOM_BYTE (((unsigned)rand()) & 0xff) 41 #endif 42 43 static FLAC__bool is_big_endian_host; 44 45 46 static FLAC__bool write_little_endian_unsigned(FILE *f, FLAC__uint32 x, size_t bytes) 47 { 48 while(bytes) { 49 if(fputc(x, f) == EOF) 50 return false; 51 x >>= 8; 52 bytes--; 53 } 54 return true; 55 } 56 57 static FLAC__bool write_little_endian_signed(FILE *f, FLAC__int32 x, size_t bytes) 58 { 59 return write_little_endian_unsigned(f, (FLAC__uint32) x, bytes); 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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_signed_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 = 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_signed(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_unsigned_raw(const char *filename, unsigned channels, unsigned bytes_per_sample, unsigned samples) 633 { 634 const FLAC__int32 full_scale = (1 << (bytes_per_sample*8-1)) - 1; 635 const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37; 636 const double delta1 = 2.0 * M_PI / ( 44100.0 / f1); 637 const double delta2 = 2.0 * M_PI / ( 44100.0 / f2); 638 const double half_scale = 0.5 * full_scale; 639 double theta1, theta2; 640 FILE *f; 641 unsigned i, j; 642 643 if(0 == (f = fopen(filename, "wb"))) 644 return false; 645 646 for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) { 647 for(j = 0; j < channels; j++) { 648 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale; 649 FLAC__int32 v = (FLAC__int32)(half_scale + val + 0.5) + ((GET_RANDOM_BYTE>>4)-8); 650 if(!write_little_endian_unsigned(f, v, bytes_per_sample)) 651 goto foo; 652 } 653 } 654 655 fclose(f); 656 return true; 657 foo: 658 fclose(f); 659 return false; 660 } 661 662 static FLAC__bool generate_aiff(const char *filename, unsigned sample_rate, unsigned channels, unsigned bps, unsigned samples) 663 { 664 const unsigned bytes_per_sample = (bps+7)/8; 665 const unsigned true_size = channels * bytes_per_sample * samples; 666 const unsigned padded_size = (true_size + 1) & (~1u); 667 const unsigned shift = (bps%8)? 8 - (bps%8) : 0; 668 const FLAC__int32 full_scale = (1 << (bps-1)) - 1; 669 const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37; 670 const double delta1 = 2.0 * M_PI / ( sample_rate / f1); 671 const double delta2 = 2.0 * M_PI / ( sample_rate / f2); 672 double theta1, theta2; 673 FILE *f; 674 unsigned i, j; 675 676 if(0 == (f = fopen(filename, "wb"))) 677 return false; 678 if(fwrite("FORM", 1, 4, f) < 4) 679 goto foo; 680 if(!write_big_endian_uint32(f, padded_size + 46)) 681 goto foo; 682 if(fwrite("AIFFCOMM\000\000\000\022", 1, 12, f) < 12) 683 goto foo; 684 if(!write_big_endian_uint16(f, (FLAC__uint16)channels)) 685 goto foo; 686 if(!write_big_endian_uint32(f, samples)) 687 goto foo; 688 if(!write_big_endian_uint16(f, (FLAC__uint16)bps)) 689 goto foo; 690 if(!write_sane_extended(f, sample_rate)) 691 goto foo; 692 if(fwrite("SSND", 1, 4, f) < 4) 693 goto foo; 694 if(!write_big_endian_uint32(f, true_size + 8)) 695 goto foo; 696 if(fwrite("\000\000\000\000\000\000\000\000", 1, 8, f) < 8) 697 goto foo; 698 699 for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) { 700 for(j = 0; j < channels; j++) { 701 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale; 702 FLAC__int32 v = ((FLAC__int32)(val + 0.5) + ((GET_RANDOM_BYTE>>4)-8)) << shift; 703 if(!write_big_endian(f, v, bytes_per_sample)) 704 goto foo; 705 } 706 } 707 for(i = true_size; i < padded_size; i++) 708 if(fputc(0, f) == EOF) 709 goto foo; 710 711 fclose(f); 712 return true; 713 foo: 714 fclose(f); 715 return false; 716 } 717 718 /* flavor is: 0:WAVE, 1:RF64, 2:WAVE64 */ 719 static FLAC__bool generate_wav(const char *filename, unsigned sample_rate, unsigned channels, unsigned bps, unsigned samples, FLAC__bool strict, int flavor) 720 { 721 const FLAC__bool waveformatextensible = strict && (channels > 2 || (bps%8)); 722 /* ^^^^^^^ 723 * (bps%8) allows 24 bps which is technically supposed to be WAVEFORMATEXTENSIBLE but we 724 * write 24bps as WAVEFORMATEX since it's unambiguous and matches how flac writes it 725 */ 726 727 const unsigned bytes_per_sample = (bps+7)/8; 728 const unsigned shift = (bps%8)? 8 - (bps%8) : 0; 729 /* this rig is not going over 4G so we're ok with 32-bit sizes here */ 730 const FLAC__uint32 true_size = channels * bytes_per_sample * samples; 731 const FLAC__uint32 padded_size = flavor<2? (true_size + 1) & (~1u) : (true_size + 7) & (~7u); 732 const FLAC__int32 full_scale = (1 << (bps-1)) - 1; 733 const double f1 = 441.0, a1 = 0.61, f2 = 661.5, a2 = 0.37; 734 const double delta1 = 2.0 * M_PI / ( sample_rate / f1); 735 const double delta2 = 2.0 * M_PI / ( sample_rate / f2); 736 double theta1, theta2; 737 FILE *f; 738 unsigned i, j; 739 740 if(0 == (f = fopen(filename, "wb"))) 741 return false; 742 /* RIFFxxxxWAVE or equivalent: */ 743 switch(flavor) { 744 case 0: 745 if(fwrite("RIFF", 1, 4, f) < 4) 746 goto foo; 747 /* +4 for WAVE */ 748 /* +8+{40,16} for fmt chunk */ 749 /* +8 for data chunk header */ 750 if(!write_little_endian_uint32(f, 4 + 8+(waveformatextensible?40:16) + 8 + padded_size)) 751 goto foo; 752 if(fwrite("WAVE", 1, 4, f) < 4) 753 goto foo; 754 break; 755 case 1: 756 if(fwrite("RF64", 1, 4, f) < 4) 757 goto foo; 758 if(!write_little_endian_uint32(f, 0xffffffff)) 759 goto foo; 760 if(fwrite("WAVE", 1, 4, f) < 4) 761 goto foo; 762 break; 763 case 2: 764 /* RIFF GUID 66666972-912E-11CF-A5D6-28DB04C10000 */ 765 if(fwrite("\x72\x69\x66\x66\x2E\x91\xCF\x11\xA5\xD6\x28\xDB\x04\xC1\x00\x00", 1, 16, f) < 16) 766 goto foo; 767 /* +(16+8) for RIFF GUID + size */ 768 /* +16 for WAVE GUID */ 769 /* +16+8+{40,16} for fmt chunk */ 770 /* +16+8 for data chunk header */ 771 if(!write_little_endian_uint64(f, (16+8) + 16 + 16+8+(waveformatextensible?40:16) + (16+8) + padded_size)) 772 goto foo; 773 /* WAVE GUID 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */ 774 if(fwrite("\x77\x61\x76\x65\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) < 16) 775 goto foo; 776 break; 777 default: 778 goto foo; 779 } 780 if(flavor == 1) { /* rf64 */ 781 if(fwrite("ds64", 1, 4, f) < 4) 782 goto foo; 783 if(!write_little_endian_uint32(f, 28)) /* ds64 chunk size */ 784 goto foo; 785 if(!write_little_endian_uint64(f, 36 + padded_size + (waveformatextensible?60:36))) 786 goto foo; 787 if(!write_little_endian_uint64(f, true_size)) 788 goto foo; 789 if(!write_little_endian_uint64(f, samples)) 790 goto foo; 791 if(!write_little_endian_uint32(f, 0)) /* table size */ 792 goto foo; 793 } 794 /* fmt chunk */ 795 if(flavor < 2) { 796 if(fwrite("fmt ", 1, 4, f) < 4) 797 goto foo; 798 /* chunk size */ 799 if(!write_little_endian_uint32(f, waveformatextensible?40:16)) 800 goto foo; 801 } 802 else { /* wave64 */ 803 /* fmt GUID 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */ 804 if(fwrite("\x66\x6D\x74\x20\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) < 16) 805 goto foo; 806 /* chunk size (+16+8 for GUID and size fields) */ 807 if(!write_little_endian_uint64(f, 16+8+(waveformatextensible?40:16))) 808 goto foo; 809 } 810 if(!write_little_endian_uint16(f, (FLAC__uint16)(waveformatextensible?65534:1))) 811 goto foo; 812 if(!write_little_endian_uint16(f, (FLAC__uint16)channels)) 813 goto foo; 814 if(!write_little_endian_uint32(f, sample_rate)) 815 goto foo; 816 if(!write_little_endian_uint32(f, sample_rate * channels * bytes_per_sample)) 817 goto foo; 818 if(!write_little_endian_uint16(f, (FLAC__uint16)(channels * bytes_per_sample))) /* block align */ 819 goto foo; 820 if(!write_little_endian_uint16(f, (FLAC__uint16)(bps+shift))) 821 goto foo; 822 if(waveformatextensible) { 823 if(!write_little_endian_uint16(f, (FLAC__uint16)22)) /* cbSize */ 824 goto foo; 825 if(!write_little_endian_uint16(f, (FLAC__uint16)bps)) /* validBitsPerSample */ 826 goto foo; 827 if(!write_little_endian_uint32(f, 0)) /* channelMask */ 828 goto foo; 829 /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */ 830 if(fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f) != 16) 831 goto foo; 832 } 833 /* data chunk */ 834 if(flavor < 2) { 835 if(fwrite("data", 1, 4, f) < 4) 836 goto foo; 837 if(!write_little_endian_uint32(f, flavor==1? 0xffffffff : true_size)) 838 goto foo; 839 } 840 else { /* wave64 */ 841 /* data GUID 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */ 842 if(fwrite("\x64\x61\x74\x61\xF3\xAC\xD3\x11\x8C\xD1\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) != 16) 843 goto foo; 844 /* +16+8 for GUID and size fields */ 845 if(!write_little_endian_uint64(f, 16+8 + true_size)) 846 goto foo; 847 } 848 849 for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) { 850 for(j = 0; j < channels; j++) { 851 double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale; 852 FLAC__int32 v = ((FLAC__int32)(val + 0.5) + ((GET_RANDOM_BYTE>>4)-8)) << shift; 853 if(!write_little_endian_signed(f, v, bytes_per_sample)) 854 goto foo; 855 } 856 } 857 for(i = true_size; i < padded_size; i++) 858 if(fputc(0, f) == EOF) 859 goto foo; 860 861 fclose(f); 862 return true; 863 foo: 864 fclose(f); 865 return false; 866 } 867 868 static FLAC__bool generate_wackywavs(void) 869 { 870 FILE *f; 871 FLAC__byte wav[] = { 872 'R', 'I', 'F', 'F', 76, 0, 0, 0, 873 'W', 'A', 'V', 'E', 'j', 'u', 'n', 'k', 874 4, 0, 0, 0 , 'b', 'l', 'a', 'h', 875 'p', 'a', 'd', ' ', 4, 0, 0, 0, 876 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ', 877 16, 0, 0, 0, 1, 0, 1, 0, 878 0x44,0xAC, 0, 0,0x88,0x58,0x01, 0, 879 2, 0, 16, 0, 'd', 'a', 't', 'a', 880 16, 0, 0, 0, 0, 0, 1, 0, 881 4, 0, 9, 0, 16, 0, 25, 0, 882 36, 0, 49, 0, 'p', 'a', 'd', ' ', 883 4, 0, 0, 0, 'b', 'l', 'a', 'h' 884 }; 885 886 if(0 == (f = fopen("wacky1.wav", "wb"))) 887 return false; 888 if(fwrite(wav, 1, 84, f) < 84) 889 goto foo; 890 fclose(f); 891 892 wav[4] += 12; 893 if(0 == (f = fopen("wacky2.wav", "wb"))) 894 return false; 895 if(fwrite(wav, 1, 96, f) < 96) 896 goto foo; 897 fclose(f); 898 899 return true; 900 foo: 901 fclose(f); 902 return false; 903 } 904 905 static FLAC__bool write_simple_wavex_header (FILE * f, unsigned samplerate, unsigned channels, unsigned bytespersample, unsigned frames) 906 { 907 unsigned datalen = channels * bytespersample * frames ; 908 909 if (fwrite("RIFF", 1, 4, f) != 4) 910 return false; 911 if (!write_little_endian_uint32(f, 40 + 4 + 4 + datalen)) 912 return false; 913 914 if (fwrite("WAVEfmt ", 8, 1, f) != 1) 915 return false; 916 if (!write_little_endian_uint32(f, 40)) 917 return false; 918 919 if(!write_little_endian_uint16(f, 65534)) /* WAVEFORMATEXTENSIBLE tag */ 920 return false; 921 if(!write_little_endian_uint16(f, channels)) 922 return false; 923 if(!write_little_endian_uint32(f, samplerate)) 924 return false; 925 if(!write_little_endian_uint32(f, samplerate * channels * bytespersample)) 926 return false; 927 if(!write_little_endian_uint16(f, channels * bytespersample)) /* block align */ 928 return false; 929 if(!write_little_endian_uint16(f, bytespersample * 8)) 930 return false; 931 932 if(!write_little_endian_uint16(f, 22)) /* cbSize */ 933 return false; 934 if(!write_little_endian_uint16(f, bytespersample * 8)) /* validBitsPerSample */ 935 return false; 936 if(!write_little_endian_uint32(f, 0)) /* channelMask */ 937 return false; 938 /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */ 939 if(fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f) != 16) 940 return false; 941 942 if (fwrite("data", 1, 4, f) != 4) 943 return false; 944 if (!write_little_endian_uint32(f, datalen)) 945 return false; 946 947 return true; 948 } 949 950 static FLAC__bool generate_noisy_sine(void) 951 { 952 FILE *f; 953 int32_t randstate = 0x1243456; 954 double sample, last_val = 0.0; 955 int k; 956 957 if(0 == (f = fopen("noisy-sine.wav", "wb"))) 958 return false; 959 960 if(!write_simple_wavex_header (f, 44100, 1, 2, 220500)) 961 goto foo; 962 963 for (k = 0 ; k < 5 * 44100 ; k++) { 964 /* Obvioulsy not a crypto quality RNG. */ 965 randstate = 11117 * randstate + 211231; 966 randstate = 11117 * randstate + 211231; 967 randstate = 11117 * randstate + 211231; 968 969 sample = randstate / (0x7fffffff * 1.000001); 970 sample = 0.2 * sample - 0.9 * last_val; 971 972 last_val = sample; 973 974 sample += sin (2.0 * k * M_PI * 1.0 / 32.0); 975 sample *= 0.4; 976 #if !defined _MSC_VER 977 write_little_endian_int16(f, lrintf(sample * 32700.0)); 978 #else 979 write_little_endian_int16(f, (FLAC__int16)(sample * 32700.0)); 980 #endif 981 }; 982 983 fclose(f); 984 985 return true; 986 foo: 987 fclose(f); 988 return false; 989 } 990 991 static FLAC__bool generate_wackywav64s(void) 992 { 993 FILE *f; 994 FLAC__byte wav[] = { 995 0x72,0x69,0x66,0x66,0x2E,0x91,0xCF,0x11, /* RIFF GUID */ 996 0xA5,0xD6,0x28,0xDB,0x04,0xC1,0x00,0x00, 997 152, 0, 0, 0, 0, 0, 0, 0, 998 0x77,0x61,0x76,0x65,0xF3,0xAC,0xD3,0x11, /* WAVE GUID */ 999 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A, 1000 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */ 1001 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A, 1002 32, 0, 0, 0 , 0, 0, 0, 0, 1003 'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h', 1004 0x66,0x6D,0x74,0x20,0xF3,0xAC,0xD3,0x11, /* fmt GUID */ 1005 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A, 1006 40, 0, 0, 0 , 0, 0, 0, 0, 1007 1, 0, 1, 0,0x44,0xAC, 0, 0, 1008 0x88,0x58,0x01, 0, 2, 0, 16, 0, 1009 0x64,0x61,0x74,0x61,0xF3,0xAC,0xD3,0x11, /* data GUID */ 1010 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A, 1011 40, 0, 0, 0 , 0, 0, 0, 0, 1012 0, 0, 1, 0, 4, 0, 9, 0, 1013 16, 0, 25, 0, 36, 0, 49, 0, 1014 0x6A,0x75,0x6E,0x6B,0xF3,0xAC,0xD3,0x11, /* junk GUID */ 1015 0x8C,0xD1,0x00,0xC0,0x4F,0x8E,0xDB,0x8A, 1016 32, 0, 0, 0 , 0, 0, 0, 0, 1017 'b', 'l', 'a', 'h', 'b', 'l', 'a', 'h' 1018 }; 1019 1020 if(0 == (f = fopen("wacky1.w64", "wb"))) 1021 return false; 1022 if(fwrite(wav, 1, wav[16], f) < wav[16]) 1023 goto foo; 1024 fclose(f); 1025 1026 wav[16] += 32; 1027 if(0 == (f = fopen("wacky2.w64", "wb"))) 1028 return false; 1029 if(fwrite(wav, 1, wav[16], f) < wav[16]) 1030 goto foo; 1031 fclose(f); 1032 1033 return true; 1034 foo: 1035 fclose(f); 1036 return false; 1037 } 1038 1039 static FLAC__bool generate_wackyrf64s(void) 1040 { 1041 FILE *f; 1042 FLAC__byte wav[] = { 1043 'R', 'F', '6', '4', 255, 255, 255, 255, 1044 'W', 'A', 'V', 'E', 'd', 's', '6', '4', 1045 28, 0, 0, 0, 112, 0, 0, 0, 1046 0, 0, 0, 0, 16, 0, 0, 0, 1047 0, 0, 0, 0, 8, 0, 0, 0, 1048 0, 0, 0, 0, 0, 0, 0, 0, 1049 'j', 'u', 'n', 'k', 1050 4, 0, 0, 0, 'b', 'l', 'a', 'h', 1051 'p', 'a', 'd', ' ', 4, 0, 0, 0, 1052 'B', 'L', 'A', 'H', 'f', 'm', 't', ' ', 1053 16, 0, 0, 0, 1, 0, 1, 0, 1054 0x44,0xAC, 0, 0,0x88,0x58,0x01, 0, 1055 2, 0, 16, 0, 'd', 'a', 't', 'a', 1056 255, 255, 255, 255, 0, 0, 1, 0, 1057 4, 0, 9, 0, 16, 0, 25, 0, 1058 36, 0, 49, 0, 'p', 'a', 'd', ' ', 1059 4, 0, 0, 0, 'b', 'l', 'a', 'h' 1060 }; 1061 1062 if(0 == (f = fopen("wacky1.rf64", "wb"))) 1063 return false; 1064 if(fwrite(wav, 1, 120, f) < 120) 1065 goto foo; 1066 fclose(f); 1067 1068 wav[20] += 12; 1069 if(0 == (f = fopen("wacky2.rf64", "wb"))) 1070 return false; 1071 if(fwrite(wav, 1, 132, f) < 132) 1072 goto foo; 1073 fclose(f); 1074 1075 return true; 1076 foo: 1077 fclose(f); 1078 return false; 1079 } 1080 1081 static FLAC__bool generate_replaygain_tone (unsigned samplerate) 1082 { 1083 FILE *f; 1084 char fname [256] ; 1085 double tone, sample, samplerange; 1086 int k; 1087 1088 flac_snprintf(fname, sizeof(fname), "rpg-tone-%u.wav", samplerate); 1089 1090 if(0 == (f = fopen(fname, "wb"))) 1091 return false; 1092 1093 if(!write_simple_wavex_header (f, samplerate, 1, 3, 220500)) 1094 goto foo; 1095 1096 1097 samplerange = 0x7fffff; /* Largest sample value allowed for a 24 bit PCM file. */ 1098 tone = 1000.0; /* 1 kHz */ 1099 1100 for (k = 0 ; k < 5 * 44100 ; k++) { 1101 sample = sin(2 * M_PI * tone * k / samplerate); 1102 sample *= samplerange; 1103 if (!write_little_endian_uint24(f, (FLAC__int32) sample)) 1104 goto foo; 1105 }; 1106 1107 fclose(f); 1108 1109 return true; 1110 foo: 1111 fclose(f); 1112 return false; 1113 } 1114 1115 int main(int argc, char *argv[]) 1116 { 1117 FLAC__uint32 test = 1; 1118 unsigned channels; 1119 1120 int pattern01[] = { 1, -1, 0 }; 1121 int pattern02[] = { 1, 1, -1, 0 }; 1122 int pattern03[] = { 1, -1, -1, 0 }; 1123 int pattern04[] = { 1, -1, 1, -1, 0 }; 1124 int pattern05[] = { 1, -1, -1, 1, 0 }; 1125 int pattern06[] = { 1, -1, 1, 1, -1, 0 }; 1126 int pattern07[] = { 1, -1, -1, 1, -1, 0 }; 1127 1128 (void)argc; 1129 (void)argv; 1130 is_big_endian_host = (*((FLAC__byte*)(&test)))? false : true; 1131 1132 #if !defined _MSC_VER && !defined __MINGW32__ 1133 { 1134 struct timeval tv; 1135 1136 if(gettimeofday(&tv, 0) < 0) { 1137 fprintf(stderr, "WARNING: couldn't seed RNG with time\n"); 1138 tv.tv_usec = 4321; 1139 } 1140 srandom(tv.tv_usec); 1141 } 1142 #else 1143 srand((unsigned)time(0)); 1144 #endif 1145 1146 if(!generate_01()) return 1; 1147 if(!generate_02()) return 1; 1148 if(!generate_03()) return 1; 1149 if(!generate_04()) return 1; 1150 1151 if(!generate_fsd8("fsd8-01.raw", pattern01, 100)) return 1; 1152 if(!generate_fsd8("fsd8-02.raw", pattern02, 100)) return 1; 1153 if(!generate_fsd8("fsd8-03.raw", pattern03, 100)) return 1; 1154 if(!generate_fsd8("fsd8-04.raw", pattern04, 100)) return 1; 1155 if(!generate_fsd8("fsd8-05.raw", pattern05, 100)) return 1; 1156 if(!generate_fsd8("fsd8-06.raw", pattern06, 100)) return 1; 1157 if(!generate_fsd8("fsd8-07.raw", pattern07, 100)) return 1; 1158 1159 if(!generate_fsd16("fsd16-01.raw", pattern01, 100)) return 1; 1160 if(!generate_fsd16("fsd16-02.raw", pattern02, 100)) return 1; 1161 if(!generate_fsd16("fsd16-03.raw", pattern03, 100)) return 1; 1162 if(!generate_fsd16("fsd16-04.raw", pattern04, 100)) return 1; 1163 if(!generate_fsd16("fsd16-05.raw", pattern05, 100)) return 1; 1164 if(!generate_fsd16("fsd16-06.raw", pattern06, 100)) return 1; 1165 if(!generate_fsd16("fsd16-07.raw", pattern07, 100)) return 1; 1166 1167 if(!generate_fsd24("fsd24-01.raw", pattern01, 100)) return 1; 1168 if(!generate_fsd24("fsd24-02.raw", pattern02, 100)) return 1; 1169 if(!generate_fsd24("fsd24-03.raw", pattern03, 100)) return 1; 1170 if(!generate_fsd24("fsd24-04.raw", pattern04, 100)) return 1; 1171 if(!generate_fsd24("fsd24-05.raw", pattern05, 100)) return 1; 1172 if(!generate_fsd24("fsd24-06.raw", pattern06, 100)) return 1; 1173 if(!generate_fsd24("fsd24-07.raw", pattern07, 100)) return 1; 1174 1175 if(!generate_wbps16("wbps16-01.raw", 1000)) return 1; 1176 1177 if(!generate_sine8_1("sine8-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1; 1178 if(!generate_sine8_1("sine8-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1; 1179 if(!generate_sine8_1("sine8-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1; 1180 if(!generate_sine8_1("sine8-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1; 1181 if(!generate_sine8_1("sine8-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1; 1182 1183 if(!generate_sine8_2("sine8-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1; 1184 if(!generate_sine8_2("sine8-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1; 1185 if(!generate_sine8_2("sine8-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1; 1186 if(!generate_sine8_2("sine8-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1; 1187 if(!generate_sine8_2("sine8-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1; 1188 if(!generate_sine8_2("sine8-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1; 1189 if(!generate_sine8_2("sine8-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1; 1190 if(!generate_sine8_2("sine8-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1; 1191 if(!generate_sine8_2("sine8-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1; 1192 if(!generate_sine8_2("sine8-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1; 1193 1194 if(!generate_sine16_1("sine16-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1; 1195 if(!generate_sine16_1("sine16-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1; 1196 if(!generate_sine16_1("sine16-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1; 1197 if(!generate_sine16_1("sine16-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1; 1198 if(!generate_sine16_1("sine16-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1; 1199 1200 if(!generate_sine16_2("sine16-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1; 1201 if(!generate_sine16_2("sine16-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1; 1202 if(!generate_sine16_2("sine16-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1; 1203 if(!generate_sine16_2("sine16-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1; 1204 if(!generate_sine16_2("sine16-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1; 1205 if(!generate_sine16_2("sine16-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1; 1206 if(!generate_sine16_2("sine16-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1; 1207 if(!generate_sine16_2("sine16-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1; 1208 if(!generate_sine16_2("sine16-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1; 1209 if(!generate_sine16_2("sine16-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1; 1210 1211 if(!generate_sine24_1("sine24-00.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49)) return 1; 1212 if(!generate_sine24_1("sine24-01.raw", 96000.0, 200000, 441.0, 0.61, 661.5, 0.37)) return 1; 1213 if(!generate_sine24_1("sine24-02.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49)) return 1; 1214 if(!generate_sine24_1("sine24-03.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49)) return 1; 1215 if(!generate_sine24_1("sine24-04.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29)) return 1; 1216 1217 if(!generate_sine24_2("sine24-10.raw", 48000.0, 200000, 441.0, 0.50, 441.0, 0.49, 1.0)) return 1; 1218 if(!generate_sine24_2("sine24-11.raw", 48000.0, 200000, 441.0, 0.61, 661.5, 0.37, 1.0)) return 1; 1219 if(!generate_sine24_2("sine24-12.raw", 96000.0, 200000, 441.0, 0.50, 882.0, 0.49, 1.0)) return 1; 1220 if(!generate_sine24_2("sine24-13.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.0)) return 1; 1221 if(!generate_sine24_2("sine24-14.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 1.0)) return 1; 1222 if(!generate_sine24_2("sine24-15.raw", 44100.0, 200000, 441.0, 0.50, 441.0, 0.49, 0.5)) return 1; 1223 if(!generate_sine24_2("sine24-16.raw", 44100.0, 200000, 441.0, 0.61, 661.5, 0.37, 2.0)) return 1; 1224 if(!generate_sine24_2("sine24-17.raw", 44100.0, 200000, 441.0, 0.50, 882.0, 0.49, 0.7)) return 1; 1225 if(!generate_sine24_2("sine24-18.raw", 44100.0, 200000, 441.0, 0.50, 4410.0, 0.49, 1.3)) return 1; 1226 if(!generate_sine24_2("sine24-19.raw", 44100.0, 200000, 8820.0, 0.70, 4410.0, 0.29, 0.1)) return 1; 1227 1228 if(!generate_replaygain_tone(8000)) return 1; 1229 if(!generate_replaygain_tone(11025)) return 1; 1230 if(!generate_replaygain_tone(12000)) return 1; 1231 if(!generate_replaygain_tone(16000)) return 1; 1232 if(!generate_replaygain_tone(18900)) return 1; 1233 if(!generate_replaygain_tone(22050)) return 1; 1234 if(!generate_replaygain_tone(24000)) return 1; 1235 if(!generate_replaygain_tone(28000)) return 1; 1236 if(!generate_replaygain_tone(32000)) return 1; 1237 if(!generate_replaygain_tone(36000)) return 1; 1238 if(!generate_replaygain_tone(37800)) return 1; 1239 if(!generate_replaygain_tone(44100)) return 1; 1240 if(!generate_replaygain_tone(48000)) return 1; 1241 if(!generate_replaygain_tone(96000)) return 1; 1242 if(!generate_replaygain_tone(192000)) return 1; 1243 1244 /* WATCHOUT: the size of noise.raw is hardcoded into test/test_flac.sh */ 1245 if(!generate_noise("noise.raw", 65536 * 8 * 3)) return 1; 1246 if(!generate_noise("noise8m32.raw", 32)) return 1; 1247 if(!generate_wackywavs()) return 1; 1248 if(!generate_wackywav64s()) return 1; 1249 if(!generate_wackyrf64s()) return 1; 1250 if(!generate_noisy_sine()) return 1; 1251 for(channels = 1; channels <= 8; channels *= 2) { 1252 unsigned bits_per_sample; 1253 for(bits_per_sample = 8; bits_per_sample <= 24; bits_per_sample += 4) { 1254 static const unsigned nsamples[] = { 1, 111, 4777 } ; 1255 unsigned samples; 1256 for(samples = 0; samples < sizeof(nsamples)/sizeof(nsamples[0]); samples++) { 1257 char fn[64]; 1258 1259 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.aiff", channels, bits_per_sample, nsamples[samples]); 1260 if(!generate_aiff(fn, 44100, channels, bits_per_sample, nsamples[samples])) 1261 return 1; 1262 1263 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.wav", channels, bits_per_sample, nsamples[samples]); 1264 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/0)) 1265 return 1; 1266 1267 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.rf64", channels, bits_per_sample, nsamples[samples]); 1268 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/1)) 1269 return 1; 1270 1271 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-%u.w64", channels, bits_per_sample, nsamples[samples]); 1272 if(!generate_wav(fn, 44100, channels, bits_per_sample, nsamples[samples], /*strict=*/true, /*flavor=*/2)) 1273 return 1; 1274 1275 if(bits_per_sample % 8 == 0) { 1276 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-signed-%u.raw", channels, bits_per_sample, nsamples[samples]); 1277 if(!generate_signed_raw(fn, channels, bits_per_sample/8, nsamples[samples])) 1278 return 1; 1279 flac_snprintf(fn, sizeof (fn), "rt-%u-%u-unsigned-%u.raw", channels, bits_per_sample, nsamples[samples]); 1280 if(!generate_unsigned_raw(fn, channels, bits_per_sample/8, nsamples[samples])) 1281 return 1; 1282 } 1283 } 1284 } 1285 } 1286 1287 return 0; 1288 } 1289