src/lib/dl/ext/lame/get_audio.c

   1 /*
   2  *      Get Audio routines source file
   3  *
   4  *      Copyright (c) 1999 Albert L Faber
   5  *                    2008-2011 Robert Hegemann
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* $Id: get_audio.c,v 1.152.2.1 2011/11/18 08:38:04 robert Exp $ */
  24
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include <config.h>
  28 #endif
  29
  30 #include <assert.h>
  31
  32 #ifdef HAVE_LIMITS_H
  33 # include <limits.h>
  34 #endif
  35
  36 #include <stdio.h>
  37
  38 #ifdef STDC_HEADERS
  39 # include <stdlib.h>
  40 # include <string.h>
  41 #else
  42 # ifndef HAVE_STRCHR
  43 #  define strchr index
  44 #  define strrchr rindex
  45 # endif
  46 char   *strchr(), *strrchr();
  47 # ifndef HAVE_MEMCPY
  48 #  define memcpy(d, s, n) bcopy ((s), (d), (n))
  49 #  define memmove(d, s, n) bcopy ((s), (d), (n))
  50 # endif
  51 #endif
  52
  53 #ifdef HAVE_INTTYPES_H
  54 # include <inttypes.h>
  55 #else
  56 # ifdef HAVE_STDINT_H
  57 #  include <stdint.h>
  58 # endif
  59 #endif
  60
  61 #define         MAX_U_32_NUM            0xFFFFFFFF
  62
  63
  64 #include <math.h>
  65
  66 #if defined(__riscos__)
  67 # include <kernel.h>
  68 # include <sys/swis.h>
  69 #elif defined(_WIN32)
  70 # include <sys/types.h>
  71 # include <sys/stat.h>
  72 #else
  73 # include <sys/stat.h>
  74 #endif
  75
  76 #ifdef __sun__
  77 /* woraround for SunOS 4.x, it has SEEK_* defined here */
  78 #include <unistd.h>
  79 #endif
  80
  81 #include "lame.h"
  82 #include "main.h"
  83 #include "get_audio.h"
  84 #include "lametime.h"
  85 #include "console.h"
  86
  87 #ifdef WITH_DMALLOC
  88 #include <dmalloc.h>
  89 #endif
  90
  91 #ifndef STR
  92 # define __STR(x)  #x
  93 # define STR(x)    __STR(x)
  94 #define __LOC__ __FILE__ "("STR(__LINE__)") : "
  95 #endif
  96
  97
  98 #define FLOAT_TO_UNSIGNED(f) ((unsigned long)(((long)((f) - 2147483648.0)) + 2147483647L + 1))
  99 #define UNSIGNED_TO_FLOAT(u) (((double)((long)((u) - 2147483647L - 1))) + 2147483648.0)
 100
 101 static unsigned int uint32_high_low(unsigned char *bytes)
 102 {
 103     uint32_t const hh = bytes[0];
 104     uint32_t const hl = bytes[1];
 105     uint32_t const lh = bytes[2];
 106     uint32_t const ll = bytes[3];
 107     return (hh << 24) | (hl << 16) | (lh << 8) | ll;
 108 }
 109
 110 static double
 111 read_ieee_extended_high_low(FILE * fp)
 112 {
 113     unsigned char bytes[10];
 114     memset(bytes, 0, 10);
 115     fread(bytes, 1, 10, fp);
 116     {
 117         int32_t const s = (bytes[0] & 0x80);
 118         int32_t const e_h = (bytes[0] & 0x7F);
 119         int32_t const e_l = bytes[1];
 120         int32_t e = (e_h << 8) | e_l;
 121         uint32_t const hm = uint32_high_low(bytes + 2);
 122         uint32_t const lm = uint32_high_low(bytes + 6);
 123         double  result = 0;
 124         if (e != 0 || hm != 0 || lm != 0) {
 125             if (e == 0x7fff) {
 126                 result = HUGE_VAL;
 127             }
 128             else {
 129                 double  mantissa_h = UNSIGNED_TO_FLOAT(hm);
 130                 double  mantissa_l = UNSIGNED_TO_FLOAT(lm);
 131                 e -= 0x3fff;
 132                 e -= 31;
 133                 result = ldexp(mantissa_h, e);
 134                 e -= 32;
 135                 result += ldexp(mantissa_l, e);
 136             }
 137         }
 138         return s ? -result : result;
 139     }
 140 }
 141
 142
 143 static int
 144 read_16_bits_low_high(FILE * fp)
 145 {
 146     unsigned char bytes[2] = { 0, 0 };
 147     fread(bytes, 1, 2, fp);
 148     {
 149         int32_t const low = bytes[0];
 150         int32_t const high = (signed char) (bytes[1]);
 151         return (high << 8) | low;
 152     }
 153 }
 154
 155
 156 static int
 157 read_32_bits_low_high(FILE * fp)
 158 {
 159     unsigned char bytes[4] = { 0, 0, 0, 0 };
 160     fread(bytes, 1, 4, fp);
 161     {
 162         int32_t const low = bytes[0];
 163         int32_t const medl = bytes[1];
 164         int32_t const medh = bytes[2];
 165         int32_t const high = (signed char) (bytes[3]);
 166         return (high << 24) | (medh << 16) | (medl << 8) | low;
 167     }
 168 }
 169
 170 static int
 171 read_16_bits_high_low(FILE * fp)
 172 {
 173     unsigned char bytes[2] = { 0, 0 };
 174     fread(bytes, 1, 2, fp);
 175     {
 176         int32_t const low = bytes[1];
 177         int32_t const high = (signed char) (bytes[0]);
 178         return (high << 8) | low;
 179     }
 180 }
 181
 182 static int
 183 read_32_bits_high_low(FILE * fp)
 184 {
 185     unsigned char bytes[4] = { 0, 0, 0, 0 };
 186     fread(bytes, 1, 4, fp);
 187     {
 188         int32_t const low = bytes[3];
 189         int32_t const medl = bytes[2];
 190         int32_t const medh = bytes[1];
 191         int32_t const high = (signed char) (bytes[0]);
 192         return (high << 24) | (medh << 16) | (medl << 8) | low;
 193     }
 194 }
 195
 196 static void
 197 write_16_bits_low_high(FILE * fp, int val)
 198 {
 199     unsigned char bytes[2];
 200     bytes[0] = (val & 0xff);
 201     bytes[1] = ((val >> 8) & 0xff);
 202     fwrite(bytes, 1, 2, fp);
 203 }
 204
 205 static void
 206 write_32_bits_low_high(FILE * fp, int val)
 207 {
 208     unsigned char bytes[4];
 209     bytes[0] = (val & 0xff);
 210     bytes[1] = ((val >> 8) & 0xff);
 211     bytes[2] = ((val >> 16) & 0xff);
 212     bytes[3] = ((val >> 24) & 0xff);
 213     fwrite(bytes, 1, 4, fp);
 214 }
 215
 216 #ifdef LIBSNDFILE
 217
 218 #include <sndfile.h>
 219
 220
 221 #else
 222
 223 typedef void SNDFILE;
 224
 225 #endif /* ifdef LIBSNDFILE */
 226
 227
 228
 229 typedef struct blockAlign_struct {
 230     unsigned long offset;
 231     unsigned long blockSize;
 232 } blockAlign;
 233
 234 typedef struct IFF_AIFF_struct {
 235     short   numChannels;
 236     unsigned long numSampleFrames;
 237     short   sampleSize;
 238     double  sampleRate;
 239     unsigned long sampleType;
 240     blockAlign blkAlgn;
 241 } IFF_AIFF;
 242
 243
 244
 245 struct PcmBuffer {
 246     void   *ch[2];           /* buffer for each channel */
 247     int     w;               /* sample width */
 248     int     n;               /* number samples allocated */
 249     int     u;               /* number samples used */
 250     int     skip_start;      /* number samples to ignore at the beginning */
 251     int     skip_end;        /* number samples to ignore at the end */
 252 };
 253
 254 typedef struct PcmBuffer PcmBuffer;
 255
 256 static void
 257 initPcmBuffer(PcmBuffer * b, int w)
 258 {
 259     b->ch[0] = 0;
 260     b->ch[1] = 0;
 261     b->w = w;
 262     b->n = 0;
 263     b->u = 0;
 264     b->skip_start = 0;
 265     b->skip_end = 0;
 266 }
 267
 268 static void
 269 freePcmBuffer(PcmBuffer * b)
 270 {
 271     if (b != 0) {
 272         free(b->ch[0]);
 273         free(b->ch[1]);
 274         b->ch[0] = 0;
 275         b->ch[1] = 0;
 276         b->n = 0;
 277         b->u = 0;
 278     }
 279 }
 280
 281 static int
 282 addPcmBuffer(PcmBuffer * b, void *a0, void *a1, int read)
 283 {
 284     int     a_n;
 285
 286     if (b == 0) {
 287         return 0;
 288     }
 289     if (read < 0) {
 290         return b->u - b->skip_end;
 291     }
 292     if (b->skip_start >= read) {
 293         b->skip_start -= read;
 294         return b->u - b->skip_end;
 295     }
 296     a_n = read - b->skip_start;
 297
 298     if (b != 0 && a_n > 0) {
 299         int const b_free = b->n - b->u;
 300         int const a_need = b->w * a_n;
 301         int const b_used = b->w * b->u;
 302         if (b_free < a_need) {
 303             b->n += a_n;
 304             b->ch[0] = realloc(b->ch[0], b->w * b->n);
 305             b->ch[1] = realloc(b->ch[1], b->w * b->n);
 306         }
 307         b->u += a_n;
 308         if (b->ch[0] != 0 && a0 != 0) {
 309             char   *src = a0;
 310             memcpy((char *) b->ch[0] + b_used, src + b->skip_start, a_need);
 311         }
 312         if (b->ch[1] != 0 && a1 != 0) {
 313             char   *src = a1;
 314             memcpy((char *) b->ch[1] + b_used, src + b->skip_start, a_need);
 315         }
 316     }
 317     b->skip_start = 0;
 318     return b->u - b->skip_end;
 319 }
 320
 321 static int
 322 takePcmBuffer(PcmBuffer * b, void *a0, void *a1, int a_n, int mm)
 323 {
 324     if (a_n > mm) {
 325         a_n = mm;
 326     }
 327     if (b != 0 && a_n > 0) {
 328         int const a_take = b->w * a_n;
 329         if (a0 != 0 && b->ch[0] != 0) {
 330             memcpy(a0, b->ch[0], a_take);
 331         }
 332         if (a1 != 0 && b->ch[1] != 0) {
 333             memcpy(a1, b->ch[1], a_take);
 334         }
 335         b->u -= a_n;
 336         if (b->u < 0) {
 337             b->u = 0;
 338             return a_n;
 339         }
 340         if (b->ch[0] != 0) {
 341             memmove(b->ch[0], (char *) b->ch[0] + a_take, b->w * b->u);
 342         }
 343         if (b->ch[1] != 0) {
 344             memmove(b->ch[1], (char *) b->ch[1] + a_take, b->w * b->u);
 345         }
 346     }
 347     return a_n;
 348 }
 349
 350 /* global data for get_audio.c. */
 351 typedef struct get_audio_global_data_struct {
 352     int     count_samples_carefully;
 353     int     pcmbitwidth;
 354     int     pcmswapbytes;
 355     int     pcm_is_unsigned_8bit;
 356     int     pcm_is_ieee_float;
 357     unsigned int num_samples_read;
 358     FILE   *music_in;
 359     SNDFILE *snd_file;
 360     hip_t   hip;
 361     PcmBuffer pcm32;
 362     PcmBuffer pcm16;
 363     size_t  in_id3v2_size;
 364     unsigned char* in_id3v2_tag;
 365 } get_audio_global_data;
 366
 367 static get_audio_global_data global;
 368
 369
 370
 371 #ifdef AMIGA_MPEGA
 372 int     lame_decode_initfile(const char *fullname, mp3data_struct * const mp3data);
 373 #else
 374 int     lame_decode_initfile(FILE * fd, mp3data_struct * mp3data, int *enc_delay, int *enc_padding);
 375 #endif
 376
 377 /* read mp3 file until mpglib returns one frame of PCM data */
 378 static int lame_decode_fromfile(FILE * fd, short int pcm_l[], short int pcm_r[],
 379                                 mp3data_struct * mp3data);
 380
 381
 382 static int read_samples_pcm(FILE * musicin, int sample_buffer[2304], int samples_to_read);
 383 static int read_samples_mp3(lame_t gfp, FILE * musicin, short int mpg123pcm[2][1152]);
 384 #ifdef LIBSNDFILE
 385 static SNDFILE *open_snd_file(lame_t gfp, char const *inPath);
 386 #endif
 387 static FILE *open_mpeg_file(lame_t gfp, char const *inPath, int *enc_delay, int *enc_padding);
 388 static FILE *open_wave_file(lame_t gfp, char const *inPath);
 389 static int close_input_file(FILE * musicin);
 390
 391
 392 static  size_t
 393 min_size_t(size_t a, size_t b)
 394 {
 395     if (a < b) {
 396         return a;
 397     }
 398     return b;
 399 }
 400
 401 enum ByteOrder machine_byte_order(void);
 402
 403 enum ByteOrder
 404 machine_byte_order(void)
 405 {
 406     long    one = 1;
 407     return !(*((char *) (&one))) ? ByteOrderBigEndian : ByteOrderLittleEndian;
 408 }
 409
 410
 411
 412 /* Replacement for forward fseek(,,SEEK_CUR), because fseek() fails on pipes */
 413
 414
 415 static int
 416 fskip(FILE * fp, long offset, int whence)
 417 {
 418 #ifndef PIPE_BUF
 419     char    buffer[4096];
 420 #else
 421     char    buffer[PIPE_BUF];
 422 #endif
 423
 424 /* S_ISFIFO macro is defined on newer Linuxes */
 425 #ifndef S_ISFIFO
 426 # ifdef _S_IFIFO
 427     /* _S_IFIFO is defined on Win32 and Cygwin */
 428 #  define S_ISFIFO(m) (((m)&_S_IFIFO) == _S_IFIFO)
 429 # endif
 430 #endif
 431
 432 #ifdef S_ISFIFO
 433     /* fseek is known to fail on pipes with several C-Library implementations
 434        workaround: 1) test for pipe
 435        2) for pipes, only relatvie seeking is possible
 436        3)            and only in forward direction!
 437        else fallback to old code
 438      */
 439     {
 440         int const fd = fileno(fp);
 441         struct stat file_stat;
 442
 443         if (fstat(fd, &file_stat) == 0) {
 444             if (S_ISFIFO(file_stat.st_mode)) {
 445                 if (whence != SEEK_CUR || offset < 0) {
 446                     return -1;
 447                 }
 448                 while (offset > 0) {
 449                     size_t const bytes_to_skip = min_size_t(sizeof(buffer), offset);
 450                     size_t const read = fread(buffer, 1, bytes_to_skip, fp);
 451                     if (read < 1) {
 452                         return -1;
 453                     }
 454                     offset -= read;
 455                 }
 456                 return 0;
 457             }
 458         }
 459     }
 460 #endif
 461     if (0 == fseek(fp, offset, whence)) {
 462         return 0;
 463     }
 464
 465     if (whence != SEEK_CUR || offset < 0) {
 466         if (global_ui_config.silent < 10) {
 467             error_printf
 468                 ("fskip problem: Mostly the return status of functions is not evaluate so it is more secure to polute <stderr>.\n");
 469         }
 470         return -1;
 471     }
 472
 473     while (offset > 0) {
 474         size_t const bytes_to_skip = min_size_t(sizeof(buffer), offset);
 475         size_t const read = fread(buffer, 1, bytes_to_skip, fp);
 476         if (read < 1) {
 477             return -1;
 478         }
 479         offset -= read;
 480     }
 481
 482     return 0;
 483 }
 484
 485
 486 static  off_t
 487 lame_get_file_size(FILE * fp)
 488 {
 489     struct stat sb;
 490     int     fd = fileno(fp);
 491
 492     if (0 == fstat(fd, &sb))
 493         return sb.st_size;
 494     return (off_t) - 1;
 495 }
 496
 497
 498 FILE   *
 499 init_outfile(char const *outPath, int decode)
 500 {
 501     FILE   *outf;
 502
 503     /* open the output file */
 504     if (0 == strcmp(outPath, "-")) {
 505         outf = stdout;
 506         lame_set_stream_binary_mode(outf);
 507     }
 508     else {
 509         outf = lame_fopen(outPath, "w+b");
 510 #ifdef __riscos__
 511         /* Assign correct file type */
 512         if (outf != NULL) {
 513             char   *p, *out_path = strdup(outPath);
 514             for (p = out_path; *p; p++) { /* ugly, ugly to modify a string */
 515                 switch (*p) {
 516                 case '.':
 517                     *p = '/';
 518                     break;
 519                 case '/':
 520                     *p = '.';
 521                     break;
 522                 }
 523             }
 524             SetFiletype(out_path, decode ? 0xFB1 /*WAV*/ : 0x1AD /*AMPEG*/);
 525             free(out_path);
 526         }
 527 #else
 528         (void) decode;
 529 #endif
 530     }
 531     return outf;
 532 }
 533
 534
 535 static void
 536 setSkipStartAndEnd(lame_t gfp, int enc_delay, int enc_padding)
 537 {
 538     int     skip_start = 0, skip_end = 0;
 539
 540     if (global_decoder.mp3_delay_set)
 541         skip_start = global_decoder.mp3_delay;
 542
 543     switch (global_reader.input_format) {
 544     case sf_mp123:
 545         break;
 546
 547     case sf_mp3:
 548         if (skip_start == 0) {
 549             if (enc_delay > -1 || enc_padding > -1) {
 550                 if (enc_delay > -1)
 551                     skip_start = enc_delay + 528 + 1;
 552                 if (enc_padding > -1)
 553                     skip_end = enc_padding - (528 + 1);
 554             }
 555             else
 556                 skip_start = lame_get_encoder_delay(gfp) + 528 + 1;
 557         }
 558         else {
 559             /* user specified a value of skip. just add for decoder */
 560             skip_start += 528 + 1; /* mp3 decoder has a 528 sample delay, plus user supplied "skip" */
 561         }
 562         break;
 563     case sf_mp2:
 564         skip_start += 240 + 1;
 565         break;
 566     case sf_mp1:
 567         skip_start += 240 + 1;
 568         break;
 569     case sf_raw:
 570         skip_start += 0; /* other formats have no delay *//* is += 0 not better ??? */
 571         break;
 572     case sf_wave:
 573         skip_start += 0; /* other formats have no delay *//* is += 0 not better ??? */
 574         break;
 575     case sf_aiff:
 576         skip_start += 0; /* other formats have no delay *//* is += 0 not better ??? */
 577         break;
 578     default:
 579         skip_start += 0; /* other formats have no delay *//* is += 0 not better ??? */
 580         break;
 581     }
 582     skip_start = skip_start < 0 ? 0 : skip_start;
 583     skip_end = skip_end < 0 ? 0 : skip_end;
 584     global. pcm16.skip_start = global.pcm32.skip_start = skip_start;
 585     global. pcm16.skip_end = global.pcm32.skip_end = skip_end;
 586 }
 587
 588
 589
 590 int
 591 init_infile(lame_t gfp, char const *inPath)
 592 {
 593     int     enc_delay = 0, enc_padding = 0;
 594     /* open the input file */
 595     global. count_samples_carefully = 0;
 596     global. num_samples_read = 0;
 597     global. pcmbitwidth = global_raw_pcm.in_bitwidth;
 598     global. pcmswapbytes = global_reader.swapbytes;
 599     global. pcm_is_unsigned_8bit = global_raw_pcm.in_signed == 1 ? 0 : 1;
 600     global. pcm_is_ieee_float = 0;
 601     global. hip = 0;
 602     global. music_in = 0;
 603     global. snd_file = 0;
 604     global. in_id3v2_size = 0;
 605     global. in_id3v2_tag = 0;
 606     if (is_mpeg_file_format(global_reader.input_format)) {
 607         global. music_in = open_mpeg_file(gfp, inPath, &enc_delay, &enc_padding);
 608     }
 609     else {
 610 #ifdef LIBSNDFILE
 611         if (strcmp(inPath, "-") != 0) { /* not for stdin */
 612             global. snd_file = open_snd_file(gfp, inPath);
 613         }
 614 #endif
 615         if (global.snd_file == 0) {
 616             global. music_in = open_wave_file(gfp, inPath);
 617         }
 618     }
 619     initPcmBuffer(&global.pcm32, sizeof(int));
 620     initPcmBuffer(&global.pcm16, sizeof(short));
 621     setSkipStartAndEnd(gfp, enc_delay, enc_padding);
 622     {
 623         unsigned long n = lame_get_num_samples(gfp);
 624         if (n != MAX_U_32_NUM) {
 625             unsigned long const discard = global.pcm32.skip_start + global.pcm32.skip_end;
 626             lame_set_num_samples(gfp, n > discard ? n - discard : 0);
 627         }
 628     }
 629     return (global.snd_file != NULL || global.music_in != NULL) ? 1 : -1;
 630 }
 631
 632 int
 633 samples_to_skip_at_start(void)
 634 {
 635     return global.pcm32.skip_start;
 636 }
 637
 638 int
 639 samples_to_skip_at_end(void)
 640 {
 641     return global.pcm32.skip_end;
 642 }
 643
 644 void
 645 close_infile(void)
 646 {
 647     close_input_file(global.music_in);
 648 #ifdef LIBSNDFILE
 649     if (global.snd_file) {
 650         if (sf_close(global.snd_file) != 0) {
 651             if (global_ui_config.silent < 10) {
 652                 error_printf("Could not close sound file \n");
 653             }
 654         }
 655         global. snd_file = 0;
 656     }
 657 #endif
 658     freePcmBuffer(&global.pcm32);
 659     freePcmBuffer(&global.pcm16);
 660     global. music_in = 0;
 661     free(global.in_id3v2_tag);
 662     global.in_id3v2_tag = 0;
 663     global.in_id3v2_size = 0;
 664 }
 665
 666
 667 static int
 668         get_audio_common(lame_t gfp, int buffer[2][1152], short buffer16[2][1152]);
 669
 670 /************************************************************************
 671 *
 672 * get_audio()
 673 *
 674 * PURPOSE:  reads a frame of audio data from a file to the buffer,
 675 *   aligns the data for future processing, and separates the
 676 *   left and right channels
 677 *
 678 ************************************************************************/
 679 int
 680 get_audio(lame_t gfp, int buffer[2][1152])
 681 {
 682     int     used = 0, read = 0;
 683     do {
 684         read = get_audio_common(gfp, buffer, NULL);
 685         used = addPcmBuffer(&global.pcm32, buffer[0], buffer[1], read);
 686     } while (used <= 0 && read > 0);
 687     if (read < 0) {
 688         return read;
 689     }
 690     if (global_reader.swap_channel == 0)
 691         return takePcmBuffer(&global.pcm32, buffer[0], buffer[1], used, 1152);
 692     else
 693         return takePcmBuffer(&global.pcm32, buffer[1], buffer[0], used, 1152);
 694 }
 695
 696 /*
 697   get_audio16 - behave as the original get_audio function, with a limited
 698                 16 bit per sample output
 699 */
 700 int
 701 get_audio16(lame_t gfp, short buffer[2][1152])
 702 {
 703     int     used = 0, read = 0;
 704     do {
 705         read = get_audio_common(gfp, NULL, buffer);
 706         used = addPcmBuffer(&global.pcm16, buffer[0], buffer[1], read);
 707     } while (used <= 0 && read > 0);
 708     if (read < 0) {
 709         return read;
 710     }
 711     if (global_reader.swap_channel == 0)
 712         return takePcmBuffer(&global.pcm16, buffer[0], buffer[1], used, 1152);
 713     else
 714         return takePcmBuffer(&global.pcm16, buffer[1], buffer[0], used, 1152);
 715 }
 716
 717 /************************************************************************
 718   get_audio_common - central functionality of get_audio*
 719     in: gfp
 720         buffer    output to the int buffer or 16-bit buffer
 721    out: buffer    int output    (if buffer != NULL)
 722         buffer16  16-bit output (if buffer == NULL)
 723 returns: samples read
 724 note: either buffer or buffer16 must be allocated upon call
 725 */
 726 static int
 727 get_audio_common(lame_t gfp, int buffer[2][1152], short buffer16[2][1152])
 728 {
 729 /* NTS: Do *NOT* allocate these on the stack. This causes crashes with Open Watcom's default small stack size. */
 730     static short buf_tmp16[2][1152];
 731     static int insamp[2 * 1152];
 732
 733     int     num_channels = lame_get_num_channels(gfp);
 734     int     samples_read;
 735     int     framesize;
 736     int     samples_to_read;
 737     unsigned int remaining, tmp_num_samples;
 738     int     i;
 739     int    *p;
 740
 741     /*
 742      * NOTE: LAME can now handle arbritray size input data packets,
 743      * so there is no reason to read the input data in chuncks of
 744      * size "framesize".  EXCEPT:  the LAME graphical frame analyzer
 745      * will get out of sync if we read more than framesize worth of data.
 746      */
 747
 748     samples_to_read = framesize = lame_get_framesize(gfp);
 749     assert(framesize <= 1152);
 750
 751     /* get num_samples */
 752     if (is_mpeg_file_format(global_reader.input_format)) {
 753         tmp_num_samples = global_decoder.mp3input_data.nsamp;
 754     }
 755     else {
 756         tmp_num_samples = lame_get_num_samples(gfp);
 757     }
 758
 759     /* if this flag has been set, then we are carefull to read
 760      * exactly num_samples and no more.  This is useful for .wav and .aiff
 761      * files which have id3 or other tags at the end.  Note that if you
 762      * are using LIBSNDFILE, this is not necessary
 763      */
 764     if (global.count_samples_carefully) {
 765         if (global.num_samples_read < tmp_num_samples) {
 766             remaining = tmp_num_samples - global.num_samples_read;
 767         }
 768         else {
 769             remaining = 0;
 770         }
 771         if (remaining < (unsigned int) framesize && 0 != tmp_num_samples)
 772             /* in case the input is a FIFO (at least it's reproducible with
 773                a FIFO) tmp_num_samples may be 0 and therefore remaining
 774                would be 0, but we need to read some samples, so don't
 775                change samples_to_read to the wrong value in this case */
 776             samples_to_read = remaining;
 777     }
 778
 779     if (is_mpeg_file_format(global_reader.input_format)) {
 780         if (buffer != NULL)
 781             samples_read = read_samples_mp3(gfp, global.music_in, buf_tmp16);
 782         else
 783             samples_read = read_samples_mp3(gfp, global.music_in, buffer16);
 784         if (samples_read < 0) {
 785             return samples_read;
 786         }
 787     }
 788     else {
 789         if (global.snd_file) {
 790 #ifdef LIBSNDFILE
 791             samples_read = sf_read_int(global.snd_file, insamp, num_channels * samples_to_read);
 792 #else
 793             samples_read = 0;
 794 #endif
 795         }
 796         else {
 797             samples_read =
 798                 read_samples_pcm(global.music_in, insamp, num_channels * samples_to_read);
 799         }
 800         if (samples_read < 0) {
 801             return samples_read;
 802         }
 803         p = insamp + samples_read;
 804         samples_read /= num_channels;
 805         if (buffer != NULL) { /* output to int buffer */
 806             if (num_channels == 2) {
 807                 for (i = samples_read; --i >= 0;) {
 808                     buffer[1][i] = *--p;
 809                     buffer[0][i] = *--p;
 810                 }
 811             }
 812             else if (num_channels == 1) {
 813                 memset(buffer[1], 0, samples_read * sizeof(int));
 814                 for (i = samples_read; --i >= 0;) {
 815                     buffer[0][i] = *--p;
 816                 }
 817             }
 818             else
 819                 assert(0);
 820         }
 821         else {          /* convert from int; output to 16-bit buffer */
 822             if (num_channels == 2) {
 823                 for (i = samples_read; --i >= 0;) {
 824                     buffer16[1][i] = *--p >> (8 * sizeof(int) - 16);
 825                     buffer16[0][i] = *--p >> (8 * sizeof(int) - 16);
 826                 }
 827             }
 828             else if (num_channels == 1) {
 829                 memset(buffer16[1], 0, samples_read * sizeof(short));
 830                 for (i = samples_read; --i >= 0;) {
 831                     buffer16[0][i] = *--p >> (8 * sizeof(int) - 16);
 832                 }
 833             }
 834             else
 835                 assert(0);
 836         }
 837     }
 838
 839     /* LAME mp3 output 16bit -  convert to int, if necessary */
 840     if (is_mpeg_file_format(global_reader.input_format)) {
 841         if (buffer != NULL) {
 842             for (i = samples_read; --i >= 0;)
 843                 buffer[0][i] = buf_tmp16[0][i] << (8 * sizeof(int) - 16);
 844             if (num_channels == 2) {
 845                 for (i = samples_read; --i >= 0;)
 846                     buffer[1][i] = buf_tmp16[1][i] << (8 * sizeof(int) - 16);
 847             }
 848             else if (num_channels == 1) {
 849                 memset(buffer[1], 0, samples_read * sizeof(int));
 850             }
 851             else
 852                 assert(0);
 853         }
 854     }
 855
 856
 857     /* if num_samples = MAX_U_32_NUM, then it is considered infinitely long.
 858        Don't count the samples */
 859     if (tmp_num_samples != MAX_U_32_NUM)
 860         global. num_samples_read += samples_read;
 861
 862     return samples_read;
 863 }
 864
 865
 866
 867 static int
 868 read_samples_mp3(lame_t gfp, FILE * musicin, short int mpg123pcm[2][1152])
 869 {
 870     int     out;
 871 #if defined(AMIGA_MPEGA)  ||  defined(HAVE_MPGLIB)
 872     int     samplerate;
 873     static const char type_name[] = "MP3 file";
 874
 875     out = lame_decode_fromfile(musicin, mpg123pcm[0], mpg123pcm[1], &global_decoder.mp3input_data);
 876     /*
 877      * out < 0:  error, probably EOF
 878      * out = 0:  not possible with lame_decode_fromfile() ???
 879      * out > 0:  number of output samples
 880      */
 881     if (out < 0) {
 882         memset(mpg123pcm, 0, sizeof(**mpg123pcm) * 2 * 1152);
 883         return 0;
 884     }
 885
 886     if (lame_get_num_channels(gfp) != global_decoder.mp3input_data.stereo) {
 887         if (global_ui_config.silent < 10) {
 888             error_printf("Error: number of channels has changed in %s - not supported\n",
 889                          type_name);
 890         }
 891         out = -1;
 892     }
 893     samplerate = global_reader.input_samplerate;
 894     if (samplerate == 0) {
 895         samplerate = global_decoder.mp3input_data.samplerate;
 896     }
 897     if (lame_get_in_samplerate(gfp) != samplerate) {
 898         if (global_ui_config.silent < 10) {
 899             error_printf("Error: sample frequency has changed in %s - not supported\n", type_name);
 900         }
 901         out = -1;
 902     }
 903 #else
 904     out = -1;
 905 #endif
 906     return out;
 907 }
 908
 909
 910 int
 911 WriteWaveHeader(FILE * const fp, int pcmbytes, int freq, int channels, int bits)
 912 {
 913     int     bytes = (bits + 7) / 8;
 914
 915     /* quick and dirty, but documented */
 916     fwrite("RIFF", 1, 4, fp); /* label */
 917     write_32_bits_low_high(fp, pcmbytes + 44 - 8); /* length in bytes without header */
 918     fwrite("WAVEfmt ", 2, 4, fp); /* 2 labels */
 919     write_32_bits_low_high(fp, 2 + 2 + 4 + 4 + 2 + 2); /* length of PCM format declaration area */
 920     write_16_bits_low_high(fp, 1); /* is PCM? */
 921     write_16_bits_low_high(fp, channels); /* number of channels */
 922     write_32_bits_low_high(fp, freq); /* sample frequency in [Hz] */
 923     write_32_bits_low_high(fp, freq * channels * bytes); /* bytes per second */
 924     write_16_bits_low_high(fp, channels * bytes); /* bytes per sample time */
 925     write_16_bits_low_high(fp, bits); /* bits per sample */
 926     fwrite("data", 1, 4, fp); /* label */
 927     write_32_bits_low_high(fp, pcmbytes); /* length in bytes of raw PCM data */
 928
 929     return ferror(fp) ? -1 : 0;
 930 }
 931
 932
 933
 934
 935 #if defined(LIBSNDFILE)
 936
 937 extern SNDFILE *sf_wchar_open(wchar_t const *wpath, int mode, SF_INFO * sfinfo);
 938
 939 static SNDFILE *
 940 open_snd_file(lame_t gfp, char const *inPath)
 941 {
 942     char const *lpszFileName = inPath;
 943     SNDFILE *gs_pSndFileIn = NULL;
 944     SF_INFO gs_wfInfo;
 945
 946     {
 947 #ifdef _WIN32
 948         wchar_t *file_name = utf8ToUnicode(lpszFileName);
 949 #endif
 950         /* Try to open the sound file */
 951         memset(&gs_wfInfo, 0, sizeof(gs_wfInfo));
 952 #ifdef _WIN32
 953         gs_pSndFileIn = sf_wchar_open(file_name, SFM_READ, &gs_wfInfo);
 954 #else
 955         gs_pSndFileIn = sf_open(lpszFileName, SFM_READ, &gs_wfInfo);
 956 #endif
 957
 958         if (gs_pSndFileIn == NULL) {
 959             if (global_raw_pcm.in_signed == 0 && global_raw_pcm.in_bitwidth != 8) {
 960                 error_printf("Unsigned input only supported with bitwidth 8\n");
 961                 exit(1);
 962             }
 963             /* set some defaults incase input is raw PCM */
 964             gs_wfInfo.seekable = (global_reader.input_format != sf_raw); /* if user specified -r, set to not seekable */
 965             gs_wfInfo.samplerate = lame_get_in_samplerate(gfp);
 966             gs_wfInfo.channels = lame_get_num_channels(gfp);
 967             gs_wfInfo.format = SF_FORMAT_RAW;
 968             if ((global_raw_pcm.in_endian == ByteOrderLittleEndian) ^ (global_reader.swapbytes !=
 969                                                                        0)) {
 970                 gs_wfInfo.format |= SF_ENDIAN_LITTLE;
 971             }
 972             else {
 973                 gs_wfInfo.format |= SF_ENDIAN_BIG;
 974             }
 975             switch (global_raw_pcm.in_bitwidth) {
 976             case 8:
 977                 gs_wfInfo.format |=
 978                     global_raw_pcm.in_signed == 0 ? SF_FORMAT_PCM_U8 : SF_FORMAT_PCM_S8;
 979                 break;
 980             case 16:
 981                 gs_wfInfo.format |= SF_FORMAT_PCM_16;
 982                 break;
 983             case 24:
 984                 gs_wfInfo.format |= SF_FORMAT_PCM_24;
 985                 break;
 986             case 32:
 987                 gs_wfInfo.format |= SF_FORMAT_PCM_32;
 988                 break;
 989             default:
 990                 break;
 991             }
 992 #ifdef _WIN32
 993             gs_pSndFileIn = sf_wchar_open(file_name, SFM_READ, &gs_wfInfo);
 994 #else
 995             gs_pSndFileIn = sf_open(lpszFileName, SFM_READ, &gs_wfInfo);
 996 #endif
 997         }
 998 #ifdef _WIN32
 999         free(file_name);
1000 #endif
1001
1002         /* Check result */
1003         if (gs_pSndFileIn == NULL) {
1004             sf_perror(gs_pSndFileIn);
1005             if (global_ui_config.silent < 10) {
1006                 error_printf("Could not open sound file \"%s\".\n", lpszFileName);
1007             }
1008             exit(1);
1009         }
1010         sf_command(gs_pSndFileIn, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE);
1011
1012         if ((gs_wfInfo.format & SF_FORMAT_RAW) == SF_FORMAT_RAW) {
1013             global_reader.input_format = sf_raw;
1014         }
1015
1016 #ifdef _DEBUG_SND_FILE
1017         printf("\n\nSF_INFO structure\n");
1018         printf("samplerate        :%d\n", gs_wfInfo.samplerate);
1019         printf("samples           :%d\n", gs_wfInfo.frames);
1020         printf("channels          :%d\n", gs_wfInfo.channels);
1021         printf("format            :");
1022
1023         /* new formats from sbellon@sbellon.de  1/2000 */
1024
1025         switch (gs_wfInfo.format & SF_FORMAT_TYPEMASK) {
1026         case SF_FORMAT_WAV:
1027             printf("Microsoft WAV format (big endian). ");
1028             break;
1029         case SF_FORMAT_AIFF:
1030             printf("Apple/SGI AIFF format (little endian). ");
1031             break;
1032         case SF_FORMAT_AU:
1033             printf("Sun/NeXT AU format (big endian). ");
1034             break;
1035             /*
1036                case SF_FORMAT_AULE:
1037                DEBUGF("DEC AU format (little endian). ");
1038                break;
1039              */
1040         case SF_FORMAT_RAW:
1041             printf("RAW PCM data. ");
1042             break;
1043         case SF_FORMAT_PAF:
1044             printf("Ensoniq PARIS file format. ");
1045             break;
1046         case SF_FORMAT_SVX:
1047             printf("Amiga IFF / SVX8 / SV16 format. ");
1048             break;
1049         case SF_FORMAT_NIST:
1050             printf("Sphere NIST format. ");
1051             break;
1052         default:
1053             assert(0);
1054             break;
1055         }
1056
1057         switch (gs_wfInfo.format & SF_FORMAT_SUBMASK) {
1058             /*
1059                case SF_FORMAT_PCM:
1060                DEBUGF("PCM data in 8, 16, 24 or 32 bits.");
1061                break;
1062              */
1063         case SF_FORMAT_FLOAT:
1064             printf("32 bit Intel x86 floats.");
1065             break;
1066         case SF_FORMAT_ULAW:
1067             printf("U-Law encoded.");
1068             break;
1069         case SF_FORMAT_ALAW:
1070             printf("A-Law encoded.");
1071             break;
1072         case SF_FORMAT_IMA_ADPCM:
1073             printf("IMA ADPCM.");
1074             break;
1075         case SF_FORMAT_MS_ADPCM:
1076             printf("Microsoft ADPCM.");
1077             break;
1078             /*
1079                case SF_FORMAT_PCM_BE:
1080                DEBUGF("Big endian PCM data.");
1081                break;
1082                case SF_FORMAT_PCM_LE:
1083                DEBUGF("Little endian PCM data.");
1084                break;
1085              */
1086         case SF_FORMAT_PCM_S8:
1087             printf("Signed 8 bit PCM.");
1088             break;
1089         case SF_FORMAT_PCM_U8:
1090             printf("Unsigned 8 bit PCM.");
1091             break;
1092         case SF_FORMAT_PCM_16:
1093             printf("Signed 16 bit PCM.");
1094             break;
1095         case SF_FORMAT_PCM_24:
1096             printf("Signed 24 bit PCM.");
1097             break;
1098         case SF_FORMAT_PCM_32:
1099             printf("Signed 32 bit PCM.");
1100             break;
1101             /*
1102                case SF_FORMAT_SVX_FIB:
1103                DEBUGF("SVX Fibonacci Delta encoding.");
1104                break;
1105                case SF_FORMAT_SVX_EXP:
1106                DEBUGF("SVX Exponential Delta encoding.");
1107                break;
1108              */
1109         default:
1110             assert(0);
1111             break;
1112         }
1113
1114         printf("\n");
1115         printf("sections          :%d\n", gs_wfInfo.sections);
1116         printf("seekable          :\n", gs_wfInfo.seekable);
1117 #endif
1118         /* Check result */
1119         if (gs_pSndFileIn == NULL) {
1120             sf_perror(gs_pSndFileIn);
1121             if (global_ui_config.silent < 10) {
1122                 error_printf("Could not open sound file \"%s\".\n", lpszFileName);
1123             }
1124             exit(1);
1125         }
1126
1127
1128         (void) lame_set_num_samples(gfp, gs_wfInfo.frames);
1129         if (-1 == lame_set_num_channels(gfp, gs_wfInfo.channels)) {
1130             if (global_ui_config.silent < 10) {
1131                 error_printf("Unsupported number of channels: %ud\n", gs_wfInfo.channels);
1132             }
1133             exit(1);
1134         }
1135         if (global_reader.input_samplerate == 0) {
1136             (void) lame_set_in_samplerate(gfp, gs_wfInfo.samplerate);
1137         }
1138         else {
1139             (void) lame_set_in_samplerate(gfp, global_reader.input_samplerate);
1140         }
1141         global. pcmbitwidth = 32;
1142     }
1143 #if 0
1144     if (lame_get_num_samples(gfp) == MAX_U_32_NUM) {
1145         /* try to figure out num_samples */
1146         double const flen = lame_get_file_size(lpszFileName);
1147         if (flen >= 0) {
1148             /* try file size, assume 2 bytes per sample */
1149             lame_set_num_samples(gfp, flen / (2 * lame_get_num_channels(gfp)));
1150         }
1151     }
1152 #endif
1153     return gs_pSndFileIn;
1154 }
1155
1156 #endif /* defined(LIBSNDFILE) */
1157
1158
1159
1160 /************************************************************************
1161 unpack_read_samples - read and unpack signed low-to-high byte or unsigned
1162                       single byte input. (used for read_samples function)
1163                       Output integers are stored in the native byte order
1164                       (little or big endian).  -jd
1165   in: samples_to_read
1166       bytes_per_sample
1167       swap_order    - set for high-to-low byte order input stream
1168  i/o: pcm_in
1169  out: sample_buffer  (must be allocated up to samples_to_read upon call)
1170 returns: number of samples read
1171 */
1172 static int
1173 unpack_read_samples(const int samples_to_read, const int bytes_per_sample,
1174                     const int swap_order, int *sample_buffer, FILE * pcm_in)
1175 {
1176     size_t  samples_read;
1177     int     i;
1178     int    *op;              /* output pointer */
1179     unsigned char *ip = (unsigned char *) sample_buffer; /* input pointer */
1180     const int b = sizeof(int) * 8;
1181
1182 #define GA_URS_IFLOOP( ga_urs_bps ) \
1183     if( bytes_per_sample == ga_urs_bps ) \
1184       for( i = samples_read * bytes_per_sample; (i -= bytes_per_sample) >=0;)
1185
1186     samples_read = fread(sample_buffer, bytes_per_sample, samples_to_read, pcm_in);
1187     op = sample_buffer + samples_read;
1188
1189     if (swap_order == 0) {
1190         GA_URS_IFLOOP(1)
1191             * --op = ip[i] << (b - 8);
1192         GA_URS_IFLOOP(2)
1193             * --op = ip[i] << (b - 16) | ip[i + 1] << (b - 8);
1194         GA_URS_IFLOOP(3)
1195             * --op = ip[i] << (b - 24) | ip[i + 1] << (b - 16) | ip[i + 2] << (b - 8);
1196         GA_URS_IFLOOP(4)
1197             * --op =
1198             ip[i] << (b - 32) | ip[i + 1] << (b - 24) | ip[i + 2] << (b - 16) | ip[i + 3] << (b -
1199                                                                                               8);
1200     }
1201     else {
1202         GA_URS_IFLOOP(1)
1203             * --op = (ip[i] ^ 0x80) << (b - 8) | 0x7f << (b - 16); /* convert from unsigned */
1204         GA_URS_IFLOOP(2)
1205             * --op = ip[i] << (b - 8) | ip[i + 1] << (b - 16);
1206         GA_URS_IFLOOP(3)
1207             * --op = ip[i] << (b - 8) | ip[i + 1] << (b - 16) | ip[i + 2] << (b - 24);
1208         GA_URS_IFLOOP(4)
1209             * --op =
1210             ip[i] << (b - 8) | ip[i + 1] << (b - 16) | ip[i + 2] << (b - 24) | ip[i + 3] << (b -
1211                                                                                              32);
1212     }
1213 #undef GA_URS_IFLOOP
1214     if (global.pcm_is_ieee_float) {
1215         ieee754_float32_t const m_max = INT_MAX;
1216         ieee754_float32_t const m_min = -(ieee754_float32_t) INT_MIN;
1217         ieee754_float32_t *x = (ieee754_float32_t *) sample_buffer;
1218         assert(sizeof(ieee754_float32_t) == sizeof(int));
1219         for (i = 0; i < samples_to_read; ++i) {
1220             ieee754_float32_t const u = x[i];
1221             int     v;
1222             if (u >= 1) {
1223                 v = INT_MAX;
1224             }
1225             else if (u <= -1) {
1226                 v = INT_MIN;
1227             }
1228             else if (u >= 0) {
1229                 v = (int) (u * m_max + 0.5f);
1230             }
1231             else {
1232                 v = (int) (u * m_min - 0.5f);
1233             }
1234             sample_buffer[i] = v;
1235         }
1236     }
1237     return (samples_read);
1238 }
1239
1240
1241
1242 /************************************************************************
1243 *
1244 * read_samples()
1245 *
1246 * PURPOSE:  reads the PCM samples from a file to the buffer
1247 *
1248 *  SEMANTICS:
1249 * Reads #samples_read# number of shorts from #musicin# filepointer
1250 * into #sample_buffer[]#.  Returns the number of samples read.
1251 *
1252 ************************************************************************/
1253
1254 static int
1255 read_samples_pcm(FILE * musicin, int sample_buffer[2304], int samples_to_read)
1256 {
1257     int     samples_read;
1258     int     bytes_per_sample = global.pcmbitwidth / 8;
1259     int     swap_byte_order; /* byte order of input stream */
1260
1261     switch (global.pcmbitwidth) {
1262     case 32:
1263     case 24:
1264     case 16:
1265         if (global_raw_pcm.in_signed == 0) {
1266             if (global_ui_config.silent < 10) {
1267                 error_printf("Unsigned input only supported with bitwidth 8\n");
1268             }
1269             return -1;
1270         }
1271         swap_byte_order = (global_raw_pcm.in_endian != ByteOrderLittleEndian) ? 1 : 0;
1272         if (global.pcmswapbytes) {
1273             swap_byte_order = !swap_byte_order;
1274         }
1275         break;
1276
1277     case 8:
1278         swap_byte_order = global.pcm_is_unsigned_8bit;
1279         break;
1280
1281     default:
1282         if (global_ui_config.silent < 10) {
1283             error_printf("Only 8, 16, 24 and 32 bit input files supported \n");
1284         }
1285         return -1;
1286     }
1287     samples_read = unpack_read_samples(samples_to_read, bytes_per_sample, swap_byte_order,
1288                                        sample_buffer, musicin);
1289     if (ferror(musicin)) {
1290         if (global_ui_config.silent < 10) {
1291             error_printf("Error reading input file\n");
1292         }
1293         return -1;
1294     }
1295
1296     return samples_read;
1297 }
1298
1299
1300
1301 /* AIFF Definitions */
1302
1303 static int const IFF_ID_FORM = 0x464f524d; /* "FORM" */
1304 static int const IFF_ID_AIFF = 0x41494646; /* "AIFF" */
1305 static int const IFF_ID_AIFC = 0x41494643; /* "AIFC" */
1306 static int const IFF_ID_COMM = 0x434f4d4d; /* "COMM" */
1307 static int const IFF_ID_SSND = 0x53534e44; /* "SSND" */
1308 static int const IFF_ID_MPEG = 0x4d504547; /* "MPEG" */
1309
1310 static int const IFF_ID_NONE = 0x4e4f4e45; /* "NONE" *//* AIFF-C data format */
1311 static int const IFF_ID_2CBE = 0x74776f73; /* "twos" *//* AIFF-C data format */
1312 static int const IFF_ID_2CLE = 0x736f7774; /* "sowt" *//* AIFF-C data format */
1313
1314 static int const WAV_ID_RIFF = 0x52494646; /* "RIFF" */
1315 static int const WAV_ID_WAVE = 0x57415645; /* "WAVE" */
1316 static int const WAV_ID_FMT = 0x666d7420; /* "fmt " */
1317 static int const WAV_ID_DATA = 0x64617461; /* "data" */
1318
1319 #ifndef WAVE_FORMAT_PCM
1320 static short const WAVE_FORMAT_PCM = (short)0x0001U;
1321 #endif
1322 #ifndef WAVE_FORMAT_IEEE_FLOAT
1323 static short const WAVE_FORMAT_IEEE_FLOAT = (short)0x0003U;
1324 #endif
1325 #ifndef WAVE_FORMAT_EXTENSIBLE
1326 static short const WAVE_FORMAT_EXTENSIBLE = (short)0xFFFEU;
1327 #endif
1328
1329
1330 static long
1331 make_even_number_of_bytes_in_length(long x)
1332 {
1333     if ((x & 0x01) != 0) {
1334         return x + 1;
1335     }
1336     return x;
1337 }
1338
1339
1340 /*****************************************************************************
1341  *
1342  *      Read Microsoft Wave headers
1343  *
1344  *      By the time we get here the first 32-bits of the file have already been
1345  *      read, and we're pretty sure that we're looking at a WAV file.
1346  *
1347  *****************************************************************************/
1348
1349 static int
1350 parse_wave_header(lame_global_flags * gfp, FILE * sf)
1351 {
1352     int     format_tag = 0;
1353     int     channels = 0;
1354     int     block_align = 0;
1355     int     bits_per_sample = 0;
1356     int     samples_per_sec = 0;
1357     int     avg_bytes_per_sec = 0;
1358
1359
1360     int     is_wav = 0;
1361     long    data_length = 0, file_length, subSize = 0;
1362     int     loop_sanity = 0;
1363
1364     file_length = read_32_bits_high_low(sf);
1365     if (read_32_bits_high_low(sf) != WAV_ID_WAVE)
1366         return -1;
1367
1368     for (loop_sanity = 0; loop_sanity < 20; ++loop_sanity) {
1369         int     type = read_32_bits_high_low(sf);
1370
1371         if (type == WAV_ID_FMT) {
1372             subSize = read_32_bits_low_high(sf);
1373             subSize = make_even_number_of_bytes_in_length(subSize);
1374             if (subSize < 16) {
1375                 /*DEBUGF(
1376                    "'fmt' chunk too short (only %ld bytes)!", subSize);  */
1377                 return -1;
1378             }
1379
1380             format_tag = read_16_bits_low_high(sf);
1381             subSize -= 2;
1382             channels = read_16_bits_low_high(sf);
1383             subSize -= 2;
1384             samples_per_sec = read_32_bits_low_high(sf);
1385             subSize -= 4;
1386             avg_bytes_per_sec = read_32_bits_low_high(sf);
1387             subSize -= 4;
1388             block_align = read_16_bits_low_high(sf);
1389             subSize -= 2;
1390             bits_per_sample = read_16_bits_low_high(sf);
1391             subSize -= 2;
1392
1393             /* WAVE_FORMAT_EXTENSIBLE support */
1394             if ((subSize > 9) && (format_tag == WAVE_FORMAT_EXTENSIBLE)) {
1395                 read_16_bits_low_high(sf); /* cbSize */
1396                 read_16_bits_low_high(sf); /* ValidBitsPerSample */
1397                 read_32_bits_low_high(sf); /* ChannelMask */
1398                 /* SubType coincident with format_tag for PCM int or float */
1399                 format_tag = read_16_bits_low_high(sf);
1400                 subSize -= 10;
1401             }
1402
1403             /* DEBUGF("   skipping %d bytes\n", subSize); */
1404
1405             if (subSize > 0) {
1406                 if (fskip(sf, (long) subSize, SEEK_CUR) != 0)
1407                     return -1;
1408             };
1409
1410         }
1411         else if (type == WAV_ID_DATA) {
1412             subSize = read_32_bits_low_high(sf);
1413             data_length = subSize;
1414             is_wav = 1;
1415             /* We've found the audio data. Read no further! */
1416             break;
1417
1418         }
1419         else {
1420             subSize = read_32_bits_low_high(sf);
1421             subSize = make_even_number_of_bytes_in_length(subSize);
1422             if (fskip(sf, (long) subSize, SEEK_CUR) != 0) {
1423                 return -1;
1424             }
1425         }
1426     }
1427     if (is_wav) {
1428         if (format_tag != WAVE_FORMAT_PCM && format_tag != WAVE_FORMAT_IEEE_FLOAT) {
1429             if (global_ui_config.silent < 10) {
1430                 error_printf("Unsupported data format: 0x%04X\n", format_tag);
1431             }
1432             return 0;   /* oh no! non-supported format  */
1433         }
1434
1435
1436         /* make sure the header is sane */
1437         if (-1 == lame_set_num_channels(gfp, channels)) {
1438             if (global_ui_config.silent < 10) {
1439                 error_printf("Unsupported number of channels: %u\n", channels);
1440             }
1441             return 0;
1442         }
1443         if (global_reader.input_samplerate == 0) {
1444             (void) lame_set_in_samplerate(gfp, samples_per_sec);
1445         }
1446         else {
1447             (void) lame_set_in_samplerate(gfp, global_reader.input_samplerate);
1448         }
1449         global. pcmbitwidth = bits_per_sample;
1450         global. pcm_is_unsigned_8bit = 1;
1451         global. pcm_is_ieee_float = (format_tag == WAVE_FORMAT_IEEE_FLOAT ? 1 : 0);
1452         (void) lame_set_num_samples(gfp, data_length / (channels * ((bits_per_sample + 7) / 8)));
1453         return 1;
1454     }
1455     return -1;
1456 }
1457
1458
1459
1460 /************************************************************************
1461 * aiff_check2
1462 *
1463 * PURPOSE:      Checks AIFF header information to make sure it is valid.
1464 *               returns 0 on success, 1 on errors
1465 ************************************************************************/
1466
1467 static int
1468 aiff_check2(IFF_AIFF * const pcm_aiff_data)
1469 {
1470     if (pcm_aiff_data->sampleType != (unsigned long) IFF_ID_SSND) {
1471         if (global_ui_config.silent < 10) {
1472             error_printf("ERROR: input sound data is not PCM\n");
1473         }
1474         return 1;
1475     }
1476     switch (pcm_aiff_data->sampleSize) {
1477     case 32:
1478     case 24:
1479     case 16:
1480     case 8:
1481         break;
1482     default:
1483         if (global_ui_config.silent < 10) {
1484             error_printf("ERROR: input sound data is not 8, 16, 24 or 32 bits\n");
1485         }
1486         return 1;
1487     }
1488     if (pcm_aiff_data->numChannels != 1 && pcm_aiff_data->numChannels != 2) {
1489         if (global_ui_config.silent < 10) {
1490             error_printf("ERROR: input sound data is not mono or stereo\n");
1491         }
1492         return 1;
1493     }
1494     if (pcm_aiff_data->blkAlgn.blockSize != 0) {
1495         if (global_ui_config.silent < 10) {
1496             error_printf("ERROR: block size of input sound data is not 0 bytes\n");
1497         }
1498         return 1;
1499     }
1500     /* A bug, since we correctly skip the offset earlier in the code.
1501        if (pcm_aiff_data->blkAlgn.offset != 0) {
1502        error_printf("Block offset is not 0 bytes in '%s'\n", file_name);
1503        return 1;
1504        } */
1505
1506     return 0;
1507 }
1508
1509
1510 /*****************************************************************************
1511  *
1512  *      Read Audio Interchange File Format (AIFF) headers.
1513  *
1514  *      By the time we get here the first 32 bits of the file have already been
1515  *      read, and we're pretty sure that we're looking at an AIFF file.
1516  *
1517  *****************************************************************************/
1518
1519 static int
1520 parse_aiff_header(lame_global_flags * gfp, FILE * sf)
1521 {
1522     long    chunkSize = 0, subSize = 0, typeID = 0, dataType = IFF_ID_NONE;
1523     IFF_AIFF aiff_info;
1524     int     seen_comm_chunk = 0, seen_ssnd_chunk = 0;
1525     long    pcm_data_pos = -1;
1526
1527     memset(&aiff_info, 0, sizeof(aiff_info));
1528     chunkSize = read_32_bits_high_low(sf);
1529
1530     typeID = read_32_bits_high_low(sf);
1531     if ((typeID != IFF_ID_AIFF) && (typeID != IFF_ID_AIFC))
1532         return -1;
1533
1534     while (chunkSize > 0) {
1535         long    ckSize;
1536         int     type = read_32_bits_high_low(sf);
1537         chunkSize -= 4;
1538
1539         /* DEBUGF(
1540            "found chunk type %08x '%4.4s'\n", type, (char*)&type); */
1541
1542         /* don't use a switch here to make it easier to use 'break' for SSND */
1543         if (type == IFF_ID_COMM) {
1544             seen_comm_chunk = seen_ssnd_chunk + 1;
1545             subSize = read_32_bits_high_low(sf);
1546             ckSize = make_even_number_of_bytes_in_length(subSize);
1547             chunkSize -= ckSize;
1548
1549             aiff_info.numChannels = (short) read_16_bits_high_low(sf);
1550             ckSize -= 2;
1551             aiff_info.numSampleFrames = read_32_bits_high_low(sf);
1552             ckSize -= 4;
1553             aiff_info.sampleSize = (short) read_16_bits_high_low(sf);
1554             ckSize -= 2;
1555             aiff_info.sampleRate = read_ieee_extended_high_low(sf);
1556             ckSize -= 10;
1557             if (typeID == IFF_ID_AIFC) {
1558                 dataType = read_32_bits_high_low(sf);
1559                 ckSize -= 4;
1560             }
1561             if (fskip(sf, ckSize, SEEK_CUR) != 0)
1562                 return -1;
1563         }
1564         else if (type == IFF_ID_SSND) {
1565             seen_ssnd_chunk = 1;
1566             subSize = read_32_bits_high_low(sf);
1567             ckSize = make_even_number_of_bytes_in_length(subSize);
1568             chunkSize -= ckSize;
1569
1570             aiff_info.blkAlgn.offset = read_32_bits_high_low(sf);
1571             ckSize -= 4;
1572             aiff_info.blkAlgn.blockSize = read_32_bits_high_low(sf);
1573             ckSize -= 4;
1574
1575             aiff_info.sampleType = IFF_ID_SSND;
1576
1577             if (seen_comm_chunk > 0) {
1578                 if (fskip(sf, (long) aiff_info.blkAlgn.offset, SEEK_CUR) != 0)
1579                     return -1;
1580                 /* We've found the audio data. Read no further! */
1581                 break;
1582             }
1583             pcm_data_pos = ftell(sf);
1584             if (pcm_data_pos >= 0) {
1585                 pcm_data_pos += aiff_info.blkAlgn.offset;
1586             }
1587             if (fskip(sf, ckSize, SEEK_CUR) != 0)
1588                 return -1;
1589         }
1590         else {
1591             subSize = read_32_bits_high_low(sf);
1592             ckSize = make_even_number_of_bytes_in_length(subSize);
1593             chunkSize -= ckSize;
1594
1595             if (fskip(sf, ckSize, SEEK_CUR) != 0)
1596                 return -1;
1597         }
1598     }
1599     if (dataType == IFF_ID_2CLE) {
1600         global. pcmswapbytes = global_reader.swapbytes;
1601     }
1602     else if (dataType == IFF_ID_2CBE) {
1603         global. pcmswapbytes = !global_reader.swapbytes;
1604     }
1605     else if (dataType == IFF_ID_NONE) {
1606         global. pcmswapbytes = !global_reader.swapbytes;
1607     }
1608     else {
1609         return -1;
1610     }
1611
1612     /* DEBUGF("Parsed AIFF %d\n", is_aiff); */
1613     if (seen_comm_chunk && (seen_ssnd_chunk > 0 || aiff_info.numSampleFrames == 0)) {
1614         /* make sure the header is sane */
1615         if (0 != aiff_check2(&aiff_info))
1616             return 0;
1617         if (-1 == lame_set_num_channels(gfp, aiff_info.numChannels)) {
1618             if (global_ui_config.silent < 10) {
1619                 error_printf("Unsupported number of channels: %u\n", aiff_info.numChannels);
1620             }
1621             return 0;
1622         }
1623         if (global_reader.input_samplerate == 0) {
1624             (void) lame_set_in_samplerate(gfp, (int) aiff_info.sampleRate);
1625         }
1626         else {
1627             (void) lame_set_in_samplerate(gfp, global_reader.input_samplerate);
1628         }
1629         (void) lame_set_num_samples(gfp, aiff_info.numSampleFrames);
1630         global. pcmbitwidth = aiff_info.sampleSize;
1631         global. pcm_is_unsigned_8bit = 0;
1632         global. pcm_is_ieee_float = 0; /* FIXME: possible ??? */
1633         if (pcm_data_pos >= 0) {
1634             if (fseek(sf, pcm_data_pos, SEEK_SET) != 0) {
1635                 if (global_ui_config.silent < 10) {
1636                     error_printf("Can't rewind stream to audio data position\n");
1637                 }
1638                 return 0;
1639             }
1640         }
1641
1642         return 1;
1643     }
1644     return -1;
1645 }
1646
1647
1648
1649 /************************************************************************
1650 *
1651 * parse_file_header
1652 *
1653 * PURPOSE: Read the header from a bytestream.  Try to determine whether
1654 *                  it's a WAV file or AIFF without rewinding, since rewind
1655 *                  doesn't work on pipes and there's a good chance we're reading
1656 *                  from stdin (otherwise we'd probably be using libsndfile).
1657 *
1658 * When this function returns, the file offset will be positioned at the
1659 * beginning of the sound data.
1660 *
1661 ************************************************************************/
1662
1663 static int
1664 parse_file_header(lame_global_flags * gfp, FILE * sf)
1665 {
1666
1667     int     type = read_32_bits_high_low(sf);
1668     /*
1669        DEBUGF(
1670        "First word of input stream: %08x '%4.4s'\n", type, (char*) &type);
1671      */
1672     global. count_samples_carefully = 0;
1673     global. pcm_is_unsigned_8bit = global_raw_pcm.in_signed == 1 ? 0 : 1;
1674     /*global_reader.input_format = sf_raw; commented out, because it is better to fail
1675        here as to encode some hundreds of input files not supported by LAME
1676        If you know you have RAW PCM data, use the -r switch
1677      */
1678
1679     if (type == WAV_ID_RIFF) {
1680         /* It's probably a WAV file */
1681         int const ret = parse_wave_header(gfp, sf);
1682         if (ret > 0) {
1683             global. count_samples_carefully = 1;
1684             return sf_wave;
1685         }
1686         if (ret < 0) {
1687             if (global_ui_config.silent < 10) {
1688                 error_printf("Warning: corrupt or unsupported WAVE format\n");
1689             }
1690         }
1691     }
1692     else if (type == IFF_ID_FORM) {
1693         /* It's probably an AIFF file */
1694         int const ret = parse_aiff_header(gfp, sf);
1695         if (ret > 0) {
1696             global. count_samples_carefully = 1;
1697             return sf_aiff;
1698         }
1699         if (ret < 0) {
1700             if (global_ui_config.silent < 10) {
1701                 error_printf("Warning: corrupt or unsupported AIFF format\n");
1702             }
1703         }
1704     }
1705     else {
1706         if (global_ui_config.silent < 10) {
1707             error_printf("Warning: unsupported audio format\n");
1708         }
1709     }
1710     return sf_unknown;
1711 }
1712
1713
1714 static FILE *
1715 open_wave_file(lame_t gfp, char const *inPath)
1716 {
1717     FILE   *musicin;
1718
1719     /* set the defaults from info incase we cannot determine them from file */
1720     lame_set_num_samples(gfp, MAX_U_32_NUM);
1721
1722     if (!strcmp(inPath, "-")) {
1723         lame_set_stream_binary_mode(musicin = stdin); /* Read from standard input. */
1724     }
1725     else {
1726         if ((musicin = lame_fopen(inPath, "rb")) == NULL) {
1727             if (global_ui_config.silent < 10) {
1728                 error_printf("Could not find \"%s\".\n", inPath);
1729             }
1730             exit(1);
1731         }
1732     }
1733
1734     if (global_reader.input_format == sf_ogg) {
1735         if (global_ui_config.silent < 10) {
1736             error_printf("sorry, vorbis support in LAME is deprecated.\n");
1737         }
1738         exit(1);
1739     }
1740     else if (global_reader.input_format == sf_raw) {
1741         /* assume raw PCM */
1742         if (global_ui_config.silent < 9) {
1743             console_printf("Assuming raw pcm input file");
1744             if (global_reader.swapbytes)
1745                 console_printf(" : Forcing byte-swapping\n");
1746             else
1747                 console_printf("\n");
1748         }
1749         global. pcmswapbytes = global_reader.swapbytes;
1750     }
1751     else {
1752         global_reader.input_format = parse_file_header(gfp, musicin);
1753     }
1754     if (global_reader.input_format == sf_unknown) {
1755         exit(1);
1756     }
1757
1758     if (lame_get_num_samples(gfp) == MAX_U_32_NUM && musicin != stdin) {
1759         double const flen = lame_get_file_size(musicin); /* try to figure out num_samples */
1760         if (flen >= 0) {
1761             /* try file size, assume 2 bytes per sample */
1762             unsigned long fsize = (unsigned long) (flen / (2 * lame_get_num_channels(gfp)));
1763             (void) lame_set_num_samples(gfp, fsize);
1764         }
1765     }
1766     return musicin;
1767 }
1768
1769
1770
1771 static FILE *
1772 open_mpeg_file(lame_t gfp, char const *inPath, int *enc_delay, int *enc_padding)
1773 {
1774     FILE   *musicin;
1775
1776     /* set the defaults from info incase we cannot determine them from file */
1777     lame_set_num_samples(gfp, MAX_U_32_NUM);
1778
1779     if (strcmp(inPath, "-") == 0) {
1780         musicin = stdin;
1781         lame_set_stream_binary_mode(musicin); /* Read from standard input. */
1782     }
1783     else {
1784         musicin = lame_fopen(inPath, "rb");
1785         if (musicin == NULL) {
1786             if (global_ui_config.silent < 10) {
1787                 error_printf("Could not find \"%s\".\n", inPath);
1788             }
1789             return 0;
1790         }
1791     }
1792 #ifdef AMIGA_MPEGA
1793     if (-1 == lame_decode_initfile(inPath, &global_decoder.mp3input_data)) {
1794         if (global_ui_config.silent < 10) {
1795             error_printf("Error reading headers in mp3 input file %s.\n", inPath);
1796         }
1797         close_input_file(musicin);
1798         return 0;
1799     }
1800 #endif
1801 #ifdef HAVE_MPGLIB
1802     if (-1 == lame_decode_initfile(musicin, &global_decoder.mp3input_data, enc_delay, enc_padding)) {
1803         if (global_ui_config.silent < 10) {
1804             error_printf("Error reading headers in mp3 input file %s.\n", inPath);
1805         }
1806         close_input_file(musicin);
1807         return 0;
1808     }
1809 #endif
1810     if (-1 == lame_set_num_channels(gfp, global_decoder.mp3input_data.stereo)) {
1811         if (global_ui_config.silent < 10) {
1812             error_printf("Unsupported number of channels: %ud\n",
1813                          global_decoder.mp3input_data.stereo);
1814         }
1815         close_input_file(musicin);
1816         return 0;
1817     }
1818     if (global_reader.input_samplerate == 0) {
1819         (void) lame_set_in_samplerate(gfp, global_decoder.mp3input_data.samplerate);
1820     }
1821     else {
1822         (void) lame_set_in_samplerate(gfp, global_reader.input_samplerate);
1823     }
1824     (void) lame_set_num_samples(gfp, global_decoder.mp3input_data.nsamp);
1825
1826     if (lame_get_num_samples(gfp) == MAX_U_32_NUM && musicin != stdin) {
1827         double  flen = lame_get_file_size(musicin); /* try to figure out num_samples */
1828         if (flen >= 0) {
1829             /* try file size, assume 2 bytes per sample */
1830             if (global_decoder.mp3input_data.bitrate > 0) {
1831                 double  totalseconds =
1832                     (flen * 8.0 / (1000.0 * global_decoder.mp3input_data.bitrate));
1833                 unsigned long tmp_num_samples =
1834                     (unsigned long) (totalseconds * lame_get_in_samplerate(gfp));
1835
1836                 (void) lame_set_num_samples(gfp, tmp_num_samples);
1837                 global_decoder.mp3input_data.nsamp = tmp_num_samples;
1838             }
1839         }
1840     }
1841     return musicin;
1842 }
1843
1844
1845 static int
1846 close_input_file(FILE * musicin)
1847 {
1848     int     ret = 0;
1849
1850     if (musicin != stdin && musicin != 0) {
1851         ret = fclose(musicin);
1852     }
1853     if (ret != 0) {
1854         if (global_ui_config.silent < 10) {
1855             error_printf("Could not close audio input file\n");
1856         }
1857     }
1858     return ret;
1859 }
1860
1861
1862
1863 #if defined(HAVE_MPGLIB)
1864 static int
1865 check_aid(const unsigned char *header)
1866 {
1867     return 0 == memcmp(header, "AiD\1", 4);
1868 }
1869
1870 /*
1871  * Please check this and don't kill me if there's a bug
1872  * This is a (nearly?) complete header analysis for a MPEG-1/2/2.5 Layer I, II or III
1873  * data stream
1874  */
1875
1876 static int
1877 is_syncword_mp123(const void *const headerptr)
1878 {
1879     const unsigned char *const p = headerptr;
1880     static const char abl2[16] = { 0, 7, 7, 7, 0, 7, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8 };
1881
1882     if ((p[0] & 0xFF) != 0xFF)
1883         return 0;       /* first 8 bits must be '1' */
1884     if ((p[1] & 0xE0) != 0xE0)
1885         return 0;       /* next 3 bits are also */
1886     if ((p[1] & 0x18) == 0x08)
1887         return 0;       /* no MPEG-1, -2 or -2.5 */
1888     switch (p[1] & 0x06) {
1889     default:
1890     case 0x00:         /* illegal Layer */
1891         return 0;
1892
1893     case 0x02:         /* Layer3 */
1894         if (global_reader.input_format != sf_mp3 && global_reader.input_format != sf_mp123) {
1895             return 0;
1896         }
1897         global_reader.input_format = sf_mp3;
1898         break;
1899
1900     case 0x04:         /* Layer2 */
1901         if (global_reader.input_format != sf_mp2 && global_reader.input_format != sf_mp123) {
1902             return 0;
1903         }
1904         global_reader.input_format = sf_mp2;
1905         break;
1906
1907     case 0x06:         /* Layer1 */
1908         if (global_reader.input_format != sf_mp1 && global_reader.input_format != sf_mp123) {
1909             return 0;
1910         }
1911         global_reader.input_format = sf_mp1;
1912         break;
1913     }
1914     if ((p[1] & 0x06) == 0x00)
1915         return 0;       /* no Layer I, II and III */
1916     if ((p[2] & 0xF0) == 0xF0)
1917         return 0;       /* bad bitrate */
1918     if ((p[2] & 0x0C) == 0x0C)
1919         return 0;       /* no sample frequency with (32,44.1,48)/(1,2,4)     */
1920     if ((p[1] & 0x18) == 0x18 && (p[1] & 0x06) == 0x04 && abl2[p[2] >> 4] & (1 << (p[3] >> 6)))
1921         return 0;
1922     if ((p[3] & 3) == 2)
1923         return 0;       /* reserved enphasis mode */
1924     return 1;
1925 }
1926
1927 static size_t
1928 lenOfId3v2Tag(unsigned char const* buf)
1929 {
1930     unsigned int b0 = buf[0] & 127;
1931     unsigned int b1 = buf[1] & 127;
1932     unsigned int b2 = buf[2] & 127;
1933     unsigned int b3 = buf[3] & 127;
1934     return (((((b0 << 7) + b1) << 7) + b2) << 7) + b3;
1935 }
1936
1937 int
1938 lame_decode_initfile(FILE * fd, mp3data_struct * mp3data, int *enc_delay, int *enc_padding)
1939 {
1940     /*  VBRTAGDATA pTagData; */
1941     /* int xing_header,len2,num_frames; */
1942     unsigned char buf[100];
1943     int     ret;
1944     size_t  len;
1945     int     aid_header;
1946     short int pcm_l[1152], pcm_r[1152];
1947     int     freeformat = 0;
1948
1949     memset(mp3data, 0, sizeof(mp3data_struct));
1950     if (global.hip) {
1951         hip_decode_exit(global.hip);
1952     }
1953     global. hip = hip_decode_init();
1954     hip_set_msgf(global.hip, global_ui_config.silent < 10 ? &frontend_msgf : 0);
1955     hip_set_errorf(global.hip, global_ui_config.silent < 10 ? &frontend_errorf : 0);
1956     hip_set_debugf(global.hip, &frontend_debugf);
1957
1958     len = 4;
1959     if (fread(buf, 1, len, fd) != len)
1960         return -1;      /* failed */
1961     while (buf[0] == 'I' && buf[1] == 'D' && buf[2] == '3') {
1962         len = 6;
1963         if (fread(&buf[4], 1, len, fd) != len)
1964             return -1;  /* failed */
1965         len = lenOfId3v2Tag(&buf[6]);
1966         if (global.in_id3v2_size < 1) {
1967             global.in_id3v2_size = 10 + len;
1968             global.in_id3v2_tag = malloc(global.in_id3v2_size);
1969             if (global.in_id3v2_tag) {
1970                 memcpy(global.in_id3v2_tag, buf, 10);
1971                 if (fread(&global.in_id3v2_tag[10], 1, len, fd) != len)
1972                     return -1;  /* failed */
1973                 len = 0; /* copied, nothing to skip */
1974             }
1975             else {
1976                 global.in_id3v2_size = 0;
1977             }
1978         }
1979         fskip(fd, len, SEEK_CUR);
1980         len = 4;
1981         if (fread(&buf, 1, len, fd) != len)
1982             return -1;  /* failed */
1983     }
1984     aid_header = check_aid(buf);
1985     if (aid_header) {
1986         if (fread(&buf, 1, 2, fd) != 2)
1987             return -1;  /* failed */
1988         aid_header = (unsigned char) buf[0] + 256 * (unsigned char) buf[1];
1989         if (global_ui_config.silent < 9) {
1990             console_printf("Album ID found.  length=%i \n", aid_header);
1991         }
1992         /* skip rest of AID, except for 6 bytes we have already read */
1993         fskip(fd, aid_header - 6, SEEK_CUR);
1994
1995         /* read 4 more bytes to set up buffer for MP3 header check */
1996         if (fread(&buf, 1, len, fd) != len)
1997             return -1;  /* failed */
1998     }
1999     len = 4;
2000     while (!is_syncword_mp123(buf)) {
2001         unsigned int i;
2002         for (i = 0; i < len - 1; i++)
2003             buf[i] = buf[i + 1];
2004         if (fread(buf + len - 1, 1, 1, fd) != 1)
2005             return -1;  /* failed */
2006     }
2007
2008     if ((buf[2] & 0xf0) == 0) {
2009         if (global_ui_config.silent < 9) {
2010             console_printf("Input file is freeformat.\n");
2011         }
2012         freeformat = 1;
2013     }
2014     /* now parse the current buffer looking for MP3 headers.    */
2015     /* (as of 11/00: mpglib modified so that for the first frame where  */
2016     /* headers are parsed, no data will be decoded.   */
2017     /* However, for freeformat, we need to decode an entire frame, */
2018     /* so mp3data->bitrate will be 0 until we have decoded the first */
2019     /* frame.  Cannot decode first frame here because we are not */
2020     /* yet prepared to handle the output. */
2021     ret = hip_decode1_headersB(global.hip, buf, len, pcm_l, pcm_r, mp3data, enc_delay, enc_padding);
2022     if (-1 == ret)
2023         return -1;
2024
2025     /* repeat until we decode a valid mp3 header.  */
2026     while (!mp3data->header_parsed) {
2027         len = fread(buf, 1, sizeof(buf), fd);
2028         if (len != sizeof(buf))
2029             return -1;
2030         ret =
2031             hip_decode1_headersB(global.hip, buf, len, pcm_l, pcm_r, mp3data, enc_delay,
2032                                  enc_padding);
2033         if (-1 == ret)
2034             return -1;
2035     }
2036
2037     if (mp3data->bitrate == 0 && !freeformat) {
2038         if (global_ui_config.silent < 10) {
2039             error_printf("fail to sync...\n");
2040         }
2041         return lame_decode_initfile(fd, mp3data, enc_delay, enc_padding);
2042     }
2043
2044     if (mp3data->totalframes > 0) {
2045         /* mpglib found a Xing VBR header and computed nsamp & totalframes */
2046     }
2047     else {
2048         /* set as unknown.  Later, we will take a guess based on file size
2049          * ant bitrate */
2050         mp3data->nsamp = MAX_U_32_NUM;
2051     }
2052
2053
2054     /*
2055        report_printf("ret = %i NEED_MORE=%i \n",ret,MP3_NEED_MORE);
2056        report_printf("stereo = %i \n",mp.fr.stereo);
2057        report_printf("samp = %i  \n",freqs[mp.fr.sampling_frequency]);
2058        report_printf("framesize = %i  \n",framesize);
2059        report_printf("bitrate = %i  \n",mp3data->bitrate);
2060        report_printf("num frames = %ui  \n",num_frames);
2061        report_printf("num samp = %ui  \n",mp3data->nsamp);
2062        report_printf("mode     = %i  \n",mp.fr.mode);
2063      */
2064
2065     return 0;
2066 }
2067
2068 /*
2069 For lame_decode_fromfile:  return code
2070   -1     error
2071    n     number of samples output.  either 576 or 1152 depending on MP3 file.
2072
2073
2074 For lame_decode1_headers():  return code
2075   -1     error
2076    0     ok, but need more data before outputing any samples
2077    n     number of samples output.  either 576 or 1152 depending on MP3 file.
2078 */
2079 static int
2080 lame_decode_fromfile(FILE * fd, short pcm_l[], short pcm_r[], mp3data_struct * mp3data)
2081 {
2082     int     ret = 0;
2083     size_t  len = 0;
2084     unsigned char buf[1024];
2085
2086     /* first see if we still have data buffered in the decoder: */
2087     ret = hip_decode1_headers(global.hip, buf, len, pcm_l, pcm_r, mp3data);
2088     if (ret != 0)
2089         return ret;
2090
2091
2092     /* read until we get a valid output frame */
2093     for (;;) {
2094         len = fread(buf, 1, 1024, fd);
2095         if (len == 0) {
2096             /* we are done reading the file, but check for buffered data */
2097             ret = hip_decode1_headers(global.hip, buf, len, pcm_l, pcm_r, mp3data);
2098             if (ret <= 0) {
2099                 hip_decode_exit(global.hip); /* release mp3decoder memory */
2100                 global. hip = 0;
2101                 return -1; /* done with file */
2102             }
2103             break;
2104         }
2105
2106         ret = hip_decode1_headers(global.hip, buf, len, pcm_l, pcm_r, mp3data);
2107         if (ret == -1) {
2108             hip_decode_exit(global.hip); /* release mp3decoder memory */
2109             global. hip = 0;
2110             return -1;
2111         }
2112         if (ret > 0)
2113             break;
2114     }
2115     return ret;
2116 }
2117 #endif /* defined(HAVE_MPGLIB) */
2118
2119
2120 int
2121 is_mpeg_file_format(int input_file_format)
2122 {
2123     switch (input_file_format) {
2124     case sf_mp1:
2125         return 1;
2126     case sf_mp2:
2127         return 2;
2128     case sf_mp3:
2129         return 3;
2130     case sf_mp123:
2131         return -1;
2132     default:
2133         break;
2134     }
2135     return 0;
2136 }
2137
2138
2139 #define LOW__BYTE(x) (x & 0x00ff)
2140 #define HIGH_BYTE(x) ((x >> 8) & 0x00ff)
2141
2142 void
2143 put_audio16(FILE * outf, short Buffer[2][1152], int iread, int nch)
2144 {
2145     char    data[2 * 1152 * 2];
2146     int     i, m = 0;
2147
2148     if (global_decoder.disable_wav_header && global_reader.swapbytes) {
2149         if (nch == 1) {
2150             for (i = 0; i < iread; i++) {
2151                 short   x = Buffer[0][i];
2152                 /* write 16 Bits High Low */
2153                 data[m++] = HIGH_BYTE(x);
2154                 data[m++] = LOW__BYTE(x);
2155             }
2156         }
2157         else {
2158             for (i = 0; i < iread; i++) {
2159                 short   x = Buffer[0][i], y = Buffer[1][i];
2160                 /* write 16 Bits High Low */
2161                 data[m++] = HIGH_BYTE(x);
2162                 data[m++] = LOW__BYTE(x);
2163                 /* write 16 Bits High Low */
2164                 data[m++] = HIGH_BYTE(y);
2165                 data[m++] = LOW__BYTE(y);
2166             }
2167         }
2168     }
2169     else {
2170         if (nch == 1) {
2171             for (i = 0; i < iread; i++) {
2172                 short   x = Buffer[0][i];
2173                 /* write 16 Bits Low High */
2174                 data[m++] = LOW__BYTE(x);
2175                 data[m++] = HIGH_BYTE(x);
2176             }
2177         }
2178         else {
2179             for (i = 0; i < iread; i++) {
2180                 short   x = Buffer[0][i], y = Buffer[1][i];
2181                 /* write 16 Bits Low High */
2182                 data[m++] = LOW__BYTE(x);
2183                 data[m++] = HIGH_BYTE(x);
2184                 /* write 16 Bits Low High */
2185                 data[m++] = LOW__BYTE(y);
2186                 data[m++] = HIGH_BYTE(y);
2187             }
2188         }
2189     }
2190     if (m > 0) {
2191         fwrite(data, 1, m, outf);
2192     }
2193     if (global_writer.flush_write == 1) {
2194         fflush(outf);
2195     }
2196 }
2197
2198 hip_t
2199 get_hip(void)
2200 {
2201     return global.hip;
2202 }
2203
2204 size_t
2205 sizeOfOldTag(lame_t gf)
2206 {
2207     (void) gf;
2208     return global.in_id3v2_size;
2209 }
2210
2211 unsigned char*
2212 getOldTag(lame_t gf)
2213 {
2214     (void) gf;
2215     return global.in_id3v2_tag;
2216 }
2217
2218 /* end of get_audio.c */