df9e70de9bf419c4a704840db863a5386fc92d9a
[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 ], "-delayed-decision" ) == 0 ) {
419             check_encoder_option(decode_only, "-delayed-decision");
420             delayed_decision = 1;
421             args++;
422         } else if( strcmp( argv[ args ], "-dtx") == 0 ) {
423             check_encoder_option(decode_only, "-dtx");
424             use_dtx = 1;
425             args++;
426         } else if( strcmp( argv[ args ], "-loss" ) == 0 ) {
427             packet_loss_perc = atoi( argv[ args + 1 ] );
428             args += 2;
429         } else if( strcmp( argv[ args ], "-sweep" ) == 0 ) {
430             check_encoder_option(decode_only, "-sweep");
431             sweep_bps = atoi( argv[ args + 1 ] );
432             args += 2;
433         } else if( strcmp( argv[ args ], "-random_framesize" ) == 0 ) {
434             check_encoder_option(decode_only, "-random_framesize");
435             random_framesize = 1;
436             args++;
437         } else if( strcmp( argv[ args ], "-sweep_max" ) == 0 ) {
438             check_encoder_option(decode_only, "-sweep_max");
439             sweep_max = atoi( argv[ args + 1 ] );
440             args += 2;
441         } else if( strcmp( argv[ args ], "-random_fec" ) == 0 ) {
442             check_encoder_option(decode_only, "-random_fec");
443             random_fec = 1;
444             args++;
445         } else if( strcmp( argv[ args ], "-silk8k_test" ) == 0 ) {
446             check_encoder_option(decode_only, "-silk8k_test");
447             mode_list = silk8_test;
448             nb_modes_in_list = 8;
449             args++;
450         } else if( strcmp( argv[ args ], "-silk12k_test" ) == 0 ) {
451             check_encoder_option(decode_only, "-silk12k_test");
452             mode_list = silk12_test;
453             nb_modes_in_list = 8;
454             args++;
455         } else if( strcmp( argv[ args ], "-silk16k_test" ) == 0 ) {
456             check_encoder_option(decode_only, "-silk16k_test");
457             mode_list = silk16_test;
458             nb_modes_in_list = 8;
459             args++;
460         } else if( strcmp( argv[ args ], "-hybrid24k_test" ) == 0 ) {
461             check_encoder_option(decode_only, "-hybrid24k_test");
462             mode_list = hybrid24_test;
463             nb_modes_in_list = 4;
464             args++;
465         } else if( strcmp( argv[ args ], "-hybrid48k_test" ) == 0 ) {
466             check_encoder_option(decode_only, "-hybrid48k_test");
467             mode_list = hybrid48_test;
468             nb_modes_in_list = 4;
469             args++;
470         } else if( strcmp( argv[ args ], "-celt_test" ) == 0 ) {
471             check_encoder_option(decode_only, "-celt_test");
472             mode_list = celt_test;
473             nb_modes_in_list = 32;
474             args++;
475         } else if( strcmp( argv[ args ], "-celt_hq_test" ) == 0 ) {
476             check_encoder_option(decode_only, "-celt_hq_test");
477             mode_list = celt_hq_test;
478             nb_modes_in_list = 4;
479             args++;
480         } else {
481             printf( "Error: unrecognized setting: %s\n\n", argv[ args ] );
482             print_usage( argv );
483             return EXIT_FAILURE;
484         }
485     }
486
487     if (sweep_max)
488        sweep_min = bitrate_bps;
489
490     if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET)
491     {
492         fprintf (stderr, "max_payload_bytes must be between 0 and %d\n",
493                           MAX_PACKET);
494         return EXIT_FAILURE;
495     }
496
497     inFile = argv[argc-2];
498     fin = fopen(inFile, "rb");
499     if (!fin)
500     {
501         fprintf (stderr, "Could not open input file %s\n", argv[argc-2]);
502         return EXIT_FAILURE;
503     }
504     if (mode_list)
505     {
506        int size;
507        fseek(fin, 0, SEEK_END);
508        size = ftell(fin);
509        fprintf(stderr, "File size is %d bytes\n", size);
510        fseek(fin, 0, SEEK_SET);
511        mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list;
512        fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time);
513     }
514
515     outFile = argv[argc-1];
516     fout = fopen(outFile, "wb+");
517     if (!fout)
518     {
519         fprintf (stderr, "Could not open output file %s\n", argv[argc-1]);
520         fclose(fin);
521         return EXIT_FAILURE;
522     }
523
524     if (!decode_only)
525     {
526        enc = opus_encoder_create(sampling_rate, channels, application, &err);
527        if (err != OPUS_OK)
528        {
529           fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err));
530           fclose(fin);
531           fclose(fout);
532           return EXIT_FAILURE;
533        }
534        opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
535        opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth));
536        opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr));
537        opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr));
538        opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
539        opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec));
540        opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels));
541        opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx));
542        opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc));
543
544        opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip));
545        opus_encoder_ctl(enc, OPUS_SET_LSB_DEPTH(16));
546        opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration));
547     }
548     if (!encode_only)
549     {
550        dec = opus_decoder_create(sampling_rate, channels, &err);
551        if (err != OPUS_OK)
552        {
553           fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err));
554           fclose(fin);
555           fclose(fout);
556           return EXIT_FAILURE;
557        }
558     }
559
560
561     switch(bandwidth)
562     {
563     case OPUS_BANDWIDTH_NARROWBAND:
564          bandwidth_string = "narrowband";
565          break;
566     case OPUS_BANDWIDTH_MEDIUMBAND:
567          bandwidth_string = "mediumband";
568          break;
569     case OPUS_BANDWIDTH_WIDEBAND:
570          bandwidth_string = "wideband";
571          break;
572     case OPUS_BANDWIDTH_SUPERWIDEBAND:
573          bandwidth_string = "superwideband";
574          break;
575     case OPUS_BANDWIDTH_FULLBAND:
576          bandwidth_string = "fullband";
577          break;
578     case OPUS_AUTO:
579          bandwidth_string = "auto bandwidth";
580          break;
581     default:
582          bandwidth_string = "unknown";
583          break;
584     }
585
586     if (decode_only)
587        fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n",
588                        (long)sampling_rate, channels);
589     else
590        fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s "
591                        "in %s with %d-sample frames.\n",
592                        (long)sampling_rate, bitrate_bps*0.001,
593                        bandwidth_string, frame_size);
594
595     in = (short*)malloc(max_frame_size*channels*sizeof(short));
596     out = (short*)malloc(max_frame_size*channels*sizeof(short));
597     /* We need to allocate for 16-bit PCM data, but we store it as unsigned char. */
598     fbytes = (unsigned char*)malloc(max_frame_size*channels*sizeof(short));
599     data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(unsigned char));
600     if ( use_inbandfec ) {
601         data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(unsigned char));
602     }
603     if(delayed_decision)
604     {
605        if (frame_size==sampling_rate/400)
606           variable_duration = OPUS_FRAMESIZE_2_5_MS;
607        else if (frame_size==sampling_rate/200)
608           variable_duration = OPUS_FRAMESIZE_5_MS;
609        else if (frame_size==sampling_rate/100)
610           variable_duration = OPUS_FRAMESIZE_10_MS;
611        else if (frame_size==sampling_rate/50)
612           variable_duration = OPUS_FRAMESIZE_20_MS;
613        else if (frame_size==sampling_rate/25)
614           variable_duration = OPUS_FRAMESIZE_40_MS;
615        else if (frame_size==3*sampling_rate/50)
616           variable_duration = OPUS_FRAMESIZE_60_MS;
617        else if (frame_size==4*sampling_rate/50)
618           variable_duration = OPUS_FRAMESIZE_80_MS;
619        else if (frame_size==5*sampling_rate/50)
620           variable_duration = OPUS_FRAMESIZE_100_MS;
621        else
622           variable_duration = OPUS_FRAMESIZE_120_MS;
623        opus_encoder_ctl(enc, OPUS_SET_EXPERT_FRAME_DURATION(variable_duration));
624        frame_size = 2*48000;
625     }
626     while (!stop)
627     {
628         if (delayed_celt)
629         {
630             frame_size = newsize;
631             delayed_celt = 0;
632         } else if (random_framesize && rand()%20==0)
633         {
634             newsize = rand()%6;
635             switch(newsize)
636             {
637             case 0: newsize=sampling_rate/400; break;
638             case 1: newsize=sampling_rate/200; break;
639             case 2: newsize=sampling_rate/100; break;
640             case 3: newsize=sampling_rate/50; break;
641             case 4: newsize=sampling_rate/25; break;
642             case 5: newsize=3*sampling_rate/50; break;
643             }
644             while (newsize < sampling_rate/25 && bitrate_bps-abs(sweep_bps) <= 3*12*sampling_rate/newsize)
645                newsize*=2;
646             if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100)
647             {
648                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
649                 delayed_celt=1;
650             } else {
651                 frame_size = newsize;
652             }
653         }
654         if (random_fec && rand()%30==0)
655         {
656            opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0));
657         }
658         if (decode_only)
659         {
660             unsigned char ch[4];
661             err = fread(ch, 1, 4, fin);
662             if (feof(fin))
663                 break;
664             len[toggle] = char_to_int(ch);
665             if (len[toggle]>max_payload_bytes || len[toggle]<0)
666             {
667                 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]);
668                 break;
669             }
670             err = fread(ch, 1, 4, fin);
671             enc_final_range[toggle] = char_to_int(ch);
672             err = fread(data[toggle], 1, len[toggle], fin);
673             if (err<len[toggle])
674             {
675                 fprintf(stderr, "Ran out of input, "
676                                 "expecting %d bytes got %d\n",
677                                 len[toggle],err);
678                 break;
679             }
680         } else {
681             int i;
682             if (mode_list!=NULL)
683             {
684                 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1]));
685                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0]));
686                 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3]));
687                 frame_size = mode_list[curr_mode][2];
688             }
689             err = fread(fbytes, sizeof(short)*channels, frame_size-remaining, fin);
690             curr_read = err;
691             tot_in += curr_read;
692             for(i=0;i<curr_read*channels;i++)
693             {
694                 opus_int32 s;
695                 s=fbytes[2*i+1]<<8|fbytes[2*i];
696                 s=((s&0xFFFF)^0x8000)-0x8000;
697                 in[i+remaining*channels]=s;
698             }
699             if (curr_read+remaining < frame_size)
700             {
701                 for (i=(curr_read+remaining)*channels;i<frame_size*channels;i++)
702                    in[i] = 0;
703                 if (encode_only || decode_only)
704                    stop = 1;
705             }
706             len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes);
707             nb_encoded = opus_packet_get_samples_per_frame(data[toggle], sampling_rate)*opus_packet_get_nb_frames(data[toggle], len[toggle]);
708             remaining = frame_size-nb_encoded;
709             for(i=0;i<remaining*channels;i++)
710                in[i] = in[nb_encoded*channels+i];
711             if (sweep_bps!=0)
712             {
713                bitrate_bps += sweep_bps;
714                if (sweep_max)
715                {
716                   if (bitrate_bps > sweep_max)
717                      sweep_bps = -sweep_bps;
718                   else if (bitrate_bps < sweep_min)
719                      sweep_bps = -sweep_bps;
720                }
721                /* safety */
722                if (bitrate_bps<1000)
723                   bitrate_bps = 1000;
724                opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
725             }
726             opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle]));
727             if (len[toggle] < 0)
728             {
729                 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]);
730                 fclose(fin);
731                 fclose(fout);
732                 return EXIT_FAILURE;
733             }
734             curr_mode_count += frame_size;
735             if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1)
736             {
737                curr_mode++;
738                curr_mode_count = 0;
739             }
740         }
741
742 #if 0 /* This is for testing the padding code, do not enable by default */
743         if (len[toggle]<1275)
744         {
745            int new_len = len[toggle]+rand()%(max_payload_bytes-len[toggle]);
746            if ((err = opus_packet_pad(data[toggle], len[toggle], new_len)) != OPUS_OK)
747            {
748               fprintf(stderr, "padding failed: %s\n", opus_strerror(err));
749               return EXIT_FAILURE;
750            }
751            len[toggle] = new_len;
752         }
753 #endif
754         if (encode_only)
755         {
756             unsigned char int_field[4];
757             int_to_char(len[toggle], int_field);
758             if (fwrite(int_field, 1, 4, fout) != 4) {
759                fprintf(stderr, "Error writing.\n");
760                return EXIT_FAILURE;
761             }
762             int_to_char(enc_final_range[toggle], int_field);
763             if (fwrite(int_field, 1, 4, fout) != 4) {
764                fprintf(stderr, "Error writing.\n");
765                return EXIT_FAILURE;
766             }
767             if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) {
768                fprintf(stderr, "Error writing.\n");
769                return EXIT_FAILURE;
770             }
771             tot_samples += nb_encoded;
772         } else {
773             opus_int32 output_samples;
774             lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc);
775             if (lost)
776                opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples));
777             else
778                output_samples = max_frame_size;
779             if( count >= use_inbandfec ) {
780                 /* delay by one packet when using in-band FEC */
781                 if( use_inbandfec  ) {
782                     if( lost_prev ) {
783                         /* attempt to decode with in-band FEC from next packet */
784                         opus_decoder_ctl(dec, OPUS_GET_LAST_PACKET_DURATION(&output_samples));
785                         output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 1);
786                     } else {
787                         /* regular decode */
788                         output_samples = max_frame_size;
789                         output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, output_samples, 0);
790                     }
791                 } else {
792                     output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, output_samples, 0);
793                 }
794                 if (output_samples>0)
795                 {
796                     if (!decode_only && tot_out + output_samples > tot_in)
797                     {
798                        stop=1;
799                        output_samples  = tot_in-tot_out;
800                     }
801                     if (output_samples>skip) {
802                        int i;
803                        for(i=0;i<(output_samples-skip)*channels;i++)
804                        {
805                           short s;
806                           s=out[i+(skip*channels)];
807                           fbytes[2*i]=s&0xFF;
808                           fbytes[2*i+1]=(s>>8)&0xFF;
809                        }
810                        if (fwrite(fbytes, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){
811                           fprintf(stderr, "Error writing.\n");
812                           return EXIT_FAILURE;
813                        }
814                        tot_out += output_samples-skip;
815                     }
816                     if (output_samples<skip) skip -= output_samples;
817                     else skip = 0;
818                 } else {
819                    fprintf(stderr, "error decoding frame: %s\n",
820                                    opus_strerror(output_samples));
821                 }
822                 tot_samples += output_samples;
823             }
824         }
825
826         if (!encode_only)
827            opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
828         /* compare final range encoder rng values of encoder and decoder */
829         if( enc_final_range[toggle^use_inbandfec]!=0  && !encode_only
830          && !lost && !lost_prev
831          && dec_final_range != enc_final_range[toggle^use_inbandfec] ) {
832             fprintf (stderr, "Error: Range coder state mismatch "
833                              "between encoder and decoder "
834                              "in frame %ld: 0x%8lx vs 0x%8lx\n",
835                          (long)count,
836                          (unsigned long)enc_final_range[toggle^use_inbandfec],
837                          (unsigned long)dec_final_range);
838             fclose(fin);
839             fclose(fout);
840             return EXIT_FAILURE;
841         }
842
843         lost_prev = lost;
844         if( count >= use_inbandfec ) {
845             /* count bits */
846             bits += len[toggle]*8;
847             bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max;
848             bits2 += len[toggle]*len[toggle]*64;
849             if (!decode_only)
850             {
851                 nrg = 0.0;
852                 for ( k = 0; k < frame_size * channels; k++ ) {
853                     nrg += in[ k ] * (double)in[ k ];
854                 }
855                 nrg /= frame_size * channels;
856                 if( nrg > 1e5 ) {
857                     bits_act += len[toggle]*8;
858                     count_act++;
859                 }
860             }
861         }
862         count++;
863         toggle = (toggle + use_inbandfec) & 1;
864     }
865
866     /* Print out bitrate statistics */
867     if(decode_only)
868         frame_size = (int)(tot_samples / count);
869     count -= use_inbandfec;
870     fprintf (stderr, "average bitrate:             %7.3f kb/s\n",
871                      1e-3*bits*sampling_rate/tot_samples);
872     fprintf (stderr, "maximum bitrate:             %7.3f kb/s\n",
873                      1e-3*bits_max*sampling_rate/frame_size);
874     if (!decode_only)
875        fprintf (stderr, "active bitrate:              %7.3f kb/s\n",
876                1e-3*bits_act*sampling_rate/(1e-15+frame_size*(double)count_act));
877     fprintf (stderr, "bitrate standard deviation:  %7.3f kb/s\n",
878             1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size);
879     /* Close any files to which intermediate results were stored */
880     SILK_DEBUG_STORE_CLOSE_FILES
881     silk_TimerSave("opus_timing.txt");
882     opus_encoder_destroy(enc);
883     opus_decoder_destroy(dec);
884     free(data[0]);
885     if (use_inbandfec)
886         free(data[1]);
887     fclose(fin);
888     fclose(fout);
889     free(in);
890     free(out);
891     free(fbytes);
892     return EXIT_SUCCESS;
893 }