f97648c0d58304c6bcd4898f2f91af38911dcf1a
[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 FOUNDATION OR
20    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
42 #define MAX_PACKET 1500
43
44 void print_usage( char* argv[] )
45 {
46     fprintf(stderr, "Usage: %s [-e] <application> <sampling rate (Hz)> <channels (1/2)> "
47         "<bits per second>  [options] <input> <output>\n", argv[0]);
48     fprintf(stderr, "       %s -d <sampling rate (Hz)> <channels (1/2)> "
49         "[options] <input> <output>\n\n", argv[0]);
50     fprintf(stderr, "mode: voip | audio | restricted-lowdelay\n" );
51     fprintf(stderr, "options:\n" );
52     fprintf(stderr, "-e                   : only runs the encoder (output the bit-stream)\n" );
53     fprintf(stderr, "-d                   : only runs the decoder (reads the bit-stream as input)\n" );
54     fprintf(stderr, "-cbr                 : enable constant bitrate; default: variable bitrate\n" );
55     fprintf(stderr, "-cvbr                : enable constrained variable bitrate; default: unconstrained\n" );
56     fprintf(stderr, "-bandwidth <NB|MB|WB|SWB|FB> : audio bandwidth (from narrowband to fullband); default: sampling rate\n" );
57     fprintf(stderr, "-framesize <2.5|5|10|20|40|60> : frame size in ms; default: 20 \n" );
58     fprintf(stderr, "-max_payload <bytes> : maximum payload size in bytes, default: 1024\n" );
59     fprintf(stderr, "-complexity <comp>   : complexity, 0 (lowest) ... 10 (highest); default: 10\n" );
60     fprintf(stderr, "-inbandfec           : enable SILK inband FEC\n" );
61     fprintf(stderr, "-forcemono           : force mono encoding, even for stereo input\n" );
62     fprintf(stderr, "-dtx                 : enable SILK DTX\n" );
63     fprintf(stderr, "-loss <perc>         : simulate packet loss, in percent (0-100); default: 0\n" );
64 }
65
66 #ifdef _WIN32
67 #   define STR_CASEINSENSITIVE_COMPARE(x, y) _stricmp(x, y)
68 #else
69 #   include <strings.h>
70 #   define STR_CASEINSENSITIVE_COMPARE(x, y) strcasecmp(x, y)
71 #endif
72
73 static void int_to_char(opus_uint32 i, unsigned char ch[4])
74 {
75     ch[0] = i>>24;
76     ch[1] = (i>>16)&0xFF;
77     ch[2] = (i>>8)&0xFF;
78     ch[3] = i&0xFF;
79 }
80
81 static opus_uint32 char_to_int(unsigned char ch[4])
82 {
83     return ((opus_uint32)ch[0]<<24) | ((opus_uint32)ch[1]<<16)
84          | ((opus_uint32)ch[2]<< 8) |  (opus_uint32)ch[3];
85 }
86
87 static void check_decoder_option(int encode_only, const char *opt)
88 {
89    if (encode_only)
90    {
91       fprintf(stderr, "option %s is only for decoding\n", opt);
92       exit(EXIT_FAILURE);
93    }
94 }
95
96 static void check_encoder_option(int decode_only, const char *opt)
97 {
98    if (decode_only)
99    {
100       fprintf(stderr, "option %s is only for encoding\n", opt);
101       exit(EXIT_FAILURE);
102    }
103 }
104
105 int main(int argc, char *argv[])
106 {
107     int err;
108     char *inFile, *outFile;
109     FILE *fin, *fout;
110     OpusEncoder *enc=NULL;
111     OpusDecoder *dec=NULL;
112     int args;
113     int len[2];
114     int frame_size, channels;
115     opus_int32 bitrate_bps=0;
116     unsigned char *data[2];
117     opus_int32 sampling_rate;
118     int use_vbr;
119     int max_payload_bytes;
120     int complexity;
121     int use_inbandfec;
122     int use_dtx;
123     int forcechannels;
124     int cvbr = 0;
125     int packet_loss_perc;
126     opus_int32 count=0, count_act=0;
127     int k;
128     int skip=0;
129     int stop=0;
130     short *in, *out;
131     int application=OPUS_APPLICATION_AUDIO;
132     double bits=0.0, bits_max=0.0, bits_act=0.0, bits2=0.0, nrg;
133     int bandwidth=-1;
134     const char *bandwidth_string;
135     int lost = 0, lost_prev = 1;
136     int toggle = 0;
137     opus_uint32 enc_final_range[2];
138     opus_uint32 dec_final_range;
139     int encode_only=0, decode_only=0;
140     int max_frame_size = 960*6;
141     int curr_read=0;
142     int sweep_bps = 0;
143     int random_framesize=0, newsize=0, delayed_celt=0;
144     int sweep_max=0, sweep_min=0;
145     int random_fec=0;
146
147     if (argc < 5 )
148     {
149        print_usage( argv );
150        return EXIT_FAILURE;
151     }
152
153     fprintf(stderr, "%s\n", opus_get_version_string());
154
155     args = 1;
156     if (strcmp(argv[args], "-e")==0)
157     {
158         encode_only = 1;
159         args++;
160     } else if (strcmp(argv[args], "-d")==0)
161     {
162         decode_only = 1;
163         args++;
164     }
165     if (!decode_only && argc < 7 )
166     {
167        print_usage( argv );
168        return EXIT_FAILURE;
169     }
170
171     if (!decode_only)
172     {
173        if (strcmp(argv[args], "voip")==0)
174           application = OPUS_APPLICATION_VOIP;
175        else if (strcmp(argv[args], "restricted-lowdelay")==0)
176           application = OPUS_APPLICATION_RESTRICTED_LOWDELAY;
177        else if (strcmp(argv[args], "audio")!=0) {
178           fprintf(stderr, "unknown application: %s\n", argv[args]);
179           print_usage(argv);
180           return EXIT_FAILURE;
181        }
182        args++;
183     }
184     sampling_rate = (opus_int32)atol(argv[args]);
185     args++;
186     channels = atoi(argv[args]);
187     args++;
188     if (!decode_only)
189     {
190        bitrate_bps = (opus_int32)atol(argv[args]);
191        args++;
192     }
193
194     if (sampling_rate != 8000 && sampling_rate != 12000
195      && sampling_rate != 16000 && sampling_rate != 24000
196      && sampling_rate != 48000)
197     {
198         fprintf(stderr, "Supported sampling rates are 8000, 12000, "
199                 "16000, 24000 and 48000.\n");
200         return EXIT_FAILURE;
201     }
202     frame_size = sampling_rate/50;
203
204     /* defaults: */
205     use_vbr = 1;
206     bandwidth = OPUS_AUTO;
207     max_payload_bytes = MAX_PACKET;
208     complexity = 10;
209     use_inbandfec = 0;
210     forcechannels = OPUS_AUTO;
211     use_dtx = 0;
212     packet_loss_perc = 0;
213     max_frame_size = 960*6;
214     curr_read=0;
215
216     while( args < argc - 2 ) {
217         /* process command line options */
218         if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cbr" ) == 0 ) {
219             check_encoder_option(decode_only, "-cbr");
220             use_vbr = 0;
221             args++;
222         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-bandwidth" ) == 0 ) {
223             check_encoder_option(decode_only, "-bandwidth");
224             if (strcmp(argv[ args + 1 ], "NB")==0)
225                 bandwidth = OPUS_BANDWIDTH_NARROWBAND;
226             else if (strcmp(argv[ args + 1 ], "MB")==0)
227                 bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
228             else if (strcmp(argv[ args + 1 ], "WB")==0)
229                 bandwidth = OPUS_BANDWIDTH_WIDEBAND;
230             else if (strcmp(argv[ args + 1 ], "SWB")==0)
231                 bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
232             else if (strcmp(argv[ args + 1 ], "FB")==0)
233                 bandwidth = OPUS_BANDWIDTH_FULLBAND;
234             else {
235                 fprintf(stderr, "Unknown bandwidth %s. "
236                                 "Supported are NB, MB, WB, SWB, FB.\n",
237                                 argv[ args + 1 ]);
238                 return EXIT_FAILURE;
239             }
240             args += 2;
241         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-framesize" ) == 0 ) {
242             check_encoder_option(decode_only, "-framesize");
243             if (strcmp(argv[ args + 1 ], "2.5")==0)
244                 frame_size = sampling_rate/400;
245             else if (strcmp(argv[ args + 1 ], "5")==0)
246                 frame_size = sampling_rate/200;
247             else if (strcmp(argv[ args + 1 ], "10")==0)
248                 frame_size = sampling_rate/100;
249             else if (strcmp(argv[ args + 1 ], "20")==0)
250                 frame_size = sampling_rate/50;
251             else if (strcmp(argv[ args + 1 ], "40")==0)
252                 frame_size = sampling_rate/25;
253             else if (strcmp(argv[ args + 1 ], "60")==0)
254                 frame_size = 3*sampling_rate/50;
255             else {
256                 fprintf(stderr, "Unsupported frame size: %s ms. "
257                                 "Supported are 2.5, 5, 10, 20, 40, 60.\n",
258                                 argv[ args + 1 ]);
259                 return EXIT_FAILURE;
260             }
261             args += 2;
262         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-max_payload" ) == 0 ) {
263             check_encoder_option(decode_only, "-max_payload");
264             max_payload_bytes = atoi( argv[ args + 1 ] );
265             args += 2;
266         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) {
267             check_encoder_option(decode_only, "-complexity");
268             complexity = atoi( argv[ args + 1 ] );
269             args += 2;
270         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-inbandfec" ) == 0 ) {
271             use_inbandfec = 1;
272             args++;
273         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-forcemono" ) == 0 ) {
274             check_encoder_option(decode_only, "-forcemono");
275             forcechannels = 1;
276             args++;
277         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-cvbr" ) == 0 ) {
278             check_encoder_option(decode_only, "-cvbr");
279             cvbr = 1;
280             args++;
281         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-dtx") == 0 ) {
282             check_encoder_option(decode_only, "-dtx");
283             use_dtx = 1;
284             args++;
285         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-loss" ) == 0 ) {
286             check_decoder_option(encode_only, "-loss");
287             packet_loss_perc = atoi( argv[ args + 1 ] );
288             args += 2;
289         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep" ) == 0 ) {
290             check_encoder_option(decode_only, "-sweep");
291             sweep_bps = atoi( argv[ args + 1 ] );
292             args += 2;
293         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_framesize" ) == 0 ) {
294             check_encoder_option(decode_only, "-random_framesize");
295             random_framesize = 1;
296             args++;
297         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-sweep_max" ) == 0 ) {
298             check_encoder_option(decode_only, "-sweep_max");
299             sweep_max = atoi( argv[ args + 1 ] );
300             args += 2;
301         } else if( STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-random_fec" ) == 0 ) {
302             check_encoder_option(decode_only, "-random_fec");
303             random_fec = 1;
304             args++;
305         } else {
306             printf( "Error: unrecognized setting: %s\n\n", argv[ args ] );
307             print_usage( argv );
308             return EXIT_FAILURE;
309         }
310     }
311
312     if (sweep_max)
313        sweep_min = bitrate_bps;
314
315     if (max_payload_bytes < 0 || max_payload_bytes > MAX_PACKET)
316     {
317         fprintf (stderr, "max_payload_bytes must be between 0 and %d\n",
318                           MAX_PACKET);
319         return EXIT_FAILURE;
320     }
321
322     inFile = argv[argc-2];
323     fin = fopen(inFile, "rb");
324     if (!fin)
325     {
326         fprintf (stderr, "Could not open input file %s\n", argv[argc-2]);
327         return EXIT_FAILURE;
328     }
329     outFile = argv[argc-1];
330     fout = fopen(outFile, "wb+");
331     if (!fout)
332     {
333         fprintf (stderr, "Could not open output file %s\n", argv[argc-1]);
334         fclose(fin);
335         return EXIT_FAILURE;
336     }
337
338     if (!decode_only)
339     {
340        enc = opus_encoder_create(sampling_rate, channels, application, &err);
341        if (err != OPUS_OK)
342        {
343           fprintf(stderr, "Cannot create encoder: %s\n", opus_strerror(err));
344           fclose(fin);
345           fclose(fout);
346           return EXIT_FAILURE;
347        }
348        opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
349        opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(bandwidth));
350        opus_encoder_ctl(enc, OPUS_SET_VBR(use_vbr));
351        opus_encoder_ctl(enc, OPUS_SET_VBR_CONSTRAINT(cvbr));
352        opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
353        opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(use_inbandfec));
354        opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(forcechannels));
355        opus_encoder_ctl(enc, OPUS_SET_DTX(use_dtx));
356        opus_encoder_ctl(enc, OPUS_SET_PACKET_LOSS_PERC(packet_loss_perc));
357
358        opus_encoder_ctl(enc, OPUS_GET_LOOKAHEAD(&skip));
359     }
360     if (!encode_only)
361     {
362        dec = opus_decoder_create(sampling_rate, channels, &err);
363        if (err != OPUS_OK)
364        {
365           fprintf(stderr, "Cannot create decoder: %s\n", opus_strerror(err));
366           fclose(fin);
367           fclose(fout);
368           return EXIT_FAILURE;
369        }
370     }
371
372
373     switch(bandwidth)
374     {
375     case OPUS_BANDWIDTH_NARROWBAND:
376          bandwidth_string = "narrowband";
377          break;
378     case OPUS_BANDWIDTH_MEDIUMBAND:
379          bandwidth_string = "mediumband";
380          break;
381     case OPUS_BANDWIDTH_WIDEBAND:
382          bandwidth_string = "wideband";
383          break;
384     case OPUS_BANDWIDTH_SUPERWIDEBAND:
385          bandwidth_string = "superwideband";
386          break;
387     case OPUS_BANDWIDTH_FULLBAND:
388          bandwidth_string = "fullband";
389          break;
390     case OPUS_AUTO:
391          bandwidth_string = "auto";
392          break;
393     default:
394          bandwidth_string = "unknown";
395          break;
396     }
397
398     if (decode_only)
399        fprintf(stderr, "Decoding with %ld Hz output (%d channels)\n",
400                        (long)sampling_rate, channels);
401     else
402        fprintf(stderr, "Encoding %ld Hz input at %.3f kb/s "
403                        "in %s mode with %d-sample frames.\n",
404                        (long)sampling_rate, bitrate_bps*0.001,
405                        bandwidth_string, frame_size);
406
407     in = (short*)malloc(max_frame_size*channels*sizeof(short));
408     out = (short*)malloc(max_frame_size*channels*sizeof(short));
409     data[0] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
410     if ( use_inbandfec ) {
411         data[1] = (unsigned char*)calloc(max_payload_bytes,sizeof(char));
412     }
413     while (!stop)
414     {
415         if (delayed_celt)
416         {
417             frame_size = newsize;
418             delayed_celt = 0;
419         } else if (random_framesize && rand()%20==0)
420         {
421             newsize = rand()%6;
422             switch(newsize)
423             {
424             case 0: newsize=sampling_rate/400; break;
425             case 1: newsize=sampling_rate/200; break;
426             case 2: newsize=sampling_rate/100; break;
427             case 3: newsize=sampling_rate/50; break;
428             case 4: newsize=sampling_rate/25; break;
429             case 5: newsize=3*sampling_rate/50; break;
430             }
431             if (newsize < sampling_rate/100 && frame_size >= sampling_rate/100)
432             {
433                 opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
434                 delayed_celt=1;
435             } else {
436                 frame_size = newsize;
437             }
438         }
439         if (random_fec && rand()%30==0)
440         {
441            opus_encoder_ctl(enc, OPUS_SET_INBAND_FEC(rand()%4==0));
442         }
443         if (decode_only)
444         {
445             unsigned char ch[4];
446             err = fread(ch, 1, 4, fin);
447             if (feof(fin))
448                 break;
449             len[toggle] = char_to_int(ch);
450             if (len[toggle]>max_payload_bytes || len[toggle]<0)
451             {
452                 fprintf(stderr, "Invalid payload length: %d\n",len[toggle]);
453                 break;
454             }
455             err = fread(ch, 1, 4, fin);
456             enc_final_range[toggle] = char_to_int(ch);
457             err = fread(data[toggle], 1, len[toggle], fin);
458             if (err<len[toggle])
459             {
460                 fprintf(stderr, "Ran out of input, "
461                                 "expecting %d bytes got %d\n",
462                                 len[toggle],err);
463                 break;
464             }
465         } else {
466             err = fread(in, sizeof(short)*channels, frame_size, fin);
467             curr_read = err;
468             if (curr_read < frame_size)
469             {
470                 int i;
471                 for (i=curr_read*channels;i<frame_size*channels;i++)
472                    in[i] = 0;
473                 stop = 1;
474             }
475
476             len[toggle] = opus_encode(enc, in, frame_size, data[toggle], max_payload_bytes);
477             if (sweep_bps!=0)
478             {
479                bitrate_bps += sweep_bps;
480                if (sweep_max)
481                {
482                   if (bitrate_bps > sweep_max)
483                      sweep_bps = -sweep_bps;
484                   else if (bitrate_bps < sweep_min)
485                      sweep_bps = -sweep_bps;
486                }
487                /* safety */
488                if (bitrate_bps<1000)
489                   bitrate_bps = 1000;
490                opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate_bps));
491             }
492             opus_encoder_ctl(enc, OPUS_GET_FINAL_RANGE(&enc_final_range[toggle]));
493             if (len[toggle] < 0)
494             {
495                 fprintf (stderr, "opus_encode() returned %d\n", len[toggle]);
496                 fclose(fin);
497                 fclose(fout);
498                 return EXIT_FAILURE;
499             }
500         }
501
502         if (encode_only)
503         {
504             unsigned char int_field[4];
505             int_to_char(len[toggle], int_field);
506             fwrite(int_field, 1, 4, fout);
507             int_to_char(enc_final_range[toggle], int_field);
508             fwrite(int_field, 1, 4, fout);
509             fwrite(data[toggle], 1, len[toggle], fout);
510         } else {
511             int output_samples;
512             lost = len[toggle]==0 || (packet_loss_perc>0 && rand()%100 < packet_loss_perc);
513             if( count >= use_inbandfec ) {
514                 /* delay by one packet when using in-band FEC */
515                 if( use_inbandfec  ) {
516                     if( lost_prev ) {
517                         /* attempt to decode with in-band FEC from next packet */
518                         output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 1);
519                     } else {
520                         /* regular decode */
521                         output_samples = opus_decode(dec, data[1-toggle], len[1-toggle], out, max_frame_size, 0);
522                     }
523                 } else {
524                     output_samples = opus_decode(dec, lost ? NULL : data[toggle], len[toggle], out, max_frame_size, 0);
525                 }
526                 if (output_samples>0)
527                 {
528                     fwrite(out+skip*channels, sizeof(short)*channels, output_samples-skip, fout);
529                     skip = 0;
530                 } else {
531                    fprintf(stderr, "error decoding frame: %s\n",
532                                    opus_strerror(output_samples));
533                 }
534             }
535         }
536
537         if (!encode_only)
538            opus_decoder_ctl(dec, OPUS_GET_FINAL_RANGE(&dec_final_range));
539         /* compare final range encoder rng values of encoder and decoder */
540         if( enc_final_range[toggle^use_inbandfec]!=0  && !encode_only
541          && !lost && !lost_prev
542          && dec_final_range != enc_final_range[toggle^use_inbandfec] ) {
543             fprintf (stderr, "Error: Range coder state mismatch "
544                              "between encoder and decoder "
545                              "in frame %ld: 0x%8lx vs 0x%8lx\n",
546                          (long)count,
547                          (unsigned long)enc_final_range[toggle^use_inbandfec],
548                          (unsigned long)dec_final_range);
549             fclose(fin);
550             fclose(fout);
551             return EXIT_FAILURE;
552         }
553
554         lost_prev = lost;
555
556         /* count bits */
557         bits += len[toggle]*8;
558         bits_max = ( len[toggle]*8 > bits_max ) ? len[toggle]*8 : bits_max;
559         if( count >= use_inbandfec ) {
560             nrg = 0.0;
561             if (!decode_only)
562             {
563                 for ( k = 0; k < frame_size * channels; k++ ) {
564                     nrg += in[ k ] * (double)in[ k ];
565                 }
566             }
567             if ( ( nrg / ( frame_size * channels ) ) > 1e5 ) {
568                 bits_act += len[toggle]*8;
569                 count_act++;
570             }
571             /* Variance */
572             bits2 += len[toggle]*len[toggle]*64;
573         }
574         count++;
575         toggle = (toggle + use_inbandfec) & 1;
576     }
577     fprintf (stderr, "average bitrate:             %7.3f kb/s\n",
578                      1e-3*bits*sampling_rate/(frame_size*(double)count));
579     fprintf (stderr, "maximum bitrate:             %7.3f bkp/s\n",
580                      1e-3*bits_max*sampling_rate/frame_size);
581     if (!decode_only)
582        fprintf (stderr, "active bitrate:              %7.3f kb/s\n",
583                1e-3*bits_act*sampling_rate/(frame_size*(double)count_act));
584     fprintf (stderr, "bitrate standard deviation:  %7.3f kb/s\n",
585             1e-3*sqrt(bits2/count - bits*bits/(count*(double)count))*sampling_rate/frame_size);
586     /* Close any files to which intermediate results were stored */
587     SILK_DEBUG_STORE_CLOSE_FILES
588     silk_TimerSave("opus_timing.txt");
589     opus_encoder_destroy(enc);
590     opus_decoder_destroy(dec);
591     free(data[0]);
592     if (use_inbandfec)
593         free(data[1]);
594     fclose(fin);
595     fclose(fout);
596     free(in);
597     free(out);
598     return EXIT_SUCCESS;
599 }