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