opusenc: Avoid resampler fractional sample offset
[opus-tools.git] / src / audio-in.c
1 /* Copyright 2000-2002, Michael Smith <msmith@xiph.org>
2              2010, Monty <monty@xiph.org>
3    AIFF/AIFC support from OggSquish, (c) 1994-1996 Monty <xiphmont@xiph.org>
4    (From GPL code in oggenc relicensed by permission from Monty and Msmith)
5    File: audio-in.c
6
7    Redistribution and use in source and binary forms, with or without
8    modification, are permitted provided that the following conditions
9    are met:
10
11    - Redistributions of source code must retain the above copyright
12    notice, this list of conditions and the following disclaimer.
13
14    - Redistributions in binary form must reproduce the above copyright
15    notice, this list of conditions and the following disclaimer in the
16    documentation and/or other materials provided with the distribution.
17
18    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
22    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #ifdef HAVE_CONFIG_H
32 # include <config.h>
33 #endif
34
35 #if !defined(_LARGEFILE_SOURCE)
36 # define _LARGEFILE_SOURCE
37 #endif
38 #if !defined(_LARGEFILE64_SOURCE)
39 # define _LARGEFILE64_SOURCE
40 #endif
41 #if !defined(_FILE_OFFSET_BITS)
42 # define _FILE_OFFSET_BITS 64
43 #endif
44
45 #include <limits.h>
46 #include <stdlib.h>
47 #include <stdio.h>
48 #include <string.h>
49 #include <sys/types.h>
50 #include <math.h>
51
52 #include "stack_alloc.h"
53
54 #ifdef WIN32
55 # include <windows.h> /*GetFileType()*/
56 # include <io.h>      /*_get_osfhandle()*/
57 #endif
58
59 #ifdef ENABLE_NLS
60 #include <libintl.h>
61 #define _(X) gettext(X)
62 #else
63 #define _(X) (X)
64 #define textdomain(X)
65 #define bindtextdomain(X, Y)
66 #endif
67 #ifdef gettext_noop
68 #define N_(X) gettext_noop(X)
69 #else
70 #define N_(X) (X)
71 #endif
72
73 #include <ogg/ogg.h>
74 #include "opusenc.h"
75 #include "speex_resampler.h"
76 #include "lpc.h"
77 #include "opus_header.h"
78 #include "flac.h"
79
80 /* Macros for handling potentially large file offsets */
81 #if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
82 # define OFF_T __int64
83 # define FSEEK _fseeki64
84 # define FTELL _ftelli64
85 #elif defined HAVE_FSEEKO
86 # define OFF_T off_t
87 # define FSEEK fseeko
88 # define FTELL ftello
89 #else
90 # define OFF_T long
91 # define FSEEK fseek
92 # define FTELL ftell
93 #endif
94
95 /* Macros to read header data */
96 #define READ_U32_LE(buf) \
97     (((unsigned int)(buf)[3]<<24)|((buf)[2]<<16)|((buf)[1]<<8)|((buf)[0]))
98
99 #define READ_U16_LE(buf) \
100     (((buf)[1]<<8)|((buf)[0]&0xff))
101
102 #define READ_U32_BE(buf) \
103     (((unsigned int)(buf)[0]<<24)|((buf)[1]<<16)|((buf)[2]<<8)|((buf)[3]))
104
105 #define READ_U16_BE(buf) \
106     (((buf)[0]<<8)|((buf)[1]&0xff))
107
108 /* Define the supported formats here */
109 input_format formats[] = {
110     {wav_id, 12, wav_open, wav_close, "wav", N_("WAV file reader")},
111     {aiff_id, 12, aiff_open, wav_close, "aiff", N_("AIFF/AIFC file reader")},
112     {flac_id,     4, flac_open, flac_close, "flac", N_("FLAC file reader")},
113     {oggflac_id, 33, flac_open, flac_close, "ogg", N_("Ogg FLAC file reader")},
114     {NULL, 0, NULL, NULL, NULL, NULL}
115 };
116
117 input_format *open_audio_file(FILE *in, oe_enc_opt *opt)
118 {
119     int j=0;
120     unsigned char *buf=NULL;
121     int buf_size=0, buf_filled=0;
122     int size,ret;
123
124     while(formats[j].id_func)
125     {
126         size = formats[j].id_data_len;
127         if(size >= buf_size)
128         {
129             buf = realloc(buf, size);
130             buf_size = size;
131         }
132
133         if(size > buf_filled)
134         {
135             ret = fread(buf+buf_filled, 1, buf_size-buf_filled, in);
136             buf_filled += ret;
137
138             if(buf_filled < size)
139             { /* File truncated */
140                 j++;
141                 continue;
142             }
143         }
144
145         if(formats[j].id_func(buf, buf_filled))
146         {
147             /* ok, we now have something that can handle the file */
148             if(formats[j].open_func(in, opt, buf, buf_filled)) {
149                 free(buf);
150                 return &formats[j];
151             }
152         }
153         j++;
154     }
155
156     free(buf);
157
158     return NULL;
159 }
160
161 static void sanitize_fourcc(unsigned char *buf)
162 {
163     int i;
164     for(i = 0; i < 4; ++i)
165         if(buf[i] < ' ' || buf[i] > '~')
166             buf[i] = '?';
167 }
168
169 static int seek_forward(FILE *in, ogg_int64_t length)
170 {
171     ogg_int64_t remaining = length;
172     while(remaining > 0)
173     {
174         /* When OFF_T is 64 bits, only one seek is needed and the comparison
175          * will always be false. When OFF_T is not large enough, seek LONG_MAX
176          * bytes at a time (the maximum offset that basic fseek() can handle).
177          */
178         OFF_T seekstep = (OFF_T)remaining;
179         if (seekstep != remaining)
180             seekstep = LONG_MAX;
181         if(FSEEK(in, seekstep, SEEK_CUR))
182         {
183             /* Failed to seek; do it by reading. */
184             unsigned char buf[1024];
185             do {
186                 size_t readstep = remaining > 1024 ? 1024 : (size_t)remaining;
187                 readstep = fread(buf, 1, readstep, in);
188                 if(!readstep)
189                     return 0; /* Couldn't read more, can't read file */
190                 remaining -= readstep;
191             } while (remaining);
192             break;
193         }
194         remaining -= seekstep;
195     }
196     return 1;
197 }
198
199 static int find_wav_chunk(FILE *in, char *type, unsigned int *len)
200 {
201     unsigned char buf[8];
202     unsigned int chunklen;
203
204     while(1)
205     {
206         if(fread(buf,1,8,in) < 8) /* Suck down a chunk specifier */
207             return 0; /* EOF before reaching the appropriate chunk */
208
209         chunklen = READ_U32_LE(buf+4);
210
211         if(memcmp(buf, type, 4))
212         {
213             sanitize_fourcc(buf);
214             fprintf(stderr, _("Skipping chunk of type \"%.4s\", length %u\n"),
215                 buf, chunklen);
216
217             if(!seek_forward(in, (ogg_int64_t)chunklen + (chunklen & 1)))
218                 return 0;
219         }
220         else
221         {
222             *len = chunklen;
223             return 1;
224         }
225     }
226 }
227
228 static int find_aiff_chunk(FILE *in, char *type, unsigned int *len)
229 {
230     unsigned char buf[8];
231     unsigned int chunklen;
232     int restarted = 0;
233
234     while(1)
235     {
236         if(fread(buf,1,8,in) < 8)
237         {
238             if(!restarted) {
239                 /* Handle out of order chunks by seeking back to the start
240                  * to retry */
241                 restarted = 1;
242                 if(!FSEEK(in, 12, SEEK_SET))
243                     continue;
244             }
245             return 0;
246         }
247
248         chunklen = READ_U32_BE(buf+4);
249
250         if(memcmp(buf,type,4))
251         {
252             if(!seek_forward(in, (ogg_int64_t)chunklen + (chunklen & 1)))
253                 return 0;
254         }
255         else
256         {
257             *len = chunklen;
258             return 1;
259         }
260     }
261 }
262
263 /* Read chunk of size *len and advance the file position to the next chunk.
264  * Returns 0 on EOF or read error. Otherwise *len is updated with the number
265  * of bytes placed in the buffer (the lesser of the chunk size and buffer
266  * size) and 1 is returned.
267  */
268 static int read_chunk(FILE *in, unsigned char *buf, unsigned int bufsize,
269         unsigned int *len)
270 {
271     unsigned int chunklen = *len;
272     unsigned int readlen = chunklen > bufsize ? bufsize : chunklen;
273
274     if(fread(buf, 1, readlen, in) != readlen)
275         return 0;
276
277     if(!seek_forward(in, (ogg_int64_t)(chunklen - readlen) + (chunklen & 1)))
278         return 0;
279
280     *len = readlen;
281     return 1;
282 }
283
284 static double read_IEEE80(unsigned char *buf)
285 {
286     int e = READ_U16_BE(buf) & 0x7fff;
287     double f;
288     if(e==32767)
289         /* NaNs and infinities -- their format can vary among implementations,
290            but for our purposes they can all be treated as infinite. */
291         f = HUGE_VAL;
292     else
293         f = ldexp(READ_U32_BE(buf+2) + READ_U32_BE(buf+6)*ldexp(1.0, -32), e-16383-31);
294     return (buf[0]&0x80)?-f:f;
295 }
296
297 /* AIFF/AIFC support adapted from the old OggSQUISH application */
298 int aiff_id(unsigned char *buf, int len)
299 {
300     if(len<12) return 0; /* Truncated file, probably */
301
302     if(memcmp(buf, "FORM", 4))
303         return 0;
304
305     if(memcmp(buf+8, "AIF",3))
306         return 0;
307
308     if(buf[11]!='C' && buf[11]!='F')
309         return 0;
310
311     return 1;
312 }
313
314 static int aiff_permute_matrix[6][6] =
315 {
316   {0},              /* 1.0 mono   */
317   {0,1},            /* 2.0 stereo */
318   {0,2,1},          /* 3.0 channel ('wide') stereo */
319   {0,1,2,3},        /* 4.0 discrete quadraphonic (WARN) */
320   {0,2,1,3,4},      /* 5.0 surround (WARN) */
321   {0,1,2,3,4,5},    /* 5.1 surround (WARN)*/
322 };
323
324 int aiff_open(FILE *in, oe_enc_opt *opt, unsigned char *buf, int buflen)
325 {
326     int aifc; /* AIFC or AIFF? */
327     unsigned int len;
328     unsigned char buffer[22];
329     unsigned char buf2[8];
330     int bigendian = 1;
331     aiff_fmt format;
332     aifffile *aiff;
333     int i;
334     (void)buflen;/*unused*/
335
336     if(buf[11]=='C')
337         aifc=1;
338     else
339         aifc=0;
340
341     if(!find_aiff_chunk(in, "COMM", &len))
342     {
343         fprintf(stderr, _("ERROR: No common chunk found in AIFF file\n"));
344         return 0; /* EOF before COMM chunk */
345     }
346
347     if(len < 18 || !read_chunk(in, buffer, sizeof(buffer), &len))
348     {
349         fprintf(stderr, _("ERROR: Incomplete common chunk in AIFF header\n"));
350         return 0;
351     }
352
353     format.channels = (short)READ_U16_BE(buffer);
354     format.totalframes = READ_U32_BE(buffer+2);
355     format.samplesize = (short)READ_U16_BE(buffer+6);
356     format.rate = read_IEEE80(buffer+8);
357
358     if(format.channels <= 0)
359     {
360         fprintf(stderr, _("ERROR: Invalid channel count in AIFF header\n"));
361         return 0;
362     }
363
364     if(aifc)
365     {
366         if(len < 22)
367         {
368             fprintf(stderr, _("ERROR: AIFF-C header truncated.\n"));
369             return 0;
370         }
371
372         if(!memcmp(buffer+18, "NONE", 4))
373         {
374             bigendian = 1;
375         }
376         else if(!memcmp(buffer+18, "sowt", 4))
377         {
378             bigendian = 0;
379         }
380         else
381         {
382             sanitize_fourcc(buffer+18);
383             fprintf(stderr, _("ERROR: Can't handle compressed AIFF-C \"%.4s\"\n"),
384                 buffer+18);
385             return 0; /* Compressed. Can't handle */
386         }
387     }
388
389     if(!(format.rate >= 1 && format.rate <= INT_MAX))
390     {
391         fprintf(stderr, _("ERROR: Preposterous sample rate in AIFF header: %g Hz\n"),
392             format.rate);
393         return 0;
394     }
395
396     if(!find_aiff_chunk(in, "SSND", &len))
397     {
398         fprintf(stderr, _("ERROR: No SSND chunk found in AIFF file\n"));
399         return 0; /* No SSND chunk -> no actual audio */
400     }
401
402     if(len < 8)
403     {
404         fprintf(stderr, _("ERROR: Corrupted SSND chunk in AIFF header\n"));
405         return 0;
406     }
407
408     if(fread(buf2,1,8, in) < 8)
409     {
410         fprintf(stderr, _("ERROR: Unexpected EOF reading AIFF header\n"));
411         return 0;
412     }
413
414     format.offset = READ_U32_BE(buf2);
415     format.blocksize = READ_U32_BE(buf2+4);
416
417     if( format.blocksize == 0 &&
418         (format.samplesize == 16 || format.samplesize == 8))
419     {
420         /* From here on, this is very similar to the wav code. Oh well. */
421
422         opt->rate = (int)(format.rate + 0.5);  /* round to nearest integer */
423         opt->channels = format.channels;
424         opt->samplesize = format.samplesize;
425         opt->read_samples = wav_read; /* Similar enough, so we use the same */
426         opt->total_samples_per_channel = format.totalframes;
427
428         aiff = malloc(sizeof(aifffile));
429         aiff->f = in;
430         aiff->samplesread = 0;
431         aiff->channels = format.channels;
432         aiff->samplesize = format.samplesize;
433         aiff->totalsamples = format.totalframes;
434         aiff->bigendian = bigendian;
435         aiff->unsigned8bit = 0;
436
437         if(aiff->channels>3)
438           fprintf(stderr, _("WARNING: AIFF[-C] files with more than three channels use\n"
439                   "speaker locations incompatible with Vorbis surround definitions.\n"
440                   "Not performing channel location mapping.\n"));
441
442         opt->readdata = (void *)aiff;
443
444         aiff->channel_permute = malloc(aiff->channels * sizeof(int));
445         if (aiff->channels <= 6)
446             /* Where we know the mappings, use them. */
447             memcpy(aiff->channel_permute, aiff_permute_matrix[aiff->channels-1],
448                     sizeof(int) * aiff->channels);
449         else
450             /* Use a default 1-1 mapping */
451             for (i=0; i < aiff->channels; i++)
452                 aiff->channel_permute[i] = i;
453
454         seek_forward(in, format.offset); /* Swallow some data */
455         return 1;
456     }
457     else
458     {
459         fprintf(stderr, _("ERROR: Unsupported AIFF/AIFC file.\n"
460                 "Must be 8 or 16 bit PCM.\n"));
461         return 0;
462     }
463 }
464
465 int wav_id(unsigned char *buf, int len)
466 {
467     if(len<12) return 0; /* Something screwed up */
468
469     if(memcmp(buf, "RIFF", 4))
470         return 0; /* Not wave */
471
472     /*flen = READ_U32_LE(buf+4);*/ /* We don't use this */
473
474     if(memcmp(buf+8, "WAVE",4))
475         return 0; /* RIFF, but not wave */
476
477     return 1;
478 }
479
480 int wav_open(FILE *in, oe_enc_opt *opt, unsigned char *oldbuf, int buflen)
481 {
482     unsigned char buf[40];
483     unsigned int len;
484     int samplesize;
485     int validbits;
486     wav_fmt format;
487     wavfile *wav;
488     int i;
489     (void)buflen;/*unused*/
490     (void)oldbuf;/*unused*/
491
492     /* Ok. At this point, we know we have a WAV file. Now we have to detect
493      * whether we support the subtype, and we have to find the actual data
494      * We don't (for the wav reader) need to use the buffer we used to id this
495      * as a wav file (oldbuf)
496      */
497
498     if(!find_wav_chunk(in, "fmt ", &len))
499     {
500         fprintf(stderr, _("ERROR: No format chunk found in WAV file\n"));
501         return 0;
502     }
503
504     if(len < 16)
505     {
506         fprintf(stderr, _("ERROR: Unrecognised format chunk in WAV header\n"));
507         return 0; /* Weird format chunk */
508     }
509
510     /* A common error is to have a format chunk that is not 16, 18 or
511      * 40 bytes in size.  This is incorrect, but not fatal, so we only
512      * warn about it instead of refusing to work with the file.
513      * Please, if you have a program that's creating format chunks of
514      * sizes other than 16 or 18 bytes in size, report a bug to the
515      * author.
516      */
517     if(len!=16 && len!=18 && len!=40)
518         fprintf(stderr,
519                 _("Warning: INVALID format chunk in wav header.\n"
520                 " Trying to read anyway (may not work)...\n"));
521
522     if(!read_chunk(in, buf, sizeof(buf), &len))
523     {
524         fprintf(stderr, _("ERROR: Incomplete format chunk in WAV header\n"));
525         return 0;
526     }
527
528     format.format =      READ_U16_LE(buf);
529     format.channels =    READ_U16_LE(buf+2);
530     format.samplerate =  READ_U32_LE(buf+4);
531     format.bytespersec = READ_U32_LE(buf+8);
532     format.align =       READ_U16_LE(buf+12);
533     format.samplesize =  READ_U16_LE(buf+14);
534
535     if(format.channels == 0)
536     {
537         fprintf(stderr, _("ERROR: Zero channels in WAV header\n"));
538         return 0;
539     }
540
541     if(format.format == 0xfffe) /* WAVE_FORMAT_EXTENSIBLE */
542     {
543       if(len<40)
544       {
545         fprintf(stderr, _("ERROR: Extended WAV format header invalid (too small)\n"));
546         return 0;
547       }
548
549       validbits = READ_U16_LE(buf+18);
550       if(validbits < 1 || validbits > format.samplesize)
551         validbits = format.samplesize;
552
553       format.mask = READ_U32_LE(buf+20);
554       /* warn the user if the format mask is not a supported/expected type */
555       switch(format.mask){
556       case 1539: /* 4.0 using side surround instead of back */
557         fprintf(stderr, _("WARNING: WAV file uses side surround instead of rear for quadraphonic;\n"
558                 "remapping side speakers to rear in encoding.\n"));
559         break;
560       case 1551: /* 5.1 using side instead of rear */
561         fprintf(stderr, _("WARNING: WAV file uses side surround instead of rear for 5.1;\n"
562                 "remapping side speakers to rear in encoding.\n"));
563         break;
564       case 319:  /* 6.1 using rear instead of side */
565         fprintf(stderr, _("WARNING: WAV file uses rear surround instead of side for 6.1;\n"
566                 "remapping rear speakers to side in encoding.\n"));
567         break;
568       case 255:  /* 7.1 'Widescreen' */
569         fprintf(stderr, _("WARNING: WAV file is a 7.1 'Widescreen' channel mapping;\n"
570                 "remapping speakers to Vorbis 7.1 format.\n"));
571         break;
572       case 0:    /* default/undeclared */
573       case 1:    /* mono (left only) */
574       case 4:    /* mono (center only) */
575       case 3:    /* stereo */
576       case 51:   /* quad */
577       case 55:   /* 5.0 */
578       case 63:   /* 5.1 */
579       case 1807: /* 6.1 */
580       case 1599: /* 7.1 */
581         break;
582       default:
583         fprintf(stderr, _("WARNING: Unknown WAV surround channel mask: %u\n"
584                 "Blindly mapping speakers using default SMPTE/ITU ordering.\n"),
585                 format.mask);
586         break;
587       }
588       format.format = READ_U16_LE(buf+24);
589     }
590     else
591     {
592       validbits = format.samplesize;
593     }
594
595     if(format.format == 1)
596     {
597         samplesize = format.samplesize/8;
598         opt->read_samples = wav_read;
599     }
600     else if(format.format == 3)
601     {
602         validbits = 24;
603         samplesize = 4;
604         opt->read_samples = wav_ieee_read;
605     }
606     else
607     {
608         fprintf(stderr, _("ERROR: Unsupported WAV file type.\n"
609                 "Must be standard PCM or type 3 floating point PCM.\n"));
610         return 0;
611     }
612
613     if(format.samplerate > INT_MAX)
614     {
615         fprintf(stderr, _("ERROR: Preposterous sample rate in WAV header: %u Hz\n"),
616             format.samplerate);
617         return 0;
618     }
619
620     if(!find_wav_chunk(in, "data", &len))
621     {
622         fprintf(stderr, _("ERROR: No data chunk found in WAV file\n"));
623         return 0;
624     }
625
626     if(format.align != format.channels * samplesize) {
627         /* This is incorrect according to the spec. Warn loudly, then ignore
628          * this value.
629          */
630         fprintf(stderr, _("Warning: WAV 'block alignment' value is incorrect, "
631                     "ignoring.\n"
632                     "The software that created this file is incorrect.\n"));
633     }
634
635     if(format.samplesize == samplesize*8 &&
636             (format.samplesize == 24 || format.samplesize == 16 ||
637              format.samplesize == 8 ||
638          (format.samplesize == 32 && format.format == 3)))
639     {
640         /* OK, good - we have the one supported format,
641            now we want to find the size of the file */
642         opt->rate = format.samplerate;
643         opt->channels = format.channels;
644         opt->samplesize = validbits;
645         opt->total_samples_per_channel = 0;
646
647         wav = malloc(sizeof(wavfile));
648         wav->f = in;
649         wav->samplesread = 0;
650         wav->bigendian = 0;
651         wav->unsigned8bit = format.samplesize == 8;
652         wav->channels = format.channels; /* This is in several places. The price
653                                             of trying to abstract stuff. */
654         wav->samplesize = format.samplesize;
655         wav->totalsamples = 0;
656
657         if(len>(format.channels*samplesize*4U) && len<((1U<<31)-65536) && opt->ignorelength!=1)
658         {
659             /* Chunk length is plausible.  Limit the audio data read to
660                this length so that we do not misinterpret any additional
661                chunks after this as audio.  Also use this length to report
662                percent progress. */
663             wav->totalsamples = opt->total_samples_per_channel =
664                 len/(format.channels*samplesize);
665         }
666 #ifdef WIN32
667         /*On Mingw/Win32 fseek() returns zero on pipes.*/
668         else if (opt->ignorelength==1 || ((GetFileType((HANDLE)_get_osfhandle(fileno(in)))&~FILE_TYPE_REMOTE)!=FILE_TYPE_DISK))
669 #else
670         else if (opt->ignorelength==1)
671 #endif
672         {
673             /* Assume audio data continues until EOF.
674                No percent progress will be reported. */
675         }
676         else
677         {
678             /* Assume audio data continues until EOF.
679                If the stream is seekable and the current file size can
680                be determined, use that to estimate percent progress
681                (opt->total_samples_per_channel), but not to limit the
682                number of samples read (wav->totalsamples).  Continue to
683                read until EOF even if the file grows while reading. */
684             OFF_T pos[2];
685             pos[0] = FTELL(in);
686             if(pos[0] >= 0 && !FSEEK(in, 0, SEEK_END))
687             {
688                 pos[1] = FTELL(in);
689                 FSEEK(in, pos[0], SEEK_SET);
690                 if(pos[1] > pos[0])
691                     opt->total_samples_per_channel = (pos[1]-pos[0])/(format.channels*samplesize);
692             }
693         }
694
695         opt->readdata = (void *)wav;
696
697         wav->channel_permute = malloc(wav->channels * sizeof(int));
698         if (wav->channels <= 8)
699             /* Where we know the mappings, use them. */
700             memcpy(wav->channel_permute, wav_permute_matrix[wav->channels-1],
701                     sizeof(int) * wav->channels);
702         else
703             /* Use a default 1-1 mapping */
704             for (i=0; i < wav->channels; i++)
705                 wav->channel_permute[i] = i;
706
707         return 1;
708     }
709     else
710     {
711         fprintf(stderr, _("ERROR: Unsupported WAV sample size.\n"
712                 "Must be 8, 16, or 24 bit PCM or 32 bit floating point PCM.\n"));
713         return 0;
714     }
715 }
716
717 long wav_read(void *in, float *buffer, int samples)
718 {
719     wavfile *f = (wavfile *)in;
720     int sampbyte = f->samplesize / 8;
721     int realsamples = f->totalsamples > 0 && samples > (f->totalsamples - f->samplesread)
722         ? f->totalsamples - f->samplesread : samples;
723     signed char *buf = alloca(realsamples*sampbyte*f->channels);
724     int i,j;
725     int *ch_permute = f->channel_permute;
726
727     realsamples = fread(buf, sampbyte*f->channels, realsamples, f->f);
728     f->samplesread += realsamples;
729
730     if(f->samplesize==8)
731     {
732         if(f->unsigned8bit)
733         {
734             unsigned char *bufu = (unsigned char *)buf;
735             for(i = 0; i < realsamples; i++)
736             {
737                 for(j=0; j < f->channels; j++)
738                 {
739                     buffer[i*f->channels+j]=((int)(bufu[i*f->channels + ch_permute[j]])-128)/128.0f;
740                 }
741             }
742         }
743         else
744         {
745             for(i = 0; i < realsamples; i++)
746             {
747                 for(j=0; j < f->channels; j++)
748                 {
749                     buffer[i*f->channels+j]=buf[i*f->channels + ch_permute[j]]/128.0f;
750                 }
751             }
752         }
753     }
754     else if(f->samplesize==16)
755     {
756         if(!f->bigendian)
757         {
758             for(i = 0; i < realsamples; i++)
759             {
760                 for(j=0; j < f->channels; j++)
761                 {
762                     buffer[i*f->channels+j] = ((buf[i*2*f->channels + 2*ch_permute[j] + 1]<<8) |
763                                     (buf[i*2*f->channels + 2*ch_permute[j]] & 0xff))/32768.0f;
764                 }
765             }
766         }
767         else
768         {
769             for(i = 0; i < realsamples; i++)
770             {
771                 for(j=0; j < f->channels; j++)
772                 {
773                     buffer[i*f->channels+j]=((buf[i*2*f->channels + 2*ch_permute[j]]<<8) |
774                                   (buf[i*2*f->channels + 2*ch_permute[j] + 1] & 0xff))/32768.0f;
775                 }
776             }
777         }
778     }
779     else if(f->samplesize==24)
780     {
781         if(!f->bigendian) {
782             for(i = 0; i < realsamples; i++)
783             {
784                 for(j=0; j < f->channels; j++)
785                 {
786                     buffer[i*f->channels+j] = ((buf[i*3*f->channels + 3*ch_permute[j] + 2] << 16) |
787                       (((unsigned char *)buf)[i*3*f->channels + 3*ch_permute[j] + 1] << 8) |
788                       (((unsigned char *)buf)[i*3*f->channels + 3*ch_permute[j]] & 0xff))
789                         / 8388608.0f;
790
791                 }
792             }
793         }
794         else {
795             fprintf(stderr, _("Big endian 24 bit PCM data is not currently "
796                               "supported, aborting.\n"));
797             return 0;
798         }
799     }
800     else {
801         fprintf(stderr, _("Internal error: attempt to read unsupported "
802                           "bitdepth %d\n"), f->samplesize);
803         return 0;
804     }
805
806     return realsamples;
807 }
808
809 long wav_ieee_read(void *in, float *buffer, int samples)
810 {
811     wavfile *f = (wavfile *)in;
812     int realsamples = f->totalsamples > 0 && samples > (f->totalsamples - f->samplesread)
813         ? f->totalsamples - f->samplesread : samples;
814     float *buf = alloca(realsamples*4*f->channels); /* de-interleave buffer */
815     int i,j;
816
817     realsamples = fread(buf, 4*f->channels, realsamples, f->f);
818     f->samplesread += realsamples;
819
820     for(i=0; i < realsamples; i++)
821         for(j=0; j < f->channels; j++)
822             buffer[i*f->channels+j] = buf[i*f->channels + f->channel_permute[j]];
823
824     return realsamples;
825 }
826
827 void wav_close(void *info)
828 {
829     wavfile *f = (wavfile *)info;
830     free(f->channel_permute);
831
832     free(f);
833 }
834
835 int raw_open(FILE *in, oe_enc_opt *opt, unsigned char *buf, int buflen)
836 {
837     wavfile *wav = malloc(sizeof(wavfile));
838     int i;
839     (void)buf;/*unused*/
840     (void)buflen;/*unused*/
841
842     wav->f =             in;
843     wav->samplesread =   0;
844     wav->bigendian =     opt->endianness;
845     wav->unsigned8bit =  opt->samplesize == 8;
846     wav->channels =      opt->channels;
847     wav->samplesize =    opt->samplesize;
848     wav->totalsamples =  0;
849     wav->channel_permute = malloc(wav->channels * sizeof(int));
850     for (i=0; i < wav->channels; i++)
851       wav->channel_permute[i] = i;
852
853     opt->read_samples = wav_read;
854     opt->readdata = (void *)wav;
855     opt->total_samples_per_channel = 0; /* raw mode, don't bother */
856     return 1;
857 }
858
859 typedef struct {
860     audio_read_func real_reader;
861     void *real_readdata;
862     int channels;
863     float scale_factor;
864 } scaler;
865
866 static long read_scaler(void *data, float *buffer, int samples) {
867     scaler *d = data;
868     long in_samples = d->real_reader(d->real_readdata, buffer, samples);
869     int i;
870
871     for(i=0; i < d->channels*in_samples; i++) {
872        buffer[i] *= d->scale_factor;
873     }
874
875     return in_samples;
876 }
877
878 void setup_scaler(oe_enc_opt *opt, float scale) {
879     scaler *d = calloc(1, sizeof(scaler));
880
881     d->real_reader = opt->read_samples;
882     d->real_readdata = opt->readdata;
883
884     opt->read_samples = read_scaler;
885     opt->readdata = d;
886     d->channels = opt->channels;
887     d->scale_factor = scale;
888 }
889
890 typedef struct {
891     audio_read_func real_reader;
892     void *real_readdata;
893     ogg_int64_t *original_samples;
894     int channels;
895     int lpc_ptr;
896     int *extra_samples;
897     float *lpc_out;
898 } padder;
899
900 /* Read audio data, appending padding to make up any gap
901  * between the available and requested number of samples
902  * with LPC-predicted data to minimize the pertubation of
903  * the valid data that falls in the same frame.
904  */
905 static long read_padder(void *data, float *buffer, int samples) {
906     padder *d = data;
907     long in_samples = d->real_reader(d->real_readdata, buffer, samples);
908     int i, extra=0;
909     const int lpc_order=32;
910
911     if(d->original_samples)*d->original_samples+=in_samples;
912
913     if(in_samples<samples){
914       if(d->lpc_ptr<0){
915         d->lpc_out=calloc(d->channels * *d->extra_samples, sizeof(*d->lpc_out));
916         if(in_samples>lpc_order*2){
917           float *lpc=alloca(lpc_order*sizeof(*lpc));
918           for(i=0;i<d->channels;i++){
919             vorbis_lpc_from_data(buffer+i,lpc,in_samples,lpc_order,d->channels);
920             vorbis_lpc_predict(lpc,buffer+i+(in_samples-lpc_order)*d->channels,
921                                lpc_order,d->lpc_out+i,*d->extra_samples,d->channels);
922           }
923         }
924         d->lpc_ptr=0;
925       }
926       extra=samples-in_samples;
927       if(extra>*d->extra_samples)extra=*d->extra_samples;
928       *d->extra_samples-=extra;
929     }
930     memcpy(buffer+in_samples*d->channels,d->lpc_out+d->lpc_ptr*d->channels,extra*d->channels*sizeof(*buffer));
931     d->lpc_ptr+=extra;
932     return in_samples+extra;
933 }
934
935 void setup_padder(oe_enc_opt *opt,ogg_int64_t *original_samples) {
936     padder *d = calloc(1, sizeof(padder));
937
938     d->real_reader = opt->read_samples;
939     d->real_readdata = opt->readdata;
940
941     opt->read_samples = read_padder;
942     opt->readdata = d;
943     d->channels = opt->channels;
944     d->extra_samples = &opt->extraout;
945     d->original_samples=original_samples;
946     d->lpc_ptr = -1;
947     d->lpc_out = NULL;
948 }
949
950 void clear_padder(oe_enc_opt *opt) {
951     padder *d = opt->readdata;
952
953     opt->read_samples = d->real_reader;
954     opt->readdata = d->real_readdata;
955
956     if(d->lpc_out)free(d->lpc_out);
957     free(d);
958 }
959
960 typedef struct {
961     SpeexResamplerState *resampler;
962     audio_read_func real_reader;
963     void *real_readdata;
964     float *bufs;
965     int channels;
966     int bufpos;
967     int bufsize;
968     int done;
969 } resampler;
970
971 static long read_resampled(void *d, float *buffer, int samples)
972 {
973     resampler *rs = d;
974     int out_samples=0;
975     float *pcmbuf;
976     int *inbuf;
977     pcmbuf=rs->bufs;
978     inbuf=&rs->bufpos;
979     while(out_samples<samples){
980       int i;
981       int reading, ret;
982       unsigned in_len, out_len;
983       out_len=samples-out_samples;
984       reading=rs->bufsize-*inbuf;
985       if(reading>1024)reading=1024;
986       ret=rs->real_reader(rs->real_readdata, pcmbuf+*inbuf*rs->channels, reading);
987       *inbuf+=ret;
988       in_len=*inbuf;
989       speex_resampler_process_interleaved_float(rs->resampler, pcmbuf, &in_len, buffer+out_samples*rs->channels, &out_len);
990       out_samples+=out_len;
991       if(ret==0&&in_len==0){
992         for(i=out_samples*rs->channels;i<samples*rs->channels;i++)buffer[i]=0;
993         return out_samples;
994       }
995       for(i=0;i<rs->channels*(*inbuf-(long int)in_len);i++)pcmbuf[i]=pcmbuf[i+rs->channels*in_len];
996       *inbuf-=in_len;
997     }
998     return out_samples;
999 }
1000
1001 int setup_resample(oe_enc_opt *opt, int complexity, long outfreq) {
1002     resampler *rs = calloc(1, sizeof(resampler));
1003     int err;
1004
1005     rs->bufsize = 5760*2; /* Have at least two output frames worth, just in case of ugly ratios */
1006     rs->bufpos = 0;
1007
1008     rs->real_reader = opt->read_samples;
1009     rs->real_readdata = opt->readdata;
1010     rs->channels = opt->channels;
1011     rs->done = 0;
1012     rs->resampler = speex_resampler_init(rs->channels, opt->rate, outfreq, complexity, &err);
1013     if(err!=0)fprintf(stderr, _("resampler error: %s\n"), speex_resampler_strerror(err));
1014
1015     speex_resampler_skip_zeros(rs->resampler);
1016
1017     rs->bufs = malloc(sizeof(float) * rs->bufsize * opt->channels);
1018
1019     opt->read_samples = read_resampled;
1020     opt->readdata = rs;
1021     if(opt->total_samples_per_channel)
1022         opt->total_samples_per_channel = (opus_int64)
1023             ((double)opt->total_samples_per_channel * ((double)outfreq/(double)opt->rate));
1024     opt->rate = outfreq;
1025
1026     return 0;
1027 }
1028
1029 void clear_resample(oe_enc_opt *opt) {
1030     resampler *rs = opt->readdata;
1031
1032     opt->read_samples = rs->real_reader;
1033     opt->readdata = rs->real_readdata;
1034     speex_resampler_destroy(rs->resampler);
1035
1036     free(rs->bufs);
1037
1038     free(rs);
1039 }
1040
1041 typedef struct {
1042     audio_read_func real_reader;
1043     void *real_readdata;
1044     float *bufs;
1045     float *matrix;
1046     int in_channels;
1047     int out_channels;
1048 } downmix;
1049
1050 static long read_downmix(void *data, float *buffer, int samples)
1051 {
1052     downmix *d = data;
1053     long in_samples = d->real_reader(d->real_readdata, d->bufs, samples);
1054     int i,j,k,in_ch,out_ch;
1055
1056     in_ch=d->in_channels;
1057     out_ch=d->out_channels;
1058
1059     for(i=0;i<in_samples;i++){
1060       for(j=0;j<out_ch;j++){
1061         float *samp;
1062         samp=&buffer[i*out_ch+j];
1063         *samp=0;
1064         for(k=0;k<in_ch;k++){
1065           *samp+=d->bufs[i*in_ch+k]*d->matrix[in_ch*j+k];
1066         }
1067       }
1068     }
1069     return in_samples;
1070 }
1071
1072 int setup_downmix(oe_enc_opt *opt, int out_channels) {
1073     static const float stupid_matrix[7][8][2]={
1074       /*2*/  {{1,0},{0,1}},
1075       /*3*/  {{1,0},{0.7071f,0.7071f},{0,1}},
1076       /*4*/  {{1,0},{0,1},{0.866f,0.5f},{0.5f,0.866f}},
1077       /*5*/  {{1,0},{0.7071f,0.7071f},{0,1},{0.866f,0.5f},{0.5f,0.866f}},
1078       /*6*/  {{1,0},{0.7071f,0.7071f},{0,1},{0.866f,0.5f},{0.5f,0.866f},{0.7071f,0.7071f}},
1079       /*7*/  {{1,0},{0.7071f,0.7071f},{0,1},{0.866f,0.5f},{0.5f,0.866f},{0.6123f,0.6123f},{0.7071f,0.7071f}},
1080       /*8*/  {{1,0},{0.7071f,0.7071f},{0,1},{0.866f,0.5f},{0.5f,0.866f},{0.866f,0.5f},{0.5f,0.866f},{0.7071f,0.7071f}},
1081     };
1082     float sum;
1083     downmix *d;
1084     int i,j;
1085
1086     if(opt->channels<=out_channels || out_channels>2 || opt->channels<=0 || out_channels<=0) {
1087         fprintf(stderr, _("Downmix must actually downmix and only knows mono/stereo out.\n"));
1088         return 0;
1089     }
1090
1091     if(out_channels==2 && opt->channels>8) {
1092         fprintf(stderr, _("Downmix only knows how to mix >8ch to mono.\n"));
1093         return 0;
1094     }
1095
1096     d = calloc(1, sizeof(downmix));
1097     d->bufs = malloc(sizeof(float)*opt->channels*4096);
1098     d->matrix = malloc(sizeof(float)*opt->channels*out_channels);
1099     d->real_reader = opt->read_samples;
1100     d->real_readdata = opt->readdata;
1101     d->in_channels=opt->channels;
1102     d->out_channels=out_channels;
1103
1104     if(out_channels==1&&d->in_channels>8){
1105       for(i=0;i<d->in_channels;i++)d->matrix[i]=1.0f/d->in_channels;
1106     }else if(out_channels==2){
1107       for(j=0;j<d->out_channels;j++)
1108         for(i=0;i<d->in_channels;i++)d->matrix[d->in_channels*j+i]=
1109           stupid_matrix[opt->channels-2][i][j];
1110     }else{
1111       for(i=0;i<d->in_channels;i++)d->matrix[i]=
1112         (stupid_matrix[opt->channels-2][i][0])+
1113         (stupid_matrix[opt->channels-2][i][1]);
1114     }
1115     sum=0;
1116     for(i=0;i<d->in_channels*d->out_channels;i++)sum+=d->matrix[i];
1117     sum=(float)out_channels/sum;
1118     for(i=0;i<d->in_channels*d->out_channels;i++)d->matrix[i]*=sum;
1119     opt->read_samples = read_downmix;
1120     opt->readdata = d;
1121
1122     opt->channels = out_channels;
1123     return out_channels;
1124 }
1125
1126 void clear_downmix(oe_enc_opt *opt) {
1127     downmix *d = opt->readdata;
1128
1129     opt->read_samples = d->real_reader;
1130     opt->readdata = d->real_readdata;
1131     opt->channels = d->in_channels; /* other things in cleanup rely on this */
1132
1133     free(d->bufs);
1134     free(d->matrix);
1135     free(d);
1136 }