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