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