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