06f30e1982dcdb262115bf703c249c47fced9fd6
[opus.git] / src / opus_demo.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2009 Xiph.Org Foundation
3    Written by Jean-Marc Valin */
4 /*
5    Redistribution and use in source and binary forms, with or without
6    modification, are permitted provided that the following conditions
7    are met:
8
9    - Redistributions of source code must retain the above copyright
10    notice, this list of conditions and the following disclaimer.
11
12    - Redistributions in binary form must reproduce the above copyright
13    notice, this list of conditions and the following disclaimer in the
14    documentation and/or other materials provided with the distribution.
15
16    - Neither the name of Internet Society, IETF or IETF Trust, nor the
17    names of specific contributors, may be used to endorse or promote
18    products derived from this software without specific prior written
19    permission.
20
21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
25    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <math.h>
41 #include <string.h>
42 #include "opus.h"
43 #include "debug.h"
44 #include "opus_types.h"
45 #include "opus_private.h"
46
47 #define MAX_PACKET 1500
48
49 void print_usage( char* argv[] )
50 {
51     fprintf(stderr, "Usage: %s [-e] <application> <sampling rate (Hz)> <channels (1/2)> "
52         "<bits per second>  [options] <input> <output>\n", argv[0]);
53     fprintf(stderr, "       %s -d <sampling rate (Hz)> <channels (1/2)> "
54         "[options] <input> <output>\n\n", argv[0]);
55     fprintf(stderr, "mode: voip | audio | restricted-lowdelay\n" );
56     fprintf(stderr, "options:\n" );
57     fprintf(stderr, "-e                   : only runs the encoder (output the bit-stream)\n" );
58     fprintf(stderr, "-d                   : only runs the decoder (reads the bit-stream as input)\n" );
59     fprintf(stderr, "-cbr                 : enable constant bitrate; default: variable bitrate\n" );
60     fprintf(stderr, "-cvbr                : enable constrained variable bitrate; default: unconstrained\n" );
61     fprintf(stderr, "-bandwidth <NB|MB|WB|SWB|FB> : audio bandwidth (from narrowband to fullband); default: sampling rate\n" );
62     fprintf(stderr, "-framesize <2.5|5|10|20|40|60> : frame size in ms; default: 20 \n" );
63     fprintf(stderr, "-max_payload <bytes> : maximum payload size in bytes, default: 1024\n" );
64     fprintf(stderr, "-complexity <comp>   : complexity, 0 (lowest) ... 10 (highest); default: 10\n" );
65     fprintf(stderr, "-inbandfec           : enable SILK inband FEC\n" );
66     fprintf(stderr, "-forcemono           : force mono encoding, even for stereo input\n" );
67     fprintf(stderr, "-dtx                 : enable SILK DTX\n" );
68     fprintf(stderr, "-loss <perc>         : simulate packet loss, in percent (0-100); default: 0\n" );
69 }
70
71 #ifdef _WIN32
72 #   define STR_CASEINSENSITIVE_COMPARE(x, y) _stricmp(x, y)
73 #else
74 #   include <strings.h>
75 #   define STR_CASEINSENSITIVE_COMPARE(x, y) strcasecmp(x, y)
76 #endif
77
78 static void int_to_char(opus_uint32 i, unsigned char ch[4])
79 {
80     ch[0] = i>>24;
81     ch[1] = (i>>16)&0xFF;
82     ch[2] = (i>>8)&0xFF;
83     ch[3] = i&0xFF;
84 }
85
86 static opus_uint32 char_to_int(unsigned char ch[4])
87 {
88     return ((opus_uint32)ch[0]<<24) | ((opus_uint32)ch[1]<<16)
89          | ((opus_uint32)ch[2]<< 8) |  (opus_uint32)ch[3];
90 }
91
92 static void check_decoder_option(int encode_only, const char *opt)
93 {
94    if (encode_only)
95    {
96       fprintf(stderr, "option %s is only for decoding\n", opt);
97       exit(EXIT_FAILURE);
98    }
99 }
100
101 static void check_encoder_option(int decode_only, const char *opt)
102 {
103    if (decode_only)
104    {
105       fprintf(stderr, "option %s is only for encoding\n", opt);
106       exit(EXIT_FAILURE);
107    }
108 }
109
110 int silk8_test[][4] = {
111       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 1},
112       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 1},
113       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960,   1},
114       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480,   1},
115       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 2},
116       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 2},
117       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960,   2},
118       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480,   2}
119 };
120
121 int silk12_test[][4] = {
122       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 1},
123       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 1},
124       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960,   1},
125       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480,   1},
126       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 2},
127       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 2},
128       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960,   2},
129       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480,   2}
130 };
131
132 int silk16_test[][4] = {
133       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 1},
134       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 1},
135       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960,   1},
136       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480,   1},
137       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 2},
138       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 2},
139       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960,   2},
140       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480,   2}
141 };
142
143 int hybrid24_test[][4] = {
144       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1},
145       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1},
146       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2},
147       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2}
148 };
149
150 int hybrid48_test[][4] = {
151       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1},
152       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1},
153       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2},
154       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}
155 };
156
157 int celt_test[][4] = {
158       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 1},
159       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1},
160       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      960, 1},
161       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    960, 1},
162
163       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 1},
164       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1},
165       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      480, 1},
166       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    480, 1},
167
168       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 1},
169       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 1},
170       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      240, 1},
171       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    240, 1},
172
173       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 1},
174       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 1},
175       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      120, 1},
176       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    120, 1},
177
178       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 2},
179       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2},
180       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      960, 2},
181       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    960, 2},
182
183       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 2},
184       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2},
185       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      480, 2},
186       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    480, 2},
187
188       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 2},
189       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 2},
190       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      240, 2},
191       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    240, 2},
192
193       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 2},
194       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 2},
195       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      120, 2},
196       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    120, 2},
197
198 };
199
200 int celt_hq_test[][4] = {
201       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 2},
202       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 2},
203       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 2},
204       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 2},
205 };
206
207 int main(int argc, char *argv[])
208 {
209     int err;
210     char *inFile, *outFile;
211     FILE *fin, *fout;
212     OpusEncoder *enc=NULL;
213     OpusDecoder *dec=NULL;
214     int args;
215     int len[2];
216     int frame_size, channels;
217     opus_int32 bitrate_bps=0;
218     unsigned char *data[2];
219     opus_int32 sampling_rate;
220     int use_vbr;
221     int max_payload_bytes;
222     int complexity;
223     int use_inbandfec;
224     int use_dtx;
225     int forcechannels;
226     int cvbr = 0;
227     int packet_loss_perc;
228     opus_int32 count=0, count_act=0;
229     int k;
230     int skip=0;
231     int stop=0;
232     short *in, *out;
233     int application=OPUS_APPLICATION_AUDIO;
234     double bits=0.0, bits_max=0.0, bits_act=0.0, bits2=0.0, nrg;
235     int bandwidth=-1;
236     const char *bandwidth_string;
237     int lost = 0, lost_prev = 1;
238     int toggle = 0;
239     opus_uint32 enc_final_range[2];
240     opus_uint32 dec_final_range;
241     int encode_only=0, decode_only=0;
242     int max_frame_size = 960*6;
243     int curr_read=0;
244     int sweep_bps = 0;
245     int random_framesize=0, newsize=0, delayed_celt=0;
246     int sweep_max=0, sweep_min=0;
247     int random_fec=0;
248     int (*mode_list)[4]=NULL;
249     int nb_modes_in_list=0;
250     int curr_mode=0;
251     int curr_mode_count=0;
252     int mode_switch_time = 48000;
253
254     if (argc < 5 )
255     {
256        print_usage( argv );
257        return EXIT_FAILURE;
258     }
259
260     fprintf(stderr, "%s\n", opus_get_version_string());
261
262     args = 1;
263     if (strcmp(argv[args], "-e")==0)
264     {
265         encode_only = 1;
266         args++;
267     } else if (strcmp(argv[args], "-d")==0)
268     {
269         decode_only = 1;
270         args++;
271     }
272     if (!decode_only && argc < 7 )
273     {
274        print_usage( argv );
275        return EXIT_FAILURE;
276     }
277
278     if (!decode_only)
279     {
280        if (strcmp(argv[args], "voip")==0)
281           application = OPUS_APPLICATION_VOIP;
282        else if (strcmp(argv[args], "restricted-lowdelay")==0)
283           application = OPUS_APPLICATION_RESTRICTED_LOWDELAY;
284        else if (strcmp(argv[args], "audio")!=0) {
285           fprintf(stderr, "unknown application: %s\n", argv[args]);
286           print_usage(argv);
287           return EXIT_FAILURE;
288        }
289        args++;
290     }
291     sampling_rate = (opus_int32)atol(argv[args]);
292     args++;
293     channels = atoi(argv[args]);
294     args++;
295     if (!decode_only)
296     {
297        bitrate_bps = (opus_int32)atol(argv[args]);
298        args++;
299     }
300
301     if (sampling_rate != 8000 && sampling_rate != 12000
302      && sampling_rate != 16000 && sampling_rate != 24000
303      && sampling_rate != 48000)
304     {
305         fprintf(stderr, "Supported sampling rates are 8000, 12000, "
306                 "16000, 24000 and 48000.\n");
307         return EXIT_FAILURE;
308     }
309     frame_size = sampling_rate/50;
310
311     /* defaults: */
312     use_vbr = 1;
313     bandwidth = OPUS_AUTO;
314     max_payload_bytes = MAX_PACKET;
315     complexity = 10;
316     use_inbandfec = 0;
317     forcechannels = OPUS_AUTO;
318     use_dtx = 0;
319     packet_loss_perc = 0;
320     max_frame_size = 960*6;
321     curr_read=0;
322
323     while( args < argc - 2 ) {
324         /* process command line options */
325         if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cbr" ) == 0 ) {
326             check_encoder_option(decode_only, "-cbr");
327             use_vbr = 0;
328             args++;
329         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-bandwidth" ) == 0 ) {
330             check_encoder_option(decode_only, "-bandwidth");
331             if (strcmp(argv[ args + 1 ], "NB")==0)
332                 bandwidth = OPUS_BANDWIDTH_NARROWBAND;
333             else if (strcmp(argv[ args + 1 ], "MB")==0)
334                 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
335             else if (strcmp(argv[ args + 1 ], "WB")==0)
336                 bandwidth = OPUS_BANDWIDTH_WIDEBAND;
337             else if (strcmp(argv[ args + 1 ], "SWB")==0)
338                 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
339             else if (strcmp(argv[ args + 1 ], "FB")==0)
340                 bandwidth = OPUS_BANDWIDTH_FULLBAND;
341             else {
342                 fprintf(stderr, "Unknown bandwidth %s. "
343                                 "Supported are NB, MB, WB, SWB, FB.\n",
344                                 argv[ args + 1 ]);
345                 return EXIT_FAILURE;
346             }
347             args += 2;
348         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-framesize" ) == 0 ) {
349             check_encoder_option(decode_only, "-framesize");
350             if (strcmp(argv[ args + 1 ], "2.5")==0)
351                 frame_size = sampling_rate/400;
352             else if (strcmp(argv[ args + 1 ], "5")==0)
353                 frame_size = sampling_rate/200;
354             else if (strcmp(argv[ args + 1 ], "10")==0)
355                 frame_size = sampling_rate/100;
356             else if (strcmp(argv[ args + 1 ], "20")==0)
357                 frame_size = sampling_rate/50;
358             else if (strcmp(argv[ args + 1 ], "40")==0)
359                 frame_size = sampling_rate/25;
360             else if (strcmp(argv[ args + 1 ], "60")==0)
361                 frame_size = 3*sampling_rate/50;
362             else {
363                 fprintf(stderr, "Unsupported frame size: %s ms. "
364                                 "Supported are 2.5, 5, 10, 20, 40, 60.\n",
365                                 argv[ args + 1 ]);
366                 return EXIT_FAILURE;
367             }
368             args += 2;
369         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-max_payload" ) == 0 ) {
370             check_encoder_option(decode_only, "-max_payload");
371             max_payload_bytes = atoi( argv[ args + 1 ] );
372             args += 2;
373         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) {
374             check_encoder_option(decode_only, "-complexity");
375             complexity = atoi( argv[ args + 1 ] );
376             args += 2;
377         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-inbandfec" ) == 0 ) {
378             use_inbandfec = 1;
379             args++;
380         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-forcemono" ) == 0 ) {
381             check_encoder_option(decode_only, "-forcemono");
382             forcechannels = 1;
383             args++;
384         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cvbr" ) == 0 ) {
385             check_encoder_option(decode_only, "-cvbr");
386             cvbr = 1;
387             args++;
388         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-dtx") == 0 ) {
389             check_encoder_option(decode_only, "-dtx");
390             use_dtx = 1;
391             args++;
392         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-loss" ) == 0 ) {
393             check_decoder_option(encode_only, "-loss");
394             packet_loss_perc = atoi( argv[ args + 1 ] );
395             args += 2;
396         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep" ) == 0 ) {
397             check_encoder_option(decode_only, "-sweep");
398             sweep_bps = atoi( argv[ args + 1 ] );
399             args += 2;
400         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_framesize" ) == 0 ) {
401             check_encoder_option(decode_only, "-random_framesize");
402             random_framesize = 1;
403             args++;
404         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep_max" ) == 0 ) {
405             check_encoder_option(decode_only, "-sweep_max");
406             sweep_max = atoi( argv[ args + 1 ] );
407             args += 2;
408         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_fec" ) == 0 ) {
409             check_encoder_option(decode_only, "-random_fec");
410             random_fec = 1;
411             args++;
412         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk8k_test" ) == 0 ) {
413             check_encoder_option(decode_only, "-silk8k_test");
414             mode_list = silk8_test;
415             nb_modes_in_list = 8;
416             args++;
417         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk12k_test" ) == 0 ) {
418             check_encoder_option(decode_only, "-silk12k_test");
419             mode_list = silk12_test;
420             nb_modes_in_list = 8;
421             args++;
422         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk16k_test" ) == 0 ) {
423             check_encoder_option(decode_only, "-silk16k_test");
424             mode_list = silk16_test;
425             nb_modes_in_list = 8;
426             args++;
427         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-hybrid24k_test" ) == 0 ) {
428             check_encoder_option(decode_only, "-hybrid24k_test");
429             mode_list = hybrid24_test;
430             nb_modes_in_list = 4;
431             args++;
432         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-hybrid48k_test" ) == 0 ) {
433             check_encoder_option(decode_only, "-hybrid48k_test");
434             mode_list = hybrid48_test;
435             nb_modes_in_list = 4;
436             args++;
437         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-celt_test" ) == 0 ) {
438             check_encoder_option(decode_only, "-celt_test");
439             mode_list = celt_test;
440             nb_modes_in_list = 32;
441             args++;
442         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-celt_hq_test" ) == 0 ) {
443             check_encoder_option(decode_only, "-celt_hq_test");
444             mode_list = celt_hq_test;
445             nb_modes_in_list = 4;
446             args++;
447         } else {
448             printf( "Error: unrecognized setting: %s\n\n", argv[ args ] );
449             print_usage( argv );
450             return EXIT_FAILURE;
451         }
452     }
453
454     if (sweep_max)
455        sweep_min = bitrate_bps;
456
457     if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET)
458     {
459         fprintf (stderr, "max_payload_bytes must be between 0 and %d\n",
460                           MAX_PACKET);
461         return EXIT_FAILURE;
462     }
463
464     inFile = argv[argc-2];
465     fin = fopen(inFile, "rb");
466     if (!fin)
467     {
468         fprintf (stderr, "Could not open input file %s\n", argv[argc-2]);
469         return EXIT_FAILURE;
470     }
471     if (mode_list)
472     {
473        int size;
474        fseek(fin, 0, SEEK_END);
475        size = ftell(fin);
476        fprintf(stderr, "File size is %d bytes\n", size);
477        fseek(fin, 0, SEEK_SET);
478        mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list;
479        fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time);
480     }
481
482     outFile = argv[argc-1];
483     fout = fopen(outFile, "wb+");
484     if (!fout)
485     {
486         fprintf (stderr, "Could not open output file %s\n", argv[argc-1]);
487         fclose(fin);
488         return EXIT_FAILURE;
489     }
490
491     if (!decode_only)
492     {
493        enc = opus_encoder_create(sampling_rate, channels, application, &err);
494        if (err != OPUS_OK)
495        {
496           fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err));
497           fclose(fin);
498           fclose(fout);
499           return EXIT_FAILURE;
500        }
501        opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
502        opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth));
503        opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr));
504        opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr));
505        opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
506        opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec));
507        opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels));
508        opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx));
509        opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc));
510
511        opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip));
512     }
513     if (!encode_only)
514     {
515        dec = opus_decoder_create(sampling_rate, channels, &err);
516        if (err != OPUS_OK)
517        {
518           fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err));
519           fclose(fin);
520           fclose(fout);
521           return EXIT_FAILURE;
522        }
523     }
524
525
526     switch(bandwidth)
527     {
528     case OPUS_BANDWIDTH_NARROWBAND:
529          bandwidth_string = "narrowband";
530          break;
531     case OPUS_BANDWIDTH_MEDIUMBAND:
532          bandwidth_string = "mediumband";
533          break;
534     case OPUS_BANDWIDTH_WIDEBAND:
535          bandwidth_string = "wideband";
536          break;
537     case OPUS_BANDWIDTH_SUPERWIDEBAND:
538          bandwidth_string = "superwideband";
539          break;
540     case OPUS_BANDWIDTH_FULLBAND:
541          bandwidth_string = "fullband";
542          break;
543     case OPUS_AUTO:
544          bandwidth_string = "auto";
545          break;
546     default:
547          bandwidth_string = "unknown";
548          break;
549     }
550
551     if (decode_only)
552        fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n",
553                        (long)sampling_rate, channels);
554     else
555        fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s "
556                        "in %s mode with %d-sample frames.\n",
557                        (long)sampling_rate, bitrate_bps*0.001,
558                        bandwidth_string, frame_size);
559
560     in = (short*)malloc(max_frame_size*channels*sizeof(short));
561     out = (short*)malloc(max_frame_size*channels*sizeof(short));
562     data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
563     if ( use_inbandfec ) {
564         data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
565     }
566     while (!stop)
567     {
568         if (delayed_celt)
569         {
570             frame_size = newsize;
571             delayed_celt = 0;
572         } else if (random_framesize && rand()%20==0)
573         {
574             newsize = rand()%6;
575             switch(newsize)
576             {
577             case 0: newsize=sampling_rate/400; break;
578             case 1: newsize=sampling_rate/200; break;
579             case 2: newsize=sampling_rate/100; break;
580             case 3: newsize=sampling_rate/50; break;
581             case 4: newsize=sampling_rate/25; break;
582             case 5: newsize=3*sampling_rate/50; break;
583             }
584             while (newsize < sampling_rate/25 && bitrate_bps-fabs(sweep_bps) <= 3*12*sampling_rate/newsize)
585                newsize*=2;
586             if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100)
587             {
588                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
589                 delayed_celt=1;
590             } else {
591                 frame_size = newsize;
592             }
593         }
594         if (random_fec && rand()%30==0)
595         {
596            opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0));
597         }
598         if (decode_only)
599         {
600             unsigned char ch[4];
601             err = fread(ch, 1, 4, fin);
602             if (feof(fin))
603                 break;
604             len[toggle] = char_to_int(ch);
605             if (len[toggle]>max_payload_bytes || len[toggle]<0)
606             {
607                 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]);
608                 break;
609             }
610             err = fread(ch, 1, 4, fin);
611             enc_final_range[toggle] = char_to_int(ch);
612             err = fread(data[toggle], 1, len[toggle], fin);
613             if (err<len[toggle])
614             {
615                 fprintf(stderr, "Ran out of input, "
616                                 "expecting %d bytes got %d\n",
617                                 len[toggle],err);
618                 break;
619             }
620         } else {
621             if (mode_list!=NULL)
622             {
623                 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1]));
624                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0]));
625                 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3]));
626                 frame_size = mode_list[curr_mode][2];
627             }
628             err = fread(in, sizeof(short)*channels, frame_size, fin);
629             curr_read = err;
630             if (curr_read < frame_size)
631             {
632                 int i;
633                 for (i=curr_read*channels;i<frame_size*channels;i++)
634                    in[i] = 0;
635                 stop = 1;
636             }
637             len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes);
638             if (sweep_bps!=0)
639             {
640                bitrate_bps += sweep_bps;
641                if (sweep_max)
642                {
643                   if (bitrate_bps > sweep_max)
644                      sweep_bps = -sweep_bps;
645                   else if (bitrate_bps < sweep_min)
646                      sweep_bps = -sweep_bps;
647                }
648                /* safety */
649                if (bitrate_bps<1000)
650                   bitrate_bps = 1000;
651                opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
652             }
653             opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle]));
654             if (len[toggle] < 0)
655             {
656                 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]);
657                 fclose(fin);
658                 fclose(fout);
659                 return EXIT_FAILURE;
660             }
661             curr_mode_count += frame_size;
662             if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1)
663             {
664                curr_mode++;
665                curr_mode_count = 0;
666             }
667         }
668
669         if (encode_only)
670         {
671             unsigned char int_field[4];
672             int_to_char(len[toggle], int_field);
673             if (fwrite(int_field, 1, 4, fout) != 4) {
674                fprintf(stderr, "Error writing.\n");
675                return EXIT_FAILURE;
676             }
677             int_to_char(enc_final_range[toggle], int_field);
678             if (fwrite(int_field, 1, 4, fout) != 4) {
679                fprintf(stderr, "Error writing.\n");
680                return EXIT_FAILURE;
681             }
682             if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) {
683                fprintf(stderr, "Error writing.\n");
684                return EXIT_FAILURE;
685             }
686         } else {
687             int output_samples;
688             lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc);
689             if( count >= use_inbandfec ) {
690                 /* delay by one packet when using in-band FEC */
691                 if( use_inbandfec  ) {
692                     if( lost_prev ) {
693                         /* attempt to decode with in-band FEC from next packet */
694                         output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 1);
695                     } else {
696                         /* regular decode */
697                         output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, max_frame_size, 0);
698                     }
699                 } else {
700                     output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 0);
701                 }
702                 if (output_samples>0)
703                 {
704                     if (output_samples>skip) {
705                        if (fwrite(out+skip*channels, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){
706                           fprintf(stderr, "Error writing.\n");
707                           return EXIT_FAILURE;
708                        }
709                     }
710                     if (output_samples<skip) skip -= output_samples;
711                     else skip = 0;
712                 } else {
713                    fprintf(stderr, "error decoding frame: %s\n",
714                                    opus_strerror(output_samples));
715                 }
716             }
717         }
718
719         if (!encode_only)
720            opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
721         /* compare final range encoder rng values of encoder and decoder */
722         if( enc_final_range[toggle^use_inbandfec]!=0  && !encode_only
723          && !lost && !lost_prev
724          && dec_final_range != enc_final_range[toggle^use_inbandfec] ) {
725             fprintf (stderr, "Error: Range coder state mismatch "
726                              "between encoder and decoder "
727                              "in frame %ld: 0x%8lx vs 0x%8lx\n",
728                          (long)count,
729                          (unsigned long)enc_final_range[toggle^use_inbandfec],
730                          (unsigned long)dec_final_range);
731             fclose(fin);
732             fclose(fout);
733             return EXIT_FAILURE;
734         }
735
736         lost_prev = lost;
737
738         /* count bits */
739         bits += len[toggle]*8;
740         bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max;
741         if( count >= use_inbandfec ) {
742             nrg = 0.0;
743             if (!decode_only)
744             {
745                 for ( k = 0; k < frame_size * channels; k++ ) {
746                     nrg += in[ k ] * (double)in[ k ];
747                 }
748             }
749             if ( ( nrg / ( frame_size * channels ) ) > 1e5 ) {
750                 bits_act += len[toggle]*8;
751                 count_act++;
752             }
753             /* Variance */
754             bits2 += len[toggle]*len[toggle]*64;
755         }
756         count++;
757         toggle = (toggle + use_inbandfec) & 1;
758     }
759     fprintf (stderr, "average bitrate:             %7.3f kb/s\n",
760                      1e-3*bits*sampling_rate/(frame_size*(double)count));
761     fprintf (stderr, "maximum bitrate:             %7.3f bkp/s\n",
762                      1e-3*bits_max*sampling_rate/frame_size);
763     if (!decode_only)
764        fprintf (stderr, "active bitrate:              %7.3f kb/s\n",
765                1e-3*bits_act*sampling_rate/(frame_size*(double)count_act));
766     fprintf (stderr, "bitrate standard deviation:  %7.3f kb/s\n",
767             1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size);
768     /* Close any files to which intermediate results were stored */
769     SILK_DEBUG_STORE_CLOSE_FILES
770     silk_TimerSave("opus_timing.txt");
771     opus_encoder_destroy(enc);
772     opus_decoder_destroy(dec);
773     free(data[0]);
774     if (use_inbandfec)
775         free(data[1]);
776     fclose(fin);
777     fclose(fout);
778     free(in);
779     free(out);
780     return EXIT_SUCCESS;
781 }