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