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