vorbis-tools/oggenc/audio.c

   1 /* OggEnc
   2  **
   3  ** This program is distributed under the GNU General Public License, version 2.
   4  ** A copy of this license is included with this source.
   5  **
   6  ** Copyright 2000-2002, Michael Smith <msmith@xiph.org>
   7  **
   8  ** AIFF/AIFC support from OggSquish, (c) 1994-1996 Monty <xiphmont@xiph.org>
   9  **/
  10
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <sys/types.h>
  16 #include <math.h>
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include "audio.h"
  23 #include "platform.h"
  24 #include "i18n.h"
  25 #include "resample.h"
  26
  27 #ifdef HAVE_LIBFLAC
  28 #include "flac.h"
  29 #endif
  30
  31 #define WAV_HEADER_SIZE 44
  32
  33 /* Macros to read header data */
  34 #define READ_U32_LE(buf) \
  35         (((buf)[3]<<24)|((buf)[2]<<16)|((buf)[1]<<8)|((buf)[0]&0xff))
  36
  37 #define READ_U16_LE(buf) \
  38         (((buf)[1]<<8)|((buf)[0]&0xff))
  39
  40 #define READ_U32_BE(buf) \
  41         (((buf)[0]<<24)|((buf)[1]<<16)|((buf)[2]<<8)|((buf)[3]&0xff))
  42
  43 #define READ_U16_BE(buf) \
  44         (((buf)[0]<<8)|((buf)[1]&0xff))
  45
  46 /* Define the supported formats here */
  47 input_format formats[] = {
  48         {wav_id, 12, wav_open, wav_close, "wav", N_("WAV file reader")},
  49         {aiff_id, 12, aiff_open, wav_close, "aiff", N_("AIFF/AIFC file reader")},
  50 #ifdef HAVE_LIBFLAC
  51         {flac_id,     4, flac_open, flac_close, "flac", N_("FLAC file reader")},
  52         {oggflac_id, 32, flac_open, flac_close, "ogg", N_("Ogg FLAC file reader")},
  53 #endif
  54         {NULL, 0, NULL, NULL, NULL, NULL}
  55 };
  56
  57 input_format *open_audio_file(FILE *in, oe_enc_opt *opt)
  58 {
  59         int j=0;
  60         unsigned char *buf=NULL;
  61         int buf_size=0, buf_filled=0;
  62         int size,ret;
  63
  64         while(formats[j].id_func)
  65         {
  66                 size = formats[j].id_data_len;
  67                 if(size >= buf_size)
  68                 {
  69                         buf = realloc(buf, size);
  70                         buf_size = size;
  71                 }
  72
  73                 if(size > buf_filled)
  74                 {
  75                         ret = fread(buf+buf_filled, 1, buf_size-buf_filled, in);
  76                         buf_filled += ret;
  77
  78                         if(buf_filled < size)
  79                         { /* File truncated */
  80                                 j++;
  81                                 continue;
  82                         }
  83                 }
  84
  85                 if(formats[j].id_func(buf, buf_filled))
  86                 {
  87                         /* ok, we now have something that can handle the file */
  88                         if(formats[j].open_func(in, opt, buf, buf_filled)) {
  89                 free(buf);
  90                                 return &formats[j];
  91             }
  92                 }
  93                 j++;
  94         }
  95
  96     free(buf);
  97
  98         return NULL;
  99 }
 100
 101 static int seek_forward(FILE *in, int length)
 102 {
 103         if(fseek(in, length, SEEK_CUR))
 104         {
 105                 /* Failed. Do it the hard way. */
 106                 unsigned char buf[1024];
 107                 int seek_needed = length, seeked;
 108                 while(seek_needed > 0)
 109                 {
 110                         seeked = fread(buf, 1, seek_needed>1024?1024:seek_needed, in);
 111                         if(!seeked)
 112                                 return 0; /* Couldn't read more, can't read file */
 113                         else
 114                                 seek_needed -= seeked;
 115                 }
 116         }
 117         return 1;
 118 }
 119
 120
 121 static int find_wav_chunk(FILE *in, char *type, unsigned int *len)
 122 {
 123         unsigned char buf[8];
 124
 125         while(1)
 126         {
 127                 if(fread(buf,1,8,in) < 8) /* Suck down a chunk specifier */
 128                 {
 129                         fprintf(stderr, _("Warning: Unexpected EOF in reading WAV header\n"));
 130                         return 0; /* EOF before reaching the appropriate chunk */
 131                 }
 132
 133                 if(memcmp(buf, type, 4))
 134                 {
 135                         *len = READ_U32_LE(buf+4);
 136                         if(!seek_forward(in, *len))
 137                                 return 0;
 138
 139                         buf[4] = 0;
 140                         fprintf(stderr, _("Skipping chunk of type \"%s\", length %d\n"), buf, *len);
 141                 }
 142                 else
 143                 {
 144                         *len = READ_U32_LE(buf+4);
 145                         return 1;
 146                 }
 147         }
 148 }
 149
 150 static int find_aiff_chunk(FILE *in, char *type, unsigned int *len)
 151 {
 152         unsigned char buf[8];
 153
 154         while(1)
 155         {
 156                 if(fread(buf,1,8,in) <8)
 157                 {
 158                         fprintf(stderr, _("Warning: Unexpected EOF in AIFF chunk\n"));
 159                         return 0;
 160                 }
 161
 162                 *len = READ_U32_BE(buf+4);
 163
 164                 if(memcmp(buf,type,4))
 165                 {
 166                         if((*len) & 0x1)
 167                                 (*len)++;
 168
 169                         if(!seek_forward(in, *len))
 170                                 return 0;
 171                 }
 172                 else
 173                         return 1;
 174         }
 175 }
 176
 177
 178
 179 double read_IEEE80(unsigned char *buf)
 180 {
 181         int s=buf[0]&0xff;
 182         int e=((buf[0]&0x7f)<<8)|(buf[1]&0xff);
 183         double f=((unsigned long)(buf[2]&0xff)<<24)|
 184                 ((buf[3]&0xff)<<16)|
 185                 ((buf[4]&0xff)<<8) |
 186                  (buf[5]&0xff);
 187
 188         if(e==32767)
 189         {
 190                 if(buf[2]&0x80)
 191                         return HUGE_VAL; /* Really NaN, but this won't happen in reality */
 192                 else
 193                 {
 194                         if(s)
 195                                 return -HUGE_VAL;
 196                         else
 197                                 return HUGE_VAL;
 198                 }
 199         }
 200
 201         f=ldexp(f,32);
 202         f+= ((buf[6]&0xff)<<24)|
 203                 ((buf[7]&0xff)<<16)|
 204                 ((buf[8]&0xff)<<8) |
 205                  (buf[9]&0xff);
 206
 207         return ldexp(f, e-16446);
 208 }
 209
 210 /* AIFF/AIFC support adapted from the old OggSQUISH application */
 211 int aiff_id(unsigned char *buf, int len)
 212 {
 213         if(len<12) return 0; /* Truncated file, probably */
 214
 215         if(memcmp(buf, "FORM", 4))
 216                 return 0;
 217
 218         if(memcmp(buf+8, "AIF",3))
 219                 return 0;
 220
 221         if(buf[11]!='C' && buf[11]!='F')
 222                 return 0;
 223
 224         return 1;
 225 }
 226
 227 int aiff_open(FILE *in, oe_enc_opt *opt, unsigned char *buf, int buflen)
 228 {
 229         int aifc; /* AIFC or AIFF? */
 230         unsigned int len;
 231         unsigned char *buffer;
 232         unsigned char buf2[8];
 233         aiff_fmt format;
 234         aifffile *aiff = malloc(sizeof(aifffile));
 235
 236         if(buf[11]=='C')
 237                 aifc=1;
 238         else
 239                 aifc=0;
 240
 241         if(!find_aiff_chunk(in, "COMM", &len))
 242         {
 243                 fprintf(stderr, _("Warning: No common chunk found in AIFF file\n"));
 244                 return 0; /* EOF before COMM chunk */
 245         }
 246
 247         if(len < 18)
 248         {
 249                 fprintf(stderr, _("Warning: Truncated common chunk in AIFF header\n"));
 250                 return 0; /* Weird common chunk */
 251         }
 252
 253         buffer = alloca(len);
 254
 255         if(fread(buffer,1,len,in) < len)
 256         {
 257                 fprintf(stderr, _("Warning: Unexpected EOF in reading AIFF header\n"));
 258                 return 0;
 259         }
 260
 261         format.channels = READ_U16_BE(buffer);
 262         format.totalframes = READ_U32_BE(buffer+2);
 263         format.samplesize = READ_U16_BE(buffer+6);
 264         format.rate = (int)read_IEEE80(buffer+8);
 265
 266     aiff->bigendian = 1;
 267
 268         if(aifc)
 269         {
 270                 if(len < 22)
 271                 {
 272                         fprintf(stderr, _("Warning: AIFF-C header truncated.\n"));
 273                         return 0;
 274                 }
 275
 276                 if(!memcmp(buffer+18, "NONE", 4))
 277                 {
 278                         aiff->bigendian = 1;
 279                 }
 280                 else if(!memcmp(buffer+18, "sowt", 4))
 281                 {
 282                         aiff->bigendian = 0;
 283                 }
 284                 else
 285                 {
 286                         fprintf(stderr, _("Warning: Can't handle compressed AIFF-C (%c%c%c%c)\n"), *(buffer+18), *(buffer+19), *(buffer+20), *(buffer+21));
 287                         return 0; /* Compressed. Can't handle */
 288                 }
 289         }
 290
 291         if(!find_aiff_chunk(in, "SSND", &len))
 292         {
 293                 fprintf(stderr, _("Warning: No SSND chunk found in AIFF file\n"));
 294                 return 0; /* No SSND chunk -> no actual audio */
 295         }
 296
 297         if(len < 8)
 298         {
 299                 fprintf(stderr, _("Warning: Corrupted SSND chunk in AIFF header\n"));
 300                 return 0;
 301         }
 302
 303         if(fread(buf2,1,8, in) < 8)
 304         {
 305                 fprintf(stderr, _("Warning: Unexpected EOF reading AIFF header\n"));
 306                 return 0;
 307         }
 308
 309         format.offset = READ_U32_BE(buf2);
 310         format.blocksize = READ_U32_BE(buf2+4);
 311
 312         if( format.blocksize == 0 &&
 313                 (format.samplesize == 16 || format.samplesize == 8))
 314         {
 315                 /* From here on, this is very similar to the wav code. Oh well. */
 316
 317                 opt->rate = format.rate;
 318                 opt->channels = format.channels;
 319                 opt->read_samples = wav_read; /* Similar enough, so we use the same */
 320                 opt->total_samples_per_channel = format.totalframes;
 321
 322                 aiff->f = in;
 323                 aiff->samplesread = 0;
 324                 aiff->channels = format.channels;
 325                 aiff->samplesize = format.samplesize;
 326                 aiff->totalsamples = format.totalframes;
 327
 328                 opt->readdata = (void *)aiff;
 329
 330                 seek_forward(in, format.offset); /* Swallow some data */
 331                 return 1;
 332         }
 333         else
 334         {
 335                 fprintf(stderr,
 336                                 _("Warning: OggEnc does not support this type of AIFF/AIFC file\n"
 337                                 " Must be 8 or 16 bit PCM.\n"));
 338                 return 0;
 339         }
 340 }
 341
 342
 343 int wav_id(unsigned char *buf, int len)
 344 {
 345         unsigned int flen;
 346
 347         if(len<12) return 0; /* Something screwed up */
 348
 349         if(memcmp(buf, "RIFF", 4))
 350                 return 0; /* Not wave */
 351
 352         flen = READ_U32_LE(buf+4); /* We don't use this */
 353
 354         if(memcmp(buf+8, "WAVE",4))
 355                 return 0; /* RIFF, but not wave */
 356
 357         return 1;
 358 }
 359
 360 int wav_open(FILE *in, oe_enc_opt *opt, unsigned char *oldbuf, int buflen)
 361 {
 362         unsigned char buf[16];
 363         unsigned int len;
 364         int samplesize;
 365         wav_fmt format;
 366         wavfile *wav = malloc(sizeof(wavfile));
 367
 368         /* Ok. At this point, we know we have a WAV file. Now we have to detect
 369          * whether we support the subtype, and we have to find the actual data
 370          * We don't (for the wav reader) need to use the buffer we used to id this
 371          * as a wav file (oldbuf)
 372          */
 373
 374         if(!find_wav_chunk(in, "fmt ", &len))
 375                 return 0; /* EOF */
 376
 377         if(len < 16)
 378         {
 379                 fprintf(stderr, _("Warning: Unrecognised format chunk in WAV header\n"));
 380                 return 0; /* Weird format chunk */
 381         }
 382
 383         /* A common error is to have a format chunk that is not 16 or 18 bytes
 384          * in size.  This is incorrect, but not fatal, so we only warn about
 385          * it instead of refusing to work with the file.  Please, if you
 386          * have a program that's creating format chunks of sizes other than
 387          * 16 or 18 bytes in size, report a bug to the author.
 388          */
 389         if(len!=16 && len!=18)
 390                 fprintf(stderr,
 391                                 _("Warning: INVALID format chunk in wav header.\n"
 392                                 " Trying to read anyway (may not work)...\n"));
 393
 394         if(fread(buf,1,16,in) < 16)
 395         {
 396                 fprintf(stderr, _("Warning: Unexpected EOF in reading WAV header\n"));
 397                 return 0;
 398         }
 399
 400         /* Deal with stupid broken apps. Don't use these programs.
 401          */
 402         if(len - 16 > 0 && !seek_forward(in, len-16))
 403             return 0;
 404
 405         format.format =      READ_U16_LE(buf);
 406         format.channels =    READ_U16_LE(buf+2);
 407         format.samplerate =  READ_U32_LE(buf+4);
 408         format.bytespersec = READ_U32_LE(buf+8);
 409         format.align =       READ_U16_LE(buf+12);
 410         format.samplesize =  READ_U16_LE(buf+14);
 411
 412         if(!find_wav_chunk(in, "data", &len))
 413                 return 0; /* EOF */
 414
 415         if(format.format == 1)
 416         {
 417                 samplesize = format.samplesize/8;
 418                 opt->read_samples = wav_read;
 419         }
 420         else if(format.format == 3)
 421         {
 422                 samplesize = 4;
 423                 opt->read_samples = wav_ieee_read;
 424         }
 425         else
 426         {
 427                 fprintf(stderr,
 428                                 _("ERROR: Wav file is unsupported type (must be standard PCM\n"
 429                                 " or type 3 floating point PCM\n"));
 430                 return 0;
 431         }
 432
 433
 434
 435         if( format.align == format.channels*samplesize &&
 436                         format.samplesize == samplesize*8 &&
 437                 (format.samplesize == 24 || format.samplesize == 16 ||
 438              format.samplesize == 8 ||
 439              (format.samplesize == 32 && format.format == 3)))
 440         {
 441                 /* OK, good - we have the one supported format,
 442                    now we want to find the size of the file */
 443                 opt->rate = format.samplerate;
 444                 opt->channels = format.channels;
 445
 446                 wav->f = in;
 447                 wav->samplesread = 0;
 448                 wav->bigendian = 0;
 449                 wav->channels = format.channels; /* This is in several places. The price
 450                                                                                         of trying to abstract stuff. */
 451                 wav->samplesize = format.samplesize;
 452
 453                 if(len)
 454         {
 455                         opt->total_samples_per_channel = len/(format.channels*samplesize);
 456                 }
 457                 else
 458                 {
 459                         long pos;
 460                         pos = ftell(in);
 461                         if(fseek(in, 0, SEEK_END) == -1)
 462                         {
 463                                 opt->total_samples_per_channel = 0; /* Give up */
 464                         }
 465                         else
 466                         {
 467                                 opt->total_samples_per_channel = (ftell(in) - pos)/
 468                     (format.channels*samplesize);
 469                                 fseek(in,pos, SEEK_SET);
 470                         }
 471                 }
 472                 wav->totalsamples = opt->total_samples_per_channel;
 473
 474                 opt->readdata = (void *)wav;
 475                 return 1;
 476         }
 477         else
 478         {
 479                 fprintf(stderr,
 480                                 _("ERROR: Wav file is unsupported subformat (must be 8,16, or 24 bit PCM\n"
 481                                 "or floating point PCM\n"));
 482                 return 0;
 483         }
 484 }
 485
 486 long wav_read(void *in, float **buffer, int samples)
 487 {
 488         wavfile *f = (wavfile *)in;
 489         int sampbyte = f->samplesize / 8;
 490         signed char *buf = alloca(samples*sampbyte*f->channels);
 491         long bytes_read = fread(buf, 1, samples*sampbyte*f->channels, f->f);
 492         int i,j;
 493         long realsamples;
 494
 495         if(f->totalsamples && f->samplesread +
 496                         bytes_read/(sampbyte*f->channels) > f->totalsamples) {
 497                 bytes_read = sampbyte*f->channels*(f->totalsamples - f->samplesread);
 498     }
 499
 500         realsamples = bytes_read/(sampbyte*f->channels);
 501         f->samplesread += realsamples;
 502
 503         if(f->samplesize==8)
 504         {
 505                 unsigned char *bufu = (unsigned char *)buf;
 506                 for(i = 0; i < realsamples; i++)
 507                 {
 508                         for(j=0; j < f->channels; j++)
 509                         {
 510                                 buffer[j][i]=((int)(bufu[i*f->channels + j])-128)/128.0f;
 511                         }
 512                 }
 513         }
 514         else if(f->samplesize==16)
 515         {
 516                 if(!f->bigendian)
 517                 {
 518                         for(i = 0; i < realsamples; i++)
 519                         {
 520                                 for(j=0; j < f->channels; j++)
 521                                 {
 522                                         buffer[j][i] = ((buf[i*2*f->channels + 2*j + 1]<<8) |
 523                                                                 (buf[i*2*f->channels + 2*j] & 0xff))/32768.0f;
 524                                 }
 525                         }
 526                 }
 527                 else
 528                 {
 529                         for(i = 0; i < realsamples; i++)
 530                         {
 531                                 for(j=0; j < f->channels; j++)
 532                                 {
 533                                         buffer[j][i]=((buf[i*2*f->channels + 2*j]<<8) |
 534                                                               (buf[i*2*f->channels + 2*j + 1] & 0xff))/32768.0f;
 535                                 }
 536                         }
 537                 }
 538         }
 539     else if(f->samplesize==24)
 540     {
 541         if(!f->bigendian) {
 542             for(i = 0; i < realsamples; i++)
 543             {
 544                 for(j=0; j < f->channels; j++)
 545                 {
 546                     buffer[j][i] = ((buf[i*3*f->channels + 3*j + 2] << 16) |
 547                       (((unsigned char *)buf)[i*3*f->channels + 3*j + 1] << 8) |
 548                       (((unsigned char *)buf)[i*3*f->channels + 3*j] & 0xff))
 549                         / 8388608.0f;
 550
 551                 }
 552             }
 553         }
 554         else {
 555             fprintf(stderr, _("Big endian 24 bit PCM data is not currently "
 556                               "supported, aborting.\n"));
 557             return 0;
 558         }
 559     }
 560     else {
 561         fprintf(stderr, _("Internal error: attempt to read unsupported "
 562                           "bitdepth %d\n"), f->samplesize);
 563         return 0;
 564     }
 565
 566         return realsamples;
 567 }
 568
 569 long wav_ieee_read(void *in, float **buffer, int samples)
 570 {
 571         wavfile *f = (wavfile *)in;
 572         float *buf = alloca(samples*4*f->channels); /* de-interleave buffer */
 573         long bytes_read = fread(buf,1,samples*4*f->channels, f->f);
 574         int i,j;
 575         long realsamples;
 576
 577
 578         if(f->totalsamples && f->samplesread +
 579                         bytes_read/(4*f->channels) > f->totalsamples)
 580                 bytes_read = 4*f->channels*(f->totalsamples - f->samplesread);
 581         realsamples = bytes_read/(4*f->channels);
 582         f->samplesread += realsamples;
 583
 584         for(i=0; i < realsamples; i++)
 585                 for(j=0; j < f->channels; j++)
 586                         buffer[j][i] = buf[i*f->channels + j];
 587
 588         return realsamples;
 589 }
 590
 591
 592 void wav_close(void *info)
 593 {
 594         wavfile *f = (wavfile *)info;
 595
 596         free(f);
 597 }
 598
 599 int raw_open(FILE *in, oe_enc_opt *opt, unsigned char *buf, int buflen)
 600 {
 601         wav_fmt format; /* fake wave header ;) */
 602         wavfile *wav = malloc(sizeof(wavfile));
 603
 604         /* construct fake wav header ;) */
 605         format.format =      2;
 606         format.channels =    opt->channels;
 607         format.samplerate =  opt->rate;
 608         format.samplesize =  opt->samplesize;
 609         format.bytespersec = opt->channels * opt->rate * opt->samplesize / 8;
 610         format.align =       format.bytespersec;
 611         wav->f =             in;
 612         wav->samplesread =   0;
 613         wav->bigendian =     opt->endianness;
 614         wav->channels =      format.channels;
 615         wav->samplesize =    opt->samplesize;
 616     wav->totalsamples =  0;
 617
 618         opt->read_samples = wav_read;
 619         opt->readdata = (void *)wav;
 620         opt->total_samples_per_channel = 0; /* raw mode, don't bother */
 621         return 1;
 622 }
 623
 624 typedef struct {
 625     res_state resampler;
 626     audio_read_func real_reader;
 627     void *real_readdata;
 628     float **bufs;
 629     int channels;
 630     int bufsize;
 631     int done;
 632 } resampler;
 633
 634 static long read_resampled(void *d, float **buffer, int samples)
 635 {
 636     resampler *rs = d;
 637     long in_samples;
 638     int out_samples;
 639
 640     in_samples = res_push_max_input(&rs->resampler, samples);
 641     if(in_samples > rs->bufsize)
 642         in_samples = rs->bufsize;
 643
 644     in_samples = rs->real_reader(rs->real_readdata, rs->bufs, in_samples);
 645
 646     if(in_samples <= 0) {
 647         if(!rs->done) {
 648             rs->done = 1;
 649             out_samples = res_drain(&rs->resampler, buffer);
 650             return out_samples;
 651         }
 652         return 0;
 653     }
 654
 655     out_samples = res_push(&rs->resampler, buffer, (float const **)rs->bufs, in_samples);
 656
 657     if(out_samples <= 0) {
 658         fprintf(stderr, _("BUG: Got zero samples from resampler: your file will be truncated. Please report this.\n"));
 659     }
 660
 661     return out_samples;
 662 }
 663
 664 int setup_resample(oe_enc_opt *opt) {
 665     resampler *rs = calloc(1, sizeof(resampler));
 666     int c;
 667
 668     rs->bufsize = 4096; /* Shrug */
 669     rs->real_reader = opt->read_samples;
 670     rs->real_readdata = opt->readdata;
 671     rs->bufs = malloc(sizeof(float *) * opt->channels);
 672     rs->channels = opt->channels;
 673     rs->done = 0;
 674     if(res_init(&rs->resampler, rs->channels, opt->resamplefreq, opt->rate, RES_END))
 675     {
 676         fprintf(stderr, _("Couldn't initialise resampler\n"));
 677         return -1;
 678     }
 679
 680     for(c=0; c < opt->channels; c++)
 681         rs->bufs[c] = malloc(sizeof(float) * rs->bufsize);
 682
 683     opt->read_samples = read_resampled;
 684     opt->readdata = rs;
 685     if(opt->total_samples_per_channel)
 686         opt->total_samples_per_channel = (int)((float)opt->total_samples_per_channel *
 687             ((float)opt->resamplefreq/(float)opt->rate));
 688     opt->rate = opt->resamplefreq;
 689
 690     return 0;
 691 }
 692
 693 void clear_resample(oe_enc_opt *opt) {
 694     resampler *rs = opt->readdata;
 695     int i;
 696
 697     opt->read_samples = rs->real_reader;
 698     opt->readdata = rs->real_readdata;
 699     res_clear(&rs->resampler);
 700
 701     for(i = 0; i < rs->channels; i++)
 702         free(rs->bufs[i]);
 703
 704     free(rs->bufs);
 705
 706     free(rs);
 707 }
 708
 709 typedef struct {
 710     audio_read_func real_reader;
 711     void *real_readdata;
 712     int channels;
 713     float scale_factor;
 714 } scaler;
 715
 716 static long read_scaler(void *data, float **buffer, int samples) {
 717     scaler *d = data;
 718     long in_samples = d->real_reader(d->real_readdata, buffer, samples);
 719     int i,j;
 720
 721     for(i=0; i < d->channels; i++) {
 722         for(j=0; j < in_samples; j++) {
 723             buffer[i][j] *= d->scale_factor;
 724         }
 725     }
 726
 727     return in_samples;
 728 }
 729
 730
 731 void setup_scaler(oe_enc_opt *opt, float scale) {
 732     scaler *d = calloc(1, sizeof(scaler));
 733
 734     d->real_reader = opt->read_samples;
 735     d->real_readdata = opt->readdata;
 736
 737     opt->read_samples = read_scaler;
 738     opt->readdata = d;
 739     d->channels = opt->channels;
 740     d->scale_factor = scale;
 741 }
 742
 743 void clear_scaler(oe_enc_opt *opt) {
 744     scaler *d = opt->readdata;
 745
 746     opt->read_samples = d->real_reader;
 747     opt->readdata = d->real_readdata;
 748
 749     free(d);
 750 }
 751
 752 typedef struct {
 753     audio_read_func real_reader;
 754     void *real_readdata;
 755     float **bufs;
 756 } downmix;
 757
 758 static long read_downmix(void *data, float **buffer, int samples)
 759 {
 760     downmix *d = data;
 761     long in_samples = d->real_reader(d->real_readdata, d->bufs, samples);
 762     int i;
 763
 764     for(i=0; i < in_samples; i++) {
 765         buffer[0][i] = (d->bufs[0][i] + d->bufs[1][i])*0.5f;
 766         fprintf(stderr, "%f %f -> %f\n", d->bufs[0][i] , d->bufs[1][i], buffer[0][i]);
 767     }
 768
 769     return in_samples;
 770 }
 771
 772 void setup_downmix(oe_enc_opt *opt) {
 773     downmix *d = calloc(1, sizeof(downmix));
 774
 775     if(opt->channels != 2) {
 776         fprintf(stderr, "Internal error! Please report this bug.\n");
 777         return;
 778     }
 779
 780     d->bufs = malloc(2 * sizeof(float *));
 781     d->bufs[0] = malloc(4096 * sizeof(float));
 782     d->bufs[1] = malloc(4096 * sizeof(float));
 783     d->real_reader = opt->read_samples;
 784
 785     d->real_readdata = opt->readdata;
 786
 787     opt->read_samples = read_downmix;
 788     opt->readdata = d;
 789
 790     opt->channels = 1;
 791 }
 792 void clear_downmix(oe_enc_opt *opt) {
 793     downmix *d = opt->readdata;
 794
 795     opt->read_samples = d->real_reader;
 796     opt->readdata = d->real_readdata;
 797     opt->channels = 2; /* other things in cleanup rely on this */
 798
 799     free(d->bufs[0]);
 800     free(d->bufs[1]);
 801     free(d->bufs);
 802     free(d);
 803 }
 804