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