Make opus_demo r/w little-endian PCM independent of host byte-order.
[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    - Neither the name of Internet Society, IETF or IETF Trust, nor the
17    names of specific contributors, may be used to endorse or promote
18    products derived from this software without specific prior written
19    permission.
20
21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
25    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <math.h>
41 #include <string.h>
42 #include "opus.h"
43 #include "debug.h"
44 #include "opus_types.h"
45 #include "opus_private.h"
46
47 #define MAX_PACKET 1500
48
49 void print_usage( char* argv[] )
50 {
51     fprintf(stderr, "Usage: %s [-e] <application> <sampling rate (Hz)> <channels (1/2)> "
52         "<bits per second>  [options] <input> <output>\n", argv[0]);
53     fprintf(stderr, "       %s -d <sampling rate (Hz)> <channels (1/2)> "
54         "[options] <input> <output>\n\n", argv[0]);
55     fprintf(stderr, "mode: voip | audio | restricted-lowdelay\n" );
56     fprintf(stderr, "options:\n" );
57     fprintf(stderr, "-e                   : only runs the encoder (output the bit-stream)\n" );
58     fprintf(stderr, "-d                   : only runs the decoder (reads the bit-stream as input)\n" );
59     fprintf(stderr, "-cbr                 : enable constant bitrate; default: variable bitrate\n" );
60     fprintf(stderr, "-cvbr                : enable constrained variable bitrate; default: unconstrained\n" );
61     fprintf(stderr, "-bandwidth <NB|MB|WB|SWB|FB> : audio bandwidth (from narrowband to fullband); default: sampling rate\n" );
62     fprintf(stderr, "-framesize <2.5|5|10|20|40|60> : frame size in ms; default: 20 \n" );
63     fprintf(stderr, "-max_payload <bytes> : maximum payload size in bytes, default: 1024\n" );
64     fprintf(stderr, "-complexity <comp>   : complexity, 0 (lowest) ... 10 (highest); default: 10\n" );
65     fprintf(stderr, "-inbandfec           : enable SILK inband FEC\n" );
66     fprintf(stderr, "-forcemono           : force mono encoding, even for stereo input\n" );
67     fprintf(stderr, "-dtx                 : enable SILK DTX\n" );
68     fprintf(stderr, "-loss <perc>         : simulate packet loss, in percent (0-100); default: 0\n" );
69 }
70
71 #ifdef _WIN32
72 #   define STR_CASEINSENSITIVE_COMPARE(x, y) _stricmp(x, y)
73 #else
74 #   include <strings.h>
75 #   define STR_CASEINSENSITIVE_COMPARE(x, y) strcasecmp(x, y)
76 #endif
77
78 static void int_to_char(opus_uint32 i, unsigned char ch[4])
79 {
80     ch[0] = i>>24;
81     ch[1] = (i>>16)&0xFF;
82     ch[2] = (i>>8)&0xFF;
83     ch[3] = i&0xFF;
84 }
85
86 static opus_uint32 char_to_int(unsigned char ch[4])
87 {
88     return ((opus_uint32)ch[0]<<24) | ((opus_uint32)ch[1]<<16)
89          | ((opus_uint32)ch[2]<< 8) |  (opus_uint32)ch[3];
90 }
91
92 static void check_decoder_option(int encode_only, const char *opt)
93 {
94    if (encode_only)
95    {
96       fprintf(stderr, "option %s is only for decoding\n", opt);
97       exit(EXIT_FAILURE);
98    }
99 }
100
101 static void check_encoder_option(int decode_only, const char *opt)
102 {
103    if (decode_only)
104    {
105       fprintf(stderr, "option %s is only for encoding\n", opt);
106       exit(EXIT_FAILURE);
107    }
108 }
109
110 int silk8_test[][4] = {
111       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 1},
112       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 1},
113       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960,   1},
114       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480,   1},
115       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*3, 2},
116       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960*2, 2},
117       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 960,   2},
118       {MODE_SILK_ONLY, OPUS_BANDWIDTH_NARROWBAND, 480,   2}
119 };
120
121 int silk12_test[][4] = {
122       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 1},
123       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 1},
124       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960,   1},
125       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480,   1},
126       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*3, 2},
127       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960*2, 2},
128       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 960,   2},
129       {MODE_SILK_ONLY, OPUS_BANDWIDTH_MEDIUMBAND, 480,   2}
130 };
131
132 int silk16_test[][4] = {
133       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 1},
134       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 1},
135       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960,   1},
136       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480,   1},
137       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*3, 2},
138       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960*2, 2},
139       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 960,   2},
140       {MODE_SILK_ONLY, OPUS_BANDWIDTH_WIDEBAND, 480,   2}
141 };
142
143 int hybrid24_test[][4] = {
144       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1},
145       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1},
146       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2},
147       {MODE_SILK_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2}
148 };
149
150 int hybrid48_test[][4] = {
151       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 1},
152       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 1},
153       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 960, 2},
154       {MODE_SILK_ONLY, OPUS_BANDWIDTH_FULLBAND, 480, 2}
155 };
156
157 int celt_test[][4] = {
158       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 1},
159       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 1},
160       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      960, 1},
161       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    960, 1},
162
163       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 1},
164       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 1},
165       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      480, 1},
166       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    480, 1},
167
168       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 1},
169       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 1},
170       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      240, 1},
171       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    240, 1},
172
173       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 1},
174       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 1},
175       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      120, 1},
176       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    120, 1},
177
178       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 2},
179       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 960, 2},
180       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      960, 2},
181       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    960, 2},
182
183       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 2},
184       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 480, 2},
185       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      480, 2},
186       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    480, 2},
187
188       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 2},
189       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 240, 2},
190       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      240, 2},
191       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    240, 2},
192
193       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 2},
194       {MODE_CELT_ONLY, OPUS_BANDWIDTH_SUPERWIDEBAND, 120, 2},
195       {MODE_CELT_ONLY, OPUS_BANDWIDTH_WIDEBAND,      120, 2},
196       {MODE_CELT_ONLY, OPUS_BANDWIDTH_NARROWBAND,    120, 2},
197
198 };
199
200 int celt_hq_test[][4] = {
201       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      960, 2},
202       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      480, 2},
203       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      240, 2},
204       {MODE_CELT_ONLY, OPUS_BANDWIDTH_FULLBAND,      120, 2},
205 };
206
207 int main(int argc, char *argv[])
208 {
209     int err;
210     char *inFile, *outFile;
211     FILE *fin, *fout;
212     OpusEncoder *enc=NULL;
213     OpusDecoder *dec=NULL;
214     int args;
215     int len[2];
216     int frame_size, channels;
217     opus_int32 bitrate_bps=0;
218     unsigned char *data[2];
219     unsigned char *fbytes;
220     opus_int32 sampling_rate;
221     int use_vbr;
222     int max_payload_bytes;
223     int complexity;
224     int use_inbandfec;
225     int use_dtx;
226     int forcechannels;
227     int cvbr = 0;
228     int packet_loss_perc;
229     opus_int32 count=0, count_act=0;
230     int k;
231     int skip=0;
232     int stop=0;
233     short *in, *out;
234     int application=OPUS_APPLICATION_AUDIO;
235     double bits=0.0, bits_max=0.0, bits_act=0.0, bits2=0.0, nrg;
236     int bandwidth=-1;
237     const char *bandwidth_string;
238     int lost = 0, lost_prev = 1;
239     int toggle = 0;
240     opus_uint32 enc_final_range[2];
241     opus_uint32 dec_final_range;
242     int encode_only=0, decode_only=0;
243     int max_frame_size = 960*6;
244     int curr_read=0;
245     int sweep_bps = 0;
246     int random_framesize=0, newsize=0, delayed_celt=0;
247     int sweep_max=0, sweep_min=0;
248     int random_fec=0;
249     int (*mode_list)[4]=NULL;
250     int nb_modes_in_list=0;
251     int curr_mode=0;
252     int curr_mode_count=0;
253     int mode_switch_time = 48000;
254
255     if (argc < 5 )
256     {
257        print_usage( argv );
258        return EXIT_FAILURE;
259     }
260
261     fprintf(stderr, "%s\n", opus_get_version_string());
262
263     args = 1;
264     if (strcmp(argv[args], "-e")==0)
265     {
266         encode_only = 1;
267         args++;
268     } else if (strcmp(argv[args], "-d")==0)
269     {
270         decode_only = 1;
271         args++;
272     }
273     if (!decode_only && argc < 7 )
274     {
275        print_usage( argv );
276        return EXIT_FAILURE;
277     }
278
279     if (!decode_only)
280     {
281        if (strcmp(argv[args], "voip")==0)
282           application = OPUS_APPLICATION_VOIP;
283        else if (strcmp(argv[args], "restricted-lowdelay")==0)
284           application = OPUS_APPLICATION_RESTRICTED_LOWDELAY;
285        else if (strcmp(argv[args], "audio")!=0) {
286           fprintf(stderr, "unknown application: %s\n", argv[args]);
287           print_usage(argv);
288           return EXIT_FAILURE;
289        }
290        args++;
291     }
292     sampling_rate = (opus_int32)atol(argv[args]);
293     args++;
294     channels = atoi(argv[args]);
295     args++;
296     if (!decode_only)
297     {
298        bitrate_bps = (opus_int32)atol(argv[args]);
299        args++;
300     }
301
302     if (sampling_rate != 8000 && sampling_rate != 12000
303      && sampling_rate != 16000 && sampling_rate != 24000
304      && sampling_rate != 48000)
305     {
306         fprintf(stderr, "Supported sampling rates are 8000, 12000, "
307                 "16000, 24000 and 48000.\n");
308         return EXIT_FAILURE;
309     }
310     frame_size = sampling_rate/50;
311
312     /* defaults: */
313     use_vbr = 1;
314     bandwidth = OPUS_AUTO;
315     max_payload_bytes = MAX_PACKET;
316     complexity = 10;
317     use_inbandfec = 0;
318     forcechannels = OPUS_AUTO;
319     use_dtx = 0;
320     packet_loss_perc = 0;
321     max_frame_size = 960*6;
322     curr_read=0;
323
324     while( args < argc - 2 ) {
325         /* process command line options */
326         if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cbr" ) == 0 ) {
327             check_encoder_option(decode_only, "-cbr");
328             use_vbr = 0;
329             args++;
330         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-bandwidth" ) == 0 ) {
331             check_encoder_option(decode_only, "-bandwidth");
332             if (strcmp(argv[ args + 1 ], "NB")==0)
333                 bandwidth = OPUS_BANDWIDTH_NARROWBAND;
334             else if (strcmp(argv[ args + 1 ], "MB")==0)
335                 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
336             else if (strcmp(argv[ args + 1 ], "WB")==0)
337                 bandwidth = OPUS_BANDWIDTH_WIDEBAND;
338             else if (strcmp(argv[ args + 1 ], "SWB")==0)
339                 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
340             else if (strcmp(argv[ args + 1 ], "FB")==0)
341                 bandwidth = OPUS_BANDWIDTH_FULLBAND;
342             else {
343                 fprintf(stderr, "Unknown bandwidth %s. "
344                                 "Supported are NB, MB, WB, SWB, FB.\n",
345                                 argv[ args + 1 ]);
346                 return EXIT_FAILURE;
347             }
348             args += 2;
349         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-framesize" ) == 0 ) {
350             check_encoder_option(decode_only, "-framesize");
351             if (strcmp(argv[ args + 1 ], "2.5")==0)
352                 frame_size = sampling_rate/400;
353             else if (strcmp(argv[ args + 1 ], "5")==0)
354                 frame_size = sampling_rate/200;
355             else if (strcmp(argv[ args + 1 ], "10")==0)
356                 frame_size = sampling_rate/100;
357             else if (strcmp(argv[ args + 1 ], "20")==0)
358                 frame_size = sampling_rate/50;
359             else if (strcmp(argv[ args + 1 ], "40")==0)
360                 frame_size = sampling_rate/25;
361             else if (strcmp(argv[ args + 1 ], "60")==0)
362                 frame_size = 3*sampling_rate/50;
363             else {
364                 fprintf(stderr, "Unsupported frame size: %s ms. "
365                                 "Supported are 2.5, 5, 10, 20, 40, 60.\n",
366                                 argv[ args + 1 ]);
367                 return EXIT_FAILURE;
368             }
369             args += 2;
370         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-max_payload" ) == 0 ) {
371             check_encoder_option(decode_only, "-max_payload");
372             max_payload_bytes = atoi( argv[ args + 1 ] );
373             args += 2;
374         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) {
375             check_encoder_option(decode_only, "-complexity");
376             complexity = atoi( argv[ args + 1 ] );
377             args += 2;
378         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-inbandfec" ) == 0 ) {
379             use_inbandfec = 1;
380             args++;
381         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-forcemono" ) == 0 ) {
382             check_encoder_option(decode_only, "-forcemono");
383             forcechannels = 1;
384             args++;
385         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cvbr" ) == 0 ) {
386             check_encoder_option(decode_only, "-cvbr");
387             cvbr = 1;
388             args++;
389         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-dtx") == 0 ) {
390             check_encoder_option(decode_only, "-dtx");
391             use_dtx = 1;
392             args++;
393         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-loss" ) == 0 ) {
394             check_decoder_option(encode_only, "-loss");
395             packet_loss_perc = atoi( argv[ args + 1 ] );
396             args += 2;
397         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep" ) == 0 ) {
398             check_encoder_option(decode_only, "-sweep");
399             sweep_bps = atoi( argv[ args + 1 ] );
400             args += 2;
401         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_framesize" ) == 0 ) {
402             check_encoder_option(decode_only, "-random_framesize");
403             random_framesize = 1;
404             args++;
405         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep_max" ) == 0 ) {
406             check_encoder_option(decode_only, "-sweep_max");
407             sweep_max = atoi( argv[ args + 1 ] );
408             args += 2;
409         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_fec" ) == 0 ) {
410             check_encoder_option(decode_only, "-random_fec");
411             random_fec = 1;
412             args++;
413         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk8k_test" ) == 0 ) {
414             check_encoder_option(decode_only, "-silk8k_test");
415             mode_list = silk8_test;
416             nb_modes_in_list = 8;
417             args++;
418         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk12k_test" ) == 0 ) {
419             check_encoder_option(decode_only, "-silk12k_test");
420             mode_list = silk12_test;
421             nb_modes_in_list = 8;
422             args++;
423         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-silk16k_test" ) == 0 ) {
424             check_encoder_option(decode_only, "-silk16k_test");
425             mode_list = silk16_test;
426             nb_modes_in_list = 8;
427             args++;
428         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-hybrid24k_test" ) == 0 ) {
429             check_encoder_option(decode_only, "-hybrid24k_test");
430             mode_list = hybrid24_test;
431             nb_modes_in_list = 4;
432             args++;
433         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-hybrid48k_test" ) == 0 ) {
434             check_encoder_option(decode_only, "-hybrid48k_test");
435             mode_list = hybrid48_test;
436             nb_modes_in_list = 4;
437             args++;
438         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-celt_test" ) == 0 ) {
439             check_encoder_option(decode_only, "-celt_test");
440             mode_list = celt_test;
441             nb_modes_in_list = 32;
442             args++;
443         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-celt_hq_test" ) == 0 ) {
444             check_encoder_option(decode_only, "-celt_hq_test");
445             mode_list = celt_hq_test;
446             nb_modes_in_list = 4;
447             args++;
448         } else {
449             printf( "Error: unrecognized setting: %s\n\n", argv[ args ] );
450             print_usage( argv );
451             return EXIT_FAILURE;
452         }
453     }
454
455     if (sweep_max)
456        sweep_min = bitrate_bps;
457
458     if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET)
459     {
460         fprintf (stderr, "max_payload_bytes must be between 0 and %d\n",
461                           MAX_PACKET);
462         return EXIT_FAILURE;
463     }
464
465     inFile = argv[argc-2];
466     fin = fopen(inFile, "rb");
467     if (!fin)
468     {
469         fprintf (stderr, "Could not open input file %s\n", argv[argc-2]);
470         return EXIT_FAILURE;
471     }
472     if (mode_list)
473     {
474        int size;
475        fseek(fin, 0, SEEK_END);
476        size = ftell(fin);
477        fprintf(stderr, "File size is %d bytes\n", size);
478        fseek(fin, 0, SEEK_SET);
479        mode_switch_time = size/sizeof(short)/channels/nb_modes_in_list;
480        fprintf(stderr, "Switching mode every %d samples\n", mode_switch_time);
481     }
482
483     outFile = argv[argc-1];
484     fout = fopen(outFile, "wb+");
485     if (!fout)
486     {
487         fprintf (stderr, "Could not open output file %s\n", argv[argc-1]);
488         fclose(fin);
489         return EXIT_FAILURE;
490     }
491
492     if (!decode_only)
493     {
494        enc = opus_encoder_create(sampling_rate, channels, application, &err);
495        if (err != OPUS_OK)
496        {
497           fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err));
498           fclose(fin);
499           fclose(fout);
500           return EXIT_FAILURE;
501        }
502        opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
503        opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth));
504        opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr));
505        opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr));
506        opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
507        opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec));
508        opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels));
509        opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx));
510        opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc));
511
512        opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip));
513     }
514     if (!encode_only)
515     {
516        dec = opus_decoder_create(sampling_rate, channels, &err);
517        if (err != OPUS_OK)
518        {
519           fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err));
520           fclose(fin);
521           fclose(fout);
522           return EXIT_FAILURE;
523        }
524     }
525
526
527     switch(bandwidth)
528     {
529     case OPUS_BANDWIDTH_NARROWBAND:
530          bandwidth_string = "narrowband";
531          break;
532     case OPUS_BANDWIDTH_MEDIUMBAND:
533          bandwidth_string = "mediumband";
534          break;
535     case OPUS_BANDWIDTH_WIDEBAND:
536          bandwidth_string = "wideband";
537          break;
538     case OPUS_BANDWIDTH_SUPERWIDEBAND:
539          bandwidth_string = "superwideband";
540          break;
541     case OPUS_BANDWIDTH_FULLBAND:
542          bandwidth_string = "fullband";
543          break;
544     case OPUS_AUTO:
545          bandwidth_string = "auto";
546          break;
547     default:
548          bandwidth_string = "unknown";
549          break;
550     }
551
552     if (decode_only)
553        fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n",
554                        (long)sampling_rate, channels);
555     else
556        fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s "
557                        "in %s mode with %d-sample frames.\n",
558                        (long)sampling_rate, bitrate_bps*0.001,
559                        bandwidth_string, frame_size);
560
561     in = (short*)malloc(max_frame_size*channels*sizeof(short));
562     out = (short*)malloc(max_frame_size*channels*sizeof(short));
563     fbytes = (unsigned char*)malloc(max_frame_size*channels*sizeof(short));
564     data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
565     if ( use_inbandfec ) {
566         data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
567     }
568     while (!stop)
569     {
570         if (delayed_celt)
571         {
572             frame_size = newsize;
573             delayed_celt = 0;
574         } else if (random_framesize && rand()%20==0)
575         {
576             newsize = rand()%6;
577             switch(newsize)
578             {
579             case 0: newsize=sampling_rate/400; break;
580             case 1: newsize=sampling_rate/200; break;
581             case 2: newsize=sampling_rate/100; break;
582             case 3: newsize=sampling_rate/50; break;
583             case 4: newsize=sampling_rate/25; break;
584             case 5: newsize=3*sampling_rate/50; break;
585             }
586             while (newsize < sampling_rate/25 && bitrate_bps-fabs(sweep_bps) <= 3*12*sampling_rate/newsize)
587                newsize*=2;
588             if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100)
589             {
590                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
591                 delayed_celt=1;
592             } else {
593                 frame_size = newsize;
594             }
595         }
596         if (random_fec && rand()%30==0)
597         {
598            opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0));
599         }
600         if (decode_only)
601         {
602             unsigned char ch[4];
603             err = fread(ch, 1, 4, fin);
604             if (feof(fin))
605                 break;
606             len[toggle] = char_to_int(ch);
607             if (len[toggle]>max_payload_bytes || len[toggle]<0)
608             {
609                 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]);
610                 break;
611             }
612             err = fread(ch, 1, 4, fin);
613             enc_final_range[toggle] = char_to_int(ch);
614             err = fread(data[toggle], 1, len[toggle], fin);
615             if (err<len[toggle])
616             {
617                 fprintf(stderr, "Ran out of input, "
618                                 "expecting %d bytes got %d\n",
619                                 len[toggle],err);
620                 break;
621             }
622         } else {
623             int i;
624             if (mode_list!=NULL)
625             {
626                 opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(mode_list[curr_mode][1]));
627                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(mode_list[curr_mode][0]));
628                 opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(mode_list[curr_mode][3]));
629                 frame_size = mode_list[curr_mode][2];
630             }
631             err = fread(fbytes, sizeof(short)*channels, frame_size, fin);
632             curr_read = err;
633             for(i=0;i<curr_read*channels;i++)
634             {
635                 opus_int32 s;
636                 s=fbytes[2*i+1]<<8|fbytes[2*i];
637                 s=((s&0xFFFF)^0x8000)-0x8000;
638                 in[i]=s;
639             }
640             if (curr_read < frame_size)
641             {
642                 for (i=curr_read*channels;i<frame_size*channels;i++)
643                    in[i] = 0;
644                 stop = 1;
645             }
646             len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes);
647             if (sweep_bps!=0)
648             {
649                bitrate_bps += sweep_bps;
650                if (sweep_max)
651                {
652                   if (bitrate_bps > sweep_max)
653                      sweep_bps = -sweep_bps;
654                   else if (bitrate_bps < sweep_min)
655                      sweep_bps = -sweep_bps;
656                }
657                /* safety */
658                if (bitrate_bps<1000)
659                   bitrate_bps = 1000;
660                opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
661             }
662             opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle]));
663             if (len[toggle] < 0)
664             {
665                 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]);
666                 fclose(fin);
667                 fclose(fout);
668                 return EXIT_FAILURE;
669             }
670             curr_mode_count += frame_size;
671             if (curr_mode_count > mode_switch_time && curr_mode < nb_modes_in_list-1)
672             {
673                curr_mode++;
674                curr_mode_count = 0;
675             }
676         }
677
678         if (encode_only)
679         {
680             unsigned char int_field[4];
681             int_to_char(len[toggle], int_field);
682             if (fwrite(int_field, 1, 4, fout) != 4) {
683                fprintf(stderr, "Error writing.\n");
684                return EXIT_FAILURE;
685             }
686             int_to_char(enc_final_range[toggle], int_field);
687             if (fwrite(int_field, 1, 4, fout) != 4) {
688                fprintf(stderr, "Error writing.\n");
689                return EXIT_FAILURE;
690             }
691             if (fwrite(data[toggle], 1, len[toggle], fout) != (unsigned)len[toggle]) {
692                fprintf(stderr, "Error writing.\n");
693                return EXIT_FAILURE;
694             }
695         } else {
696             int output_samples;
697             lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc);
698             if( count >= use_inbandfec ) {
699                 /* delay by one packet when using in-band FEC */
700                 if( use_inbandfec  ) {
701                     if( lost_prev ) {
702                         /* attempt to decode with in-band FEC from next packet */
703                         output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 1);
704                     } else {
705                         /* regular decode */
706                         output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, max_frame_size, 0);
707                     }
708                 } else {
709                     output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 0);
710                 }
711                 if (output_samples>0)
712                 {
713                     if (output_samples>skip) {
714                        int i;
715                        for(i=0;i<(output_samples-skip)*channels;i++)
716                        {
717                           short s;
718                           s=out[i+(skip*channels)];
719                           fbytes[2*i]=s&0xFF;
720                           fbytes[2*i+1]=(s>>8)&0xFF;
721                        }
722                        if (fwrite(fbytes, sizeof(short)*channels, output_samples-skip, fout) != (unsigned)(output_samples-skip)){
723                           fprintf(stderr, "Error writing.\n");
724                           return EXIT_FAILURE;
725                        }
726                     }
727                     if (output_samples<skip) skip -= output_samples;
728                     else skip = 0;
729                 } else {
730                    fprintf(stderr, "error decoding frame: %s\n",
731                                    opus_strerror(output_samples));
732                 }
733             }
734         }
735
736         if (!encode_only)
737            opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
738         /* compare final range encoder rng values of encoder and decoder */
739         if( enc_final_range[toggle^use_inbandfec]!=0  && !encode_only
740          && !lost && !lost_prev
741          && dec_final_range != enc_final_range[toggle^use_inbandfec] ) {
742             fprintf (stderr, "Error: Range coder state mismatch "
743                              "between encoder and decoder "
744                              "in frame %ld: 0x%8lx vs 0x%8lx\n",
745                          (long)count,
746                          (unsigned long)enc_final_range[toggle^use_inbandfec],
747                          (unsigned long)dec_final_range);
748             fclose(fin);
749             fclose(fout);
750             return EXIT_FAILURE;
751         }
752
753         lost_prev = lost;
754
755         /* count bits */
756         bits += len[toggle]*8;
757         bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max;
758         if( count >= use_inbandfec ) {
759             nrg = 0.0;
760             if (!decode_only)
761             {
762                 for ( k = 0; k < frame_size * channels; k++ ) {
763                     nrg += in[ k ] * (double)in[ k ];
764                 }
765             }
766             if ( ( nrg / ( frame_size * channels ) ) > 1e5 ) {
767                 bits_act += len[toggle]*8;
768                 count_act++;
769             }
770             /* Variance */
771             bits2 += len[toggle]*len[toggle]*64;
772         }
773         count++;
774         toggle = (toggle + use_inbandfec) & 1;
775     }
776     fprintf (stderr, "average bitrate:             %7.3f kb/s\n",
777                      1e-3*bits*sampling_rate/(frame_size*(double)count));
778     fprintf (stderr, "maximum bitrate:             %7.3f bkp/s\n",
779                      1e-3*bits_max*sampling_rate/frame_size);
780     if (!decode_only)
781        fprintf (stderr, "active bitrate:              %7.3f kb/s\n",
782                1e-3*bits_act*sampling_rate/(frame_size*(double)count_act));
783     fprintf (stderr, "bitrate standard deviation:  %7.3f kb/s\n",
784             1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size);
785     /* Close any files to which intermediate results were stored */
786     SILK_DEBUG_STORE_CLOSE_FILES
787     silk_TimerSave("opus_timing.txt");
788     opus_encoder_destroy(enc);
789     opus_decoder_destroy(dec);
790     free(data[0]);
791     if (use_inbandfec)
792         free(data[1]);
793     fclose(fin);
794     fclose(fout);
795     free(in);
796     free(out);
797     free(fbytes);
798     return EXIT_SUCCESS;
799 }