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