Add --quiet to opusenc and opusdec man pages.
[opus-tools.git] / src / opusdec.c
1 /* Copyright (c) 2002-2007 Jean-Marc Valin
2    Copyright (c) 2008 CSIRO
3    Copyright (c) 2007-2013 Xiph.Org Foundation
4    File: opusdec.c
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16
17    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
21    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <stdio.h>
35 #if !defined WIN32 && !defined _WIN32
36 #include <unistd.h>
37 #endif
38
39 #include <getopt.h>
40 #include <stdlib.h>
41 #include <limits.h>
42 #include <string.h>
43 #include <ctype.h> /*tolower()*/
44
45 #include <opus.h>
46 #include <opus_multistream.h>
47 #include <ogg/ogg.h>
48
49 #if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
50 # include "unicode_support.h"
51 # include "wave_out.h"
52 /* We need the following two to set stdout to binary */
53 # include <io.h>
54 # include <fcntl.h>
55 # define I64FORMAT "I64d"
56 #else
57 # define I64FORMAT "lld"
58 # define fopen_utf8(_x,_y) fopen((_x),(_y))
59 # define argc_utf8 argc
60 # define argv_utf8 argv
61 #endif
62
63 #include <math.h>
64
65 #ifdef HAVE_LRINTF
66 # define float2int(x) lrintf(x)
67 #else
68 # define float2int(flt) ((int)(floor(.5+flt)))
69 #endif
70
71 #if defined HAVE_LIBSNDIO
72 # include <sndio.h>
73 #elif defined HAVE_SYS_SOUNDCARD_H || defined HAVE_MACHINE_SOUNDCARD_H || HAVE_SOUNDCARD_H
74 # ifdef HAVE_SYS_SOUNDCARD_H
75 #  include <sys/soundcard.h>
76 # elif HAVE_MACHINE_SOUNDCARD_H
77 #  include <machine/soundcard.h>
78 # else
79 #  include <soundcard.h>
80 # endif
81 # include <sys/types.h>
82 # include <sys/stat.h>
83 # include <fcntl.h>
84 # include <sys/ioctl.h>
85 #elif defined HAVE_SYS_AUDIOIO_H
86 # include <sys/types.h>
87 # include <fcntl.h>
88 # include <sys/ioctl.h>
89 # include <sys/audioio.h>
90 # ifndef AUDIO_ENCODING_SLINEAR
91 #  define AUDIO_ENCODING_SLINEAR AUDIO_ENCODING_LINEAR /* Solaris */
92 # endif
93 #endif
94
95 #include <string.h>
96 #include "wav_io.h"
97 #include "opus_header.h"
98 #include "diag_range.h"
99 #include "speex_resampler.h"
100 #include "stack_alloc.h"
101 #include "cpusupport.h"
102
103 #define MINI(_a,_b)      ((_a)<(_b)?(_a):(_b))
104 #define MAXI(_a,_b)      ((_a)>(_b)?(_a):(_b))
105 #define CLAMPI(_a,_b,_c) (MAXI(_a,MINI(_b,_c)))
106
107 /* 120ms at 48000 */
108 #define MAX_FRAME_SIZE (960*6)
109
110 #define readint(buf, base) (((buf[base+3]<<24)&0xff000000)| \
111                            ((buf[base+2]<<16)&0xff0000)| \
112                            ((buf[base+1]<<8)&0xff00)| \
113                            (buf[base]&0xff))
114
115 #ifdef HAVE_LIBSNDIO
116 struct sio_hdl *hdl;
117 #endif
118
119 typedef struct shapestate shapestate;
120 struct shapestate {
121   float * b_buf;
122   float * a_buf;
123   int fs;
124   int mute;
125 };
126
127 static unsigned int rngseed = 22222;
128 static inline unsigned int fast_rand(void) {
129   rngseed = (rngseed * 96314165) + 907633515;
130   return rngseed;
131 }
132
133 #ifndef HAVE_FMINF
134 # define fminf(_x,_y) ((_x)<(_y)?(_x):(_y))
135 #endif
136
137 #ifndef HAVE_FMAXF
138 # define fmaxf(_x,_y) ((_x)>(_y)?(_x):(_y))
139 #endif
140
141 static void quit(int _x) {
142 #ifdef WIN_UNICODE
143   uninit_console_utf8();
144 #endif
145   exit(_x);
146 }
147
148 /* This implements a 16 bit quantization with full triangular dither
149    and IIR noise shaping. The noise shaping filters were designed by
150    Sebastian Gesemann based on the LAME ATH curves with flattening
151    to limit their peak gain to 20 dB.
152    (Everyone elses' noise shaping filters are mildly crazy)
153    The 48kHz version of this filter is just a warped version of the
154    44.1kHz filter and probably could be improved by shifting the
155    HF shelf up in frequency a little bit since 48k has a bit more
156    room and being more conservative against bat-ears is probably
157    more important than more noise suppression.
158    This process can increase the peak level of the signal (in theory
159    by the peak error of 1.5 +20 dB though this much is unobservable rare)
160    so to avoid clipping the signal is attenuated by a couple thousandths
161    of a dB. Initially the approach taken here was to only attenuate by
162    the 99.9th percentile, making clipping rare but not impossible (like
163    SoX) but the limited gain of the filter means that the worst case was
164    only two thousandths of a dB more, so this just uses the worst case.
165    The attenuation is probably also helpful to prevent clipping in the DAC
166    reconstruction filters or downstream resampling in any case.*/
167 static inline void shape_dither_toshort(shapestate *_ss, short *_o, float *_i, int _n, int _CC)
168 {
169   const float gains[3]={32768.f-15.f,32768.f-15.f,32768.f-3.f};
170   const float fcoef[3][8] =
171   {
172     {2.2374f, -.7339f, -.1251f, -.6033f, 0.9030f, .0116f, -.5853f, -.2571f}, /* 48.0kHz noise shaping filter sd=2.34*/
173     {2.2061f, -.4706f, -.2534f, -.6214f, 1.0587f, .0676f, -.6054f, -.2738f}, /* 44.1kHz noise shaping filter sd=2.51*/
174     {1.0000f, 0.0000f, 0.0000f, 0.0000f, 0.0000f,0.0000f, 0.0000f, 0.0000f}, /* lowpass noise shaping filter sd=0.65*/
175   };
176   int i;
177   int rate=_ss->fs==44100?1:(_ss->fs==48000?0:2);
178   float gain=gains[rate];
179   float *b_buf;
180   float *a_buf;
181   int mute=_ss->mute;
182   b_buf=_ss->b_buf;
183   a_buf=_ss->a_buf;
184   /*In order to avoid replacing digital silence with quiet dither noise
185     we mute if the output has been silent for a while*/
186   if(mute>64)
187     memset(a_buf,0,sizeof(float)*_CC*4);
188   for(i=0;i<_n;i++)
189   {
190     int c;
191     int pos = i*_CC;
192     int silent=1;
193     for(c=0;c<_CC;c++)
194     {
195       int j, si;
196       float r,s,err=0;
197       silent&=_i[pos+c]==0;
198       s=_i[pos+c]*gain;
199       for(j=0;j<4;j++)
200         err += fcoef[rate][j]*b_buf[c*4+j] - fcoef[rate][j+4]*a_buf[c*4+j];
201       memmove(&a_buf[c*4+1],&a_buf[c*4],sizeof(float)*3);
202       memmove(&b_buf[c*4+1],&b_buf[c*4],sizeof(float)*3);
203       a_buf[c*4]=err;
204       s = s - err;
205       r=(float)fast_rand()*(1/(float)UINT_MAX) - (float)fast_rand()*(1/(float)UINT_MAX);
206       if (mute>16)r=0;
207       /*Clamp in float out of paranoia that the input will be >96 dBFS and wrap if the
208         integer is clamped.*/
209       _o[pos+c] = si = float2int(fmaxf(-32768,fminf(s + r,32767)));
210       /*Including clipping in the noise shaping is generally disastrous:
211         the futile effort to restore the clipped energy results in more clipping.
212         However, small amounts-- at the level which could normally be created by
213         dither and rounding-- are harmless and can even reduce clipping somewhat
214         due to the clipping sometimes reducing the dither+rounding error.*/
215       b_buf[c*4] = (mute>16)?0:fmaxf(-1.5f,fminf(si - s,1.5f));
216     }
217     mute++;
218     if(!silent)mute=0;
219   }
220   _ss->mute=MINI(mute,960);
221 }
222
223 static void print_comments(char *comments, int length)
224 {
225    char *c=comments;
226    int len, i, nb_fields, err=0;
227
228    if (length<(8+4+4))
229    {
230       fprintf (stderr, "Invalid/corrupted comments\n");
231       return;
232    }
233    if (strncmp(c, "OpusTags", 8) != 0)
234    {
235       fprintf (stderr, "Invalid/corrupted comments\n");
236       return;
237    }
238    c += 8;
239    fprintf(stderr, "Encoded with ");
240    len=readint(c, 0);
241    c+=4;
242    if (len < 0 || len>(length-16))
243    {
244       fprintf (stderr, "Invalid/corrupted comments\n");
245       return;
246    }
247    err&=fwrite(c, 1, len, stderr)!=(unsigned)len;
248    c+=len;
249    fprintf (stderr, "\n");
250    /*The -16 check above makes sure we can read this.*/
251    nb_fields=readint(c, 0);
252    c+=4;
253    length-=16+len;
254    if (nb_fields < 0 || nb_fields>(length>>2))
255    {
256       fprintf (stderr, "Invalid/corrupted comments\n");
257       return;
258    }
259    for (i=0;i<nb_fields;i++)
260    {
261       if (length<4)
262       {
263          fprintf (stderr, "Invalid/corrupted comments\n");
264          return;
265       }
266       len=readint(c, 0);
267       c+=4;
268       length-=4;
269       if (len < 0 || len>length)
270       {
271          fprintf (stderr, "Invalid/corrupted comments\n");
272          return;
273       }
274       err&=fwrite(c, 1, len, stderr)!=(unsigned)len;
275       c+=len;
276       length-=len;
277       fprintf (stderr, "\n");
278    }
279 }
280
281 FILE *out_file_open(char *outFile, int *wav_format, int rate, int mapping_family, int *channels, int fp)
282 {
283    FILE *fout=NULL;
284    /*Open output file*/
285    if (strlen(outFile)==0)
286    {
287 #if defined HAVE_LIBSNDIO
288       struct sio_par par;
289
290       hdl = sio_open(NULL, SIO_PLAY, 0);
291       if (!hdl)
292       {
293          fprintf(stderr, "Cannot open sndio device\n");
294          quit(1);
295       }
296
297       sio_initpar(&par);
298       par.sig = 1;
299       par.bits = 16;
300       par.rate = rate;
301       par.pchan = *channels;
302
303       if (!sio_setpar(hdl, &par) || !sio_getpar(hdl, &par) ||
304         par.sig != 1 || par.bits != 16 || par.rate != rate) {
305           fprintf(stderr, "could not set sndio parameters\n");
306           quit(1);
307       }
308       *channels = par.pchan;
309       if (!sio_start(hdl)) {
310           fprintf(stderr, "could not start sndio\n");
311           quit(1);
312       }
313 #elif defined HAVE_SYS_SOUNDCARD_H || defined HAVE_MACHINE_SOUNDCARD_H || HAVE_SOUNDCARD_H
314       int audio_fd, format, stereo;
315       audio_fd=open("/dev/dsp", O_WRONLY);
316       if (audio_fd<0)
317       {
318          perror("Cannot open /dev/dsp");
319          quit(1);
320       }
321
322       format=AFMT_S16_NE;
323       if (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &format)==-1)
324       {
325          perror("SNDCTL_DSP_SETFMT");
326          close(audio_fd);
327          quit(1);
328       }
329
330       if (*channels > 2)
331       {
332         /* There doesn't seem to be a way to get or set the channel
333          * matrix with the sys/soundcard api, so we can't support
334          * multichannel. We should fall back to stereo downmix.
335          */
336         fprintf(stderr, "Cannot configure multichannel playback."
337                         " Try decoding to a file instead.\n");
338         close(audio_fd);
339         quit(1);
340       }
341       stereo=0;
342       if (*channels==2)
343          stereo=1;
344       if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo)==-1)
345       {
346          perror("SNDCTL_DSP_STEREO");
347          close(audio_fd);
348          quit(1);
349       }
350       if (stereo!=0)
351       {
352          if (*channels==1)
353             fprintf (stderr, "Cannot set mono mode, will decode in stereo\n");
354          *channels=2;
355       }
356
357       if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &rate)==-1)
358       {
359          perror("SNDCTL_DSP_SPEED");
360          close(audio_fd);
361          quit(1);
362       }
363       fout = fdopen(audio_fd, "w");
364       if(!fout)
365       {
366         perror("Cannot open output");
367         quit(1);
368       }
369 #elif defined HAVE_SYS_AUDIOIO_H
370       audio_info_t info;
371       int audio_fd;
372
373       audio_fd = open("/dev/audio", O_WRONLY);
374       if (audio_fd<0)
375       {
376          perror("Cannot open /dev/audio");
377          quit(1);
378       }
379
380       AUDIO_INITINFO(&info);
381 #ifdef AUMODE_PLAY    /* NetBSD/OpenBSD */
382       info.mode = AUMODE_PLAY;
383 #endif
384       info.play.encoding = AUDIO_ENCODING_SLINEAR;
385       info.play.precision = 16;
386       info.play.input_sample_rate = rate;
387       info.play.channels = *channels;
388
389       if (ioctl(audio_fd, AUDIO_SETINFO, &info) < 0)
390       {
391          perror ("AUDIO_SETINFO");
392          quit(1);
393       }
394       fout = fdopen(audio_fd, "w");
395       if(!fout)
396       {
397         perror("Cannot open output");
398         quit(1);
399       }
400 #elif defined WIN32 || defined _WIN32
401       {
402          unsigned int opus_channels = *channels;
403          if (Set_WIN_Params (INVALID_FILEDESC, rate, SAMPLE_SIZE, opus_channels))
404          {
405             fprintf (stderr, "Can't access %s\n", "WAVE OUT");
406             quit(1);
407          }
408       }
409 #else
410       fprintf (stderr, "No soundcard support\n");
411       quit(1);
412 #endif
413    } else {
414       if (strcmp(outFile,"-")==0)
415       {
416 #if defined WIN32 || defined _WIN32
417          _setmode(_fileno(stdout), _O_BINARY);
418 #endif
419          fout=stdout;
420       }
421       else
422       {
423          fout = fopen_utf8(outFile, "wb");
424          if (!fout)
425          {
426             perror(outFile);
427             quit(1);
428          }
429       }
430       if (*wav_format)
431       {
432          *wav_format = write_wav_header(fout, rate, mapping_family, *channels, fp);
433          if (*wav_format < 0)
434          {
435             fprintf (stderr, "Error writing WAV header.\n");
436             quit(1);
437          }
438       }
439    }
440    return fout;
441 }
442
443 void usage(void)
444 {
445    printf ("Usage: opusdec [options] input_file.opus [output_file]\n");
446    printf ("\n");
447    printf ("Decodes a Opus file and produce a WAV file or raw file\n");
448    printf ("\n");
449    printf ("input_file can be:\n");
450    printf ("  filename.opus        regular Opus file\n");
451    printf ("  -                    stdin\n");
452    printf ("\n");
453    printf ("output_file can be:\n");
454    printf ("  filename.wav         Wav file\n");
455    printf ("  filename.*           Raw PCM file (any extension other than .wav)\n");
456    printf ("  -                    stdout (raw; unless --force-wav)\n");
457    printf ("  (nothing)            Will be played to soundcard\n");
458    printf ("\n");
459    printf ("Options:\n");
460    printf (" --rate n              Force decoding at sampling rate n Hz\n");
461    printf (" --gain n              Manually adjust gain by n.nn dB (0 default)\n");
462    printf (" --no-dither           Do not dither 16-bit output\n");
463    printf (" --float               32-bit floating-point output\n");
464    printf (" --force-wav           Force wav header on output\n");
465    printf (" --packet-loss n       Simulate n %% random packet loss\n");
466    printf (" --save-range file     Saves check values for every frame to a file\n");
467    printf (" -h, --help            This help\n");
468    printf (" -V, --version         Version information\n");
469    printf (" --quiet               Quiet mode\n");
470    printf ("\n");
471 }
472
473 void version(void)
474 {
475    printf("opusdec %s %s (using %s)\n",PACKAGE_NAME,PACKAGE_VERSION,opus_get_version_string());
476    printf("Copyright (C) 2008-2013 Xiph.Org Foundation\n");
477 }
478
479 void version_short(void)
480 {
481    version();
482 }
483
484 /*Process an Opus header and setup the opus decoder based on it.
485   It takes several pointers for header values which are needed
486   elsewhere in the code.*/
487 static OpusMSDecoder *process_header(ogg_packet *op, opus_int32 *rate,
488        int *mapping_family, int *channels, int *preskip, float *gain,
489        float manual_gain, int *streams, int wav_format, int quiet)
490 {
491    int err;
492    OpusMSDecoder *st;
493    OpusHeader header;
494
495    if (opus_header_parse(op->packet, op->bytes, &header)==0)
496    {
497       fprintf(stderr, "Cannot parse header\n");
498       return NULL;
499    }
500
501    *mapping_family = header.channel_mapping;
502    *channels = header.channels;
503    if(wav_format)adjust_wav_mapping(*mapping_family, *channels, header.stream_map);
504
505    if(!*rate)*rate=header.input_sample_rate;
506    /*If the rate is unspecified we decode to 48000*/
507    if(*rate==0)*rate=48000;
508    if(*rate<8000||*rate>192000){
509      fprintf(stderr,"Warning: Crazy input_rate %d, decoding to 48000 instead.\n",*rate);
510      *rate=48000;
511    }
512
513    *preskip = header.preskip;
514    st = opus_multistream_decoder_create(48000, header.channels, header.nb_streams, header.nb_coupled, header.stream_map, &err);
515    if(err != OPUS_OK){
516      fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err));
517      return NULL;
518    }
519    if (!st)
520    {
521       fprintf (stderr, "Decoder initialization failed: %s\n", opus_strerror(err));
522       return NULL;
523    }
524
525    *streams=header.nb_streams;
526
527    if(header.gain!=0 || manual_gain!=0)
528    {
529       /*Gain API added in a newer libopus version, if we don't have it
530         we apply the gain ourselves. We also add in a user provided
531         manual gain at the same time.*/
532       int gainadj = (int)(manual_gain*256.)+header.gain;
533 #ifdef OPUS_SET_GAIN
534       err=opus_multistream_decoder_ctl(st,OPUS_SET_GAIN(gainadj));
535       if(err==OPUS_UNIMPLEMENTED)
536       {
537 #endif
538          *gain = pow(10., gainadj/5120.);
539 #ifdef OPUS_SET_GAIN
540       } else if (err!=OPUS_OK)
541       {
542          fprintf (stderr, "Error setting gain: %s\n", opus_strerror(err));
543          return NULL;
544       }
545 #endif
546    }
547
548    if (!quiet)
549    {
550       fprintf(stderr, "Decoding to %d Hz (%d channel%s)", *rate,
551         *channels, *channels>1?"s":"");
552       if(header.version!=1)fprintf(stderr, ", Header v%d",header.version);
553       fprintf(stderr, "\n");
554       if (header.gain!=0)fprintf(stderr,"Playback gain: %f dB\n", header.gain/256.);
555       if (manual_gain!=0)fprintf(stderr,"Manual gain: %f dB\n", manual_gain);
556    }
557
558    return st;
559 }
560
561 opus_int64 audio_write(float *pcm, int channels, int frame_size, FILE *fout, SpeexResamplerState *resampler,
562                        int *skip, shapestate *shapemem, int file, opus_int64 maxout, int fp)
563 {
564    opus_int64 sampout=0;
565    int i,ret,tmp_skip;
566    unsigned out_len;
567    short *out;
568    float *buf;
569    float *output;
570    out=alloca(sizeof(short)*MAX_FRAME_SIZE*channels);
571    buf=alloca(sizeof(float)*MAX_FRAME_SIZE*channels);
572    maxout=maxout<0?0:maxout;
573    do {
574      if (skip){
575        tmp_skip = (*skip>frame_size) ? (int)frame_size : *skip;
576        *skip -= tmp_skip;
577      } else {
578        tmp_skip = 0;
579      }
580      if (resampler){
581        unsigned in_len;
582        output=buf;
583        in_len = frame_size-tmp_skip;
584        out_len = 1024<maxout?1024:maxout;
585        speex_resampler_process_interleaved_float(resampler, pcm+channels*tmp_skip, &in_len, buf, &out_len);
586        pcm += channels*(in_len+tmp_skip);
587        frame_size -= in_len+tmp_skip;
588      } else {
589        output=pcm+channels*tmp_skip;
590        out_len=frame_size-tmp_skip;
591        frame_size=0;
592      }
593
594      if(!file||!fp)
595      {
596         /*Convert to short and save to output file*/
597         if (shapemem){
598           shape_dither_toshort(shapemem,out,output,out_len,channels);
599         }else{
600           for (i=0;i<(int)out_len*channels;i++)
601             out[i]=(short)float2int(fmaxf(-32768,fminf(output[i]*32768.f,32767)));
602         }
603         if ((le_short(1)!=1)&&file){
604           for (i=0;i<(int)out_len*channels;i++)
605             out[i]=le_short(out[i]);
606         }
607      }
608
609      if(maxout>0)
610      {
611 #if defined WIN32 || defined _WIN32
612        if(!file){
613          ret=WIN_Play_Samples (out, sizeof(short) * channels * (out_len<maxout?out_len:maxout));
614          if(ret>0)ret/=sizeof(short)*channels;
615          else fprintf(stderr, "Error playing audio.\n");
616        }else
617 #elif defined HAVE_LIBSNDIO
618        if(!file){
619          ret=sio_write (hdl, out, sizeof(short) * channels * (out_len<maxout?out_len:maxout));
620          if(ret>0)ret/=sizeof(short)*channels;
621          else fprintf(stderr, "Error playing audio.\n");
622        }else
623 #endif
624          ret=fwrite(fp?(char *)output:(char *)out, (fp?4:2)*channels, out_len<maxout?out_len:maxout, fout);
625        sampout+=ret;
626        maxout-=ret;
627      }
628    } while (frame_size>0 && maxout>0);
629    return sampout;
630 }
631
632 int main(int argc, char **argv)
633 {
634    int c;
635    int option_index = 0;
636    char *inFile, *outFile;
637    FILE *fin, *fout=NULL, *frange=NULL;
638    float *output;
639    int frame_size=0;
640    OpusMSDecoder *st=NULL;
641    opus_int64 packet_count=0;
642    int total_links=0;
643    int stream_init = 0;
644    int quiet = 0;
645    int forcewav = 0;
646    ogg_int64_t page_granule=0;
647    ogg_int64_t link_out=0;
648    struct option long_options[] =
649    {
650       {"help", no_argument, NULL, 0},
651       {"quiet", no_argument, NULL, 0},
652       {"version", no_argument, NULL, 0},
653       {"version-short", no_argument, NULL, 0},
654       {"rate", required_argument, NULL, 0},
655       {"gain", required_argument, NULL, 0},
656       {"no-dither", no_argument, NULL, 0},
657       {"float", no_argument, NULL, 0},
658       {"force-wav", no_argument, NULL, 0},
659       {"packet-loss", required_argument, NULL, 0},
660       {"save-range", required_argument, NULL, 0},
661       {0, 0, 0, 0}
662    };
663    ogg_sync_state oy;
664    ogg_page       og;
665    ogg_packet     op;
666    ogg_stream_state os;
667    int close_in=0;
668    int eos=0;
669    ogg_int64_t audio_size=0;
670    double last_coded_seconds=0;
671    float loss_percent=-1;
672    float manual_gain=0;
673    int channels=-1;
674    int mapping_family;
675    int rate=0;
676    int wav_format=0;
677    int preskip=0;
678    int gran_offset=0;
679    int has_opus_stream=0;
680    int has_tags_packet=0;
681    ogg_int32_t opus_serialno;
682    int dither=1;
683    int fp=0;
684    shapestate shapemem;
685    SpeexResamplerState *resampler=NULL;
686    float gain=1;
687    int streams=0;
688    size_t last_spin=0;
689 #ifdef WIN_UNICODE
690    int argc_utf8;
691    char **argv_utf8;
692 #endif
693
694    if(query_cpu_support()){
695      fprintf(stderr,"\n\n** WARNING: This program with compiled with SSE%s\n",query_cpu_support()>1?"2":"");
696      fprintf(stderr,"            but this CPU claims to lack these instructions. **\n\n");
697    }
698
699 #ifdef WIN_UNICODE
700    (void)argc;
701    (void)argv;
702
703    init_console_utf8();
704    init_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
705 #endif
706
707    output=0;
708    shapemem.a_buf=0;
709    shapemem.b_buf=0;
710    shapemem.mute=960;
711    shapemem.fs=0;
712
713    /*Process options*/
714    while(1)
715    {
716       c = getopt_long (argc_utf8, argv_utf8, "hV",
717                        long_options, &option_index);
718       if (c==-1)
719          break;
720
721       switch(c)
722       {
723       case 0:
724          if (strcmp(long_options[option_index].name,"help")==0)
725          {
726             usage();
727             quit(0);
728          } else if (strcmp(long_options[option_index].name,"quiet")==0)
729          {
730             quiet = 1;
731          } else if (strcmp(long_options[option_index].name,"version")==0)
732          {
733             version();
734             quit(0);
735          } else if (strcmp(long_options[option_index].name,"version-short")==0)
736          {
737             version_short();
738             quit(0);
739          } else if (strcmp(long_options[option_index].name,"no-dither")==0)
740          {
741             dither=0;
742          } else if (strcmp(long_options[option_index].name,"float")==0)
743          {
744             fp=1;
745          } else if (strcmp(long_options[option_index].name,"force-wav")==0)
746          {
747             forcewav=1;
748          } else if (strcmp(long_options[option_index].name,"rate")==0)
749          {
750             rate=atoi (optarg);
751          } else if (strcmp(long_options[option_index].name,"gain")==0)
752          {
753             manual_gain=atof (optarg);
754          }else if(strcmp(long_options[option_index].name,"save-range")==0){
755           frange=fopen_utf8(optarg,"w");
756           if(frange==NULL){
757             perror(optarg);
758             fprintf(stderr,"Could not open save-range file: %s\n",optarg);
759             fprintf(stderr,"Must provide a writable file name.\n");
760             quit(1);
761           }
762          } else if (strcmp(long_options[option_index].name,"packet-loss")==0)
763          {
764             loss_percent = atof(optarg);
765          }
766          break;
767       case 'h':
768          usage();
769          quit(0);
770          break;
771       case 'V':
772          version();
773          quit(0);
774          break;
775       case '?':
776          usage();
777          quit(1);
778          break;
779       }
780    }
781    if (argc_utf8-optind!=2 && argc_utf8-optind!=1)
782    {
783       usage();
784       quit(1);
785    }
786    inFile=argv_utf8[optind];
787
788    /*Output to a file or playback?*/
789    if (argc_utf8-optind==2){
790      /*If we're outputting to a file, should we apply a wav header?*/
791      int i;
792      char *ext;
793      outFile=argv_utf8[optind+1];
794      ext=".wav";
795      i=strlen(outFile)-4;
796      wav_format=i>=0;
797      while(wav_format&&ext&&outFile[i]) {
798        wav_format&=tolower(outFile[i++])==*ext++;
799      }
800      wav_format|=forcewav;
801    }else {
802      outFile="";
803      wav_format=0;
804      /*If playing to audio out, default the rate to 48000
805        instead of the original rate. The original rate is
806        only important for minimizing surprise about the rate
807        of output files and preserving length, which aren't
808        relevant for playback. Many audio devices sound
809        better at 48kHz and not resampling also saves CPU.*/
810      if(rate==0)rate=48000;
811      /*Playback is 16-bit only.*/
812      fp=0;
813    }
814    /*If the output is floating point, don't dither.*/
815    if(fp)dither=0;
816
817    /*Open input file*/
818    if (strcmp(inFile, "-")==0)
819    {
820 #if defined WIN32 || defined _WIN32
821       _setmode(_fileno(stdin), _O_BINARY);
822 #endif
823       fin=stdin;
824    }
825    else
826    {
827       fin = fopen_utf8(inFile, "rb");
828       if (!fin)
829       {
830          perror(inFile);
831          quit(1);
832       }
833       close_in=1;
834    }
835
836    /* .opus files use the Ogg container to provide framing and timekeeping.
837     * http://tools.ietf.org/html/draft-terriberry-oggopus
838     * The easiest way to decode the Ogg container is to use libogg, so
839     *  thats what we do here.
840     * Using libogg is fairly straight forward-- you take your stream of bytes
841     *  and feed them to ogg_sync_ and it periodically returns Ogg pages, you
842     *  check if the pages belong to the stream you're decoding then you give
843     *  them to libogg and it gives you packets. You decode the packets. The
844     *  pages also provide timing information.*/
845    ogg_sync_init(&oy);
846
847    /*Main decoding loop*/
848    while (1)
849    {
850       char *data;
851       int i, nb_read;
852       /*Get the ogg buffer for writing*/
853       data = ogg_sync_buffer(&oy, 200);
854       /*Read bitstream from input file*/
855       nb_read = fread(data, sizeof(char), 200, fin);
856       ogg_sync_wrote(&oy, nb_read);
857
858       /*Loop for all complete pages we got (most likely only one)*/
859       while (ogg_sync_pageout(&oy, &og)==1)
860       {
861          if (stream_init == 0) {
862             ogg_stream_init(&os, ogg_page_serialno(&og));
863             stream_init = 1;
864          }
865          if (ogg_page_serialno(&og) != os.serialno) {
866             /* so all streams are read. */
867             ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
868          }
869          /*Add page to the bitstream*/
870          ogg_stream_pagein(&os, &og);
871          page_granule = ogg_page_granulepos(&og);
872          /*Extract all available packets*/
873          while (ogg_stream_packetout(&os, &op) == 1)
874          {
875             /*OggOpus streams are identified by a magic string in the initial
876               stream header.*/
877             if (op.b_o_s && op.bytes>=8 && !memcmp(op.packet, "OpusHead", 8)) {
878                if(has_opus_stream && has_tags_packet)
879                {
880                  /*If we're seeing another BOS OpusHead now it means
881                    the stream is chained without an EOS.*/
882                  has_opus_stream=0;
883                  if(st)opus_multistream_decoder_destroy(st);
884                  st=NULL;
885                  fprintf(stderr,"\nWarning: stream %" I64FORMAT " ended without EOS and a new stream began.\n",(long long)os.serialno);
886                }
887                if(!has_opus_stream)
888                {
889                  if(packet_count>0 && opus_serialno==os.serialno)
890                  {
891                    fprintf(stderr,"\nError: Apparent chaining without changing serial number (%" I64FORMAT "==%" I64FORMAT ").\n",
892                      (long long)opus_serialno,(long long)os.serialno);
893                    quit(1);
894                  }
895                  opus_serialno = os.serialno;
896                  has_opus_stream = 1;
897                  has_tags_packet = 0;
898                  link_out = 0;
899                  packet_count = 0;
900                  eos = 0;
901                  total_links++;
902                } else {
903                  fprintf(stderr,"\nWarning: ignoring opus stream %" I64FORMAT "\n",(long long)os.serialno);
904                }
905             }
906             if (!has_opus_stream || os.serialno != opus_serialno)
907                break;
908             /*If first packet in a logical stream, process the Opus header*/
909             if (packet_count==0)
910             {
911                int old_channels = channels;
912                st = process_header(&op, &rate, &mapping_family, &channels, &preskip, &gain, manual_gain, &streams, wav_format, quiet);
913                if (!st)
914                   quit(1);
915
916                if (output && channels!=old_channels)
917                {
918                    fprintf(stderr,"\nError: Apparent chaining changes channel count from %d to %d.\n",
919                      old_channels,channels);
920                    fprintf(stderr,"This is currently unhandled by opusdec.\n");
921                    quit(1);
922                }
923
924                if(ogg_stream_packetout(&os, &op)!=0 || og.header[og.header_len-1]==255)
925                {
926                   /*The format specifies that the initial header and tags packets are on their
927                     own pages. To aid implementors in discovering that their files are wrong
928                     we reject them explicitly here. In some player designs files like this would
929                     fail even without an explicit test.*/
930                   fprintf(stderr, "Extra packets on initial header page. Invalid stream.\n");
931                   quit(1);
932                }
933
934                /*Remember how many samples at the front we were told to skip
935                  so that we can adjust the timestamp counting.*/
936                gran_offset=preskip;
937
938                /*Setup the memory for the dithered output*/
939                if(!shapemem.a_buf)
940                {
941                   shapemem.a_buf=calloc(channels,sizeof(float)*4);
942                   shapemem.b_buf=calloc(channels,sizeof(float)*4);
943                   shapemem.fs=rate;
944                }
945                if(!output)output=malloc(sizeof(float)*MAX_FRAME_SIZE*channels);
946                if(!shapemem.a_buf||!shapemem.b_buf||!output)
947                {
948                   fprintf(stderr, "Memory allocation failure.\n");
949                   quit(1);
950                }
951
952                /*Normal players should just play at 48000 or their maximum rate,
953                  as described in the OggOpus spec.  But for commandline tools
954                  like opusdec it can be desirable to exactly preserve the original
955                  sampling rate and duration, so we have a resampler here.*/
956                if (rate != 48000 && resampler==NULL)
957                {
958                   int err;
959                   resampler = speex_resampler_init(channels, 48000, rate, 5, &err);
960                   if (err!=0)
961                      fprintf(stderr, "resampler error: %s\n", speex_resampler_strerror(err));
962                   speex_resampler_skip_zeros(resampler);
963                }
964                if(!fout)fout=out_file_open(outFile, &wav_format, rate, mapping_family, &channels, fp);
965             } else if (packet_count==1)
966             {
967                if (!quiet)
968                   print_comments((char*)op.packet, op.bytes);
969                has_tags_packet=1;
970                if(ogg_stream_packetout(&os, &op)!=0 || og.header[og.header_len-1]==255)
971                {
972                   fprintf(stderr, "Extra packets on initial tags page. Invalid stream.\n");
973                   quit(1);
974                }
975             } else {
976                int ret;
977                opus_int64 maxout;
978                opus_int64 outsamp;
979                int lost=0;
980                if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
981                   lost=1;
982
983                /*End of stream condition*/
984                if (op.e_o_s && os.serialno == opus_serialno)eos=1; /* don't care for anything except opus eos */
985
986                /*Are we simulating loss for this packet?*/
987                if (!lost){
988                   /*Decode Opus packet*/
989                   ret = opus_multistream_decode_float(st, (unsigned char*)op.packet, op.bytes, output, MAX_FRAME_SIZE, 0);
990                } else {
991                   /*Extract the original duration.
992                     Normally you wouldn't have it for a lost packet, but normally the
993                     transports used on lossy channels will effectively tell you.
994                     This avoids opusdec squaking when the decoded samples and
995                     granpos mismatches.*/
996                   opus_int32 lost_size;
997                   lost_size = MAX_FRAME_SIZE;
998                   if(op.bytes>0){
999                     opus_int32 spp;
1000                     spp=opus_packet_get_nb_frames(op.packet,op.bytes);
1001                     if(spp>0){
1002                       spp*=opus_packet_get_samples_per_frame(op.packet,48000/*decoding_rate*/);
1003                       if(spp>0)lost_size=spp;
1004                     }
1005                   }
1006                   /*Invoke packet loss concealment.*/
1007                   ret = opus_multistream_decode_float(st, NULL, 0, output, lost_size, 0);
1008                }
1009
1010                if(!quiet){
1011                   /*Display a progress spinner while decoding.*/
1012                   static const char spinner[]="|/-\\";
1013                   double coded_seconds = (double)audio_size/(channels*rate*(fp?4:2));
1014                   if(coded_seconds>=last_coded_seconds+1){
1015                      fprintf(stderr,"\r[%c] %02d:%02d:%02d", spinner[last_spin&3],
1016                              (int)(coded_seconds/3600),(int)(coded_seconds/60)%60,
1017                              (int)(coded_seconds)%60);
1018                      fflush(stderr);
1019                      last_spin++;
1020                      last_coded_seconds=coded_seconds;
1021                   }
1022                }
1023
1024                /*If the decoder returned less than zero, we have an error.*/
1025                if (ret<0)
1026                {
1027                   fprintf (stderr, "Decoding error: %s\n", opus_strerror(ret));
1028                   break;
1029                }
1030                frame_size = ret;
1031
1032                /*If we're collecting --save-range debugging data, collect it now.*/
1033                if(frange!=NULL){
1034                  OpusDecoder *od;
1035                  opus_uint32 rngs[256];
1036                  for(i=0;i<streams;i++){
1037                    ret=opus_multistream_decoder_ctl(st,OPUS_MULTISTREAM_GET_DECODER_STATE(i,&od));
1038                    ret=opus_decoder_ctl(od,OPUS_GET_FINAL_RANGE(&rngs[i]));
1039                  }
1040                  save_range(frange,frame_size*(48000/48000/*decoding_rate*/),op.packet,op.bytes,
1041                             rngs,streams);
1042                }
1043
1044                /*Apply header gain, if we're not using an opus library new
1045                  enough to do this internally.*/
1046                if (gain!=0){
1047                  for (i=0;i<frame_size*channels;i++)
1048                     output[i] *= gain;
1049                }
1050
1051                /*This handles making sure that our output duration respects
1052                  the final end-trim by not letting the output sample count
1053                  get ahead of the granpos indicated value.*/
1054                maxout=((page_granule-gran_offset)*rate/48000)-link_out;
1055                outsamp=audio_write(output, channels, frame_size, fout, resampler, &preskip, dither?&shapemem:0, strlen(outFile)!=0,0>maxout?0:maxout,fp);
1056                link_out+=outsamp;
1057                audio_size+=(fp?4:2)*outsamp*channels;
1058             }
1059             packet_count++;
1060          }
1061          /*We're done, drain the resampler if we were using it.*/
1062          if(eos && resampler)
1063          {
1064             float *zeros;
1065             int drain;
1066
1067             zeros=(float *)calloc(100*channels,sizeof(float));
1068             if(!zeros)
1069             {
1070                 fprintf(stderr, "Memory allocation failure.\n");
1071                 quit(1);
1072             }
1073             drain = speex_resampler_get_input_latency(resampler);
1074             do {
1075                opus_int64 outsamp;
1076                int tmp = drain;
1077                if (tmp > 100)
1078                   tmp = 100;
1079                outsamp=audio_write(zeros, channels, tmp, fout, resampler, NULL, &shapemem, strlen(outFile)!=0, ((page_granule-gran_offset)*rate/48000)-link_out,fp);
1080                link_out+=outsamp;
1081                audio_size+=(fp?4:2)*outsamp*channels;
1082                drain -= tmp;
1083             } while (drain>0);
1084             free(zeros);
1085             speex_resampler_destroy(resampler);
1086             resampler=NULL;
1087          }
1088          if(eos)
1089          {
1090             has_opus_stream=0;
1091             if(st)opus_multistream_decoder_destroy(st);
1092             st=NULL;
1093          }
1094       }
1095       if (feof(fin)) {
1096          if(!quiet) {
1097            fprintf(stderr, "\rDecoding complete.        \n");
1098            fflush(stderr);
1099          }
1100          break;
1101       }
1102    }
1103
1104    /*If we were writing wav, go set the duration.*/
1105    if (strlen(outFile)!=0 && fout && wav_format>0 && audio_size<0x7FFFFFFF)
1106    {
1107       if (fseek(fout,4,SEEK_SET)==0)
1108       {
1109          int tmp;
1110          tmp = le_int(audio_size+20+wav_format);
1111          if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing end length.\n");
1112          if (fseek(fout,16+wav_format,SEEK_CUR)==0)
1113          {
1114             tmp = le_int(audio_size);
1115             if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing header length.\n");
1116          } else
1117          {
1118             fprintf (stderr, "First seek worked, second didn't\n");
1119          }
1120       } else {
1121          fprintf (stderr, "Cannot seek on wav file output, wav size chunk will be incorrect\n");
1122       }
1123    }
1124
1125    /*Did we make it to the end without recovering ANY opus logical streams?*/
1126    if(!total_links)fprintf (stderr, "This doesn't look like a Opus file\n");
1127
1128    if (stream_init)
1129       ogg_stream_clear(&os);
1130    ogg_sync_clear(&oy);
1131
1132 #if defined WIN32 || defined _WIN32
1133    if (strlen(outFile)==0)
1134       WIN_Audio_close ();
1135 #endif
1136
1137    if(shapemem.a_buf)free(shapemem.a_buf);
1138    if(shapemem.b_buf)free(shapemem.b_buf);
1139
1140    if(output)free(output);
1141
1142    if(frange)fclose(frange);
1143
1144    if (close_in)
1145       fclose(fin);
1146    if (fout != NULL)
1147       fclose(fout);
1148
1149 #ifdef WIN_UNICODE
1150    free_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
1151    uninit_console_utf8();
1152 #endif
1153
1154    return 0;
1155 }