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