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