f8c83d1ef5c518790a249b8bed2d0d0439b8fb5d
[opus.git] / src / opus_encoder.c
1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
19    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdarg.h>
33 #include "celt.h"
34 #include "entenc.h"
35 #include "modes.h"
36 #include "silk_API.h"
37 #include "stack_alloc.h"
38 #include "float_cast.h"
39 #include "opus.h"
40 #include "arch.h"
41 #include "opus_private.h"
42 #include "os_support.h"
43
44 #include "silk_tuning_parameters.h"
45 #ifdef FIXED_POINT
46 #include "fixed/silk_structs_FIX.h"
47 #else
48 #include "float/silk_structs_FLP.h"
49 #endif
50
51 #define MAX_ENCODER_BUFFER 480
52
53 struct OpusEncoder {
54     int          celt_enc_offset;
55     int          silk_enc_offset;
56     silk_EncControlStruct silk_mode;
57     int          application;
58     int          channels;
59     int          delay_compensation;
60     int          force_mono;
61     int          signal_type;
62     int          user_bandwidth;
63     int          voice_ratio;
64     int          Fs;
65     int          use_vbr;
66     int          vbr_constraint;
67     int          bitrate_bps;
68     int          user_bitrate_bps;
69     int          encoder_buffer;
70
71 #define OPUS_ENCODER_RESET_START stream_channels
72     int          stream_channels;
73     int          hybrid_stereo_width_Q14;
74     opus_int32   variable_HP_smth2_Q15;
75     opus_val32   hp_mem[4];
76     int          mode;
77     int          prev_mode;
78     int          bandwidth;
79     /* Sampling rate (at the API level) */
80     int          first;
81     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
82
83     int          rangeFinal;
84 };
85
86 /* Transition tables for the voice and audio modes. First column is the
87    middle (memoriless) threshold. The second column is the hysteresis
88    (difference with the middle) */
89 static const int voice_bandwidth_thresholds[10] = {
90         11000, 1000, /* NB<->MB */
91         14000, 1000, /* MB<->WB */
92         21000, 2000, /* WB<->SWB */
93         29000, 2000, /* SWB<->FB */
94 };
95 static const int audio_bandwidth_thresholds[10] = {
96         30000,    0, /* MB not allowed */
97         20000, 2000, /* MB<->WB */
98         26000, 2000, /* WB<->SWB */
99         33000, 2000, /* SWB<->FB */
100 };
101
102
103 int opus_encoder_get_size(int channels)
104 {
105     int silkEncSizeBytes, celtEncSizeBytes;
106     int ret;
107     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
108     if (ret)
109         return 0;
110     silkEncSizeBytes = align(silkEncSizeBytes);
111     celtEncSizeBytes = celt_encoder_get_size(channels);
112     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
113 }
114
115 int opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
116 {
117     void *silk_enc;
118     CELTEncoder *celt_enc;
119     int err;
120     int ret, silkEncSizeBytes;
121
122     if (channels > 2 || channels < 1)
123         return OPUS_BAD_ARG;
124     if (application < OPUS_APPLICATION_VOIP || application > OPUS_APPLICATION_AUDIO)
125         return OPUS_BAD_ARG;
126     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
127         return OPUS_BAD_ARG;
128
129     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
130     /* Create SILK encoder */
131     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
132     if (ret)
133         return OPUS_BAD_ARG;
134     silkEncSizeBytes = align(silkEncSizeBytes);
135     st->silk_enc_offset = align(sizeof(OpusEncoder));
136     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
137     silk_enc = (char*)st+st->silk_enc_offset;
138     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
139
140     st->stream_channels = st->channels = channels;
141
142     st->Fs = Fs;
143
144     ret = silk_InitEncoder( silk_enc, &st->silk_mode );
145     if (ret)
146         goto failure;
147
148     /* default SILK parameters */
149     st->silk_mode.nChannelsAPI              = channels;
150     st->silk_mode.nChannelsInternal         = channels;
151     st->silk_mode.API_sampleRate            = st->Fs;
152     st->silk_mode.maxInternalSampleRate     = 16000;
153     st->silk_mode.minInternalSampleRate     = 8000;
154     st->silk_mode.desiredInternalSampleRate = 16000;
155     st->silk_mode.payloadSize_ms            = 20;
156     st->silk_mode.bitRate                   = 25000;
157     st->silk_mode.packetLossPercentage      = 0;
158     st->silk_mode.complexity                = 10;
159     st->silk_mode.useInBandFEC              = 0;
160     st->silk_mode.useDTX                    = 0;
161     st->silk_mode.useCBR                    = 0;
162     st->silk_mode.HP_cutoff_Hz              = 0;
163
164     /* Create CELT encoder */
165     /* Initialize CELT encoder */
166     err = celt_encoder_init(celt_enc, Fs, channels);
167     if (err != OPUS_OK)
168         goto failure;
169     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
170
171     st->use_vbr = 0;
172     st->user_bitrate_bps = OPUS_BITRATE_AUTO;
173     st->bitrate_bps = 3000+Fs*channels;
174     st->application = application;
175     st->signal_type = OPUS_SIGNAL_AUTO;
176     st->user_bandwidth = OPUS_BANDWIDTH_AUTO;
177     st->voice_ratio = 90;
178     st->encoder_buffer = st->Fs/100;
179
180     st->delay_compensation = st->Fs/400;
181     /* This part is meant to compensate for the resampler delay as a function
182        of the API sampling rate */
183     if (st->Fs == 48000)
184         st->delay_compensation += 23;
185     else if (st->Fs == 24000)
186        st->delay_compensation += 15;
187     else
188        st->delay_compensation += 2;
189
190     st->hybrid_stereo_width_Q14             = 1 << 14;
191     st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
192     st->first = 1;
193     st->mode = MODE_HYBRID;
194     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
195
196     return OPUS_OK;
197
198 failure:
199     opus_free(st);
200     return OPUS_INTERNAL_ERROR;
201 }
202
203 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int silk_bandwidth, int channels)
204 {
205    int period;
206    unsigned char toc;
207    period = 0;
208    while (framerate < 400)
209    {
210        framerate <<= 1;
211        period++;
212    }
213    if (mode == MODE_SILK_ONLY)
214    {
215        toc = (silk_bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
216        toc |= (period-2)<<3;
217    } else if (mode == MODE_CELT_ONLY)
218    {
219        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
220        if (tmp < 0)
221            tmp = 0;
222        toc = 0x80;
223        toc |= tmp << 5;
224        toc |= period<<3;
225    } else /* Hybrid */
226    {
227        toc = 0x60;
228        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
229        toc |= (period-2)<<3;
230    }
231    toc |= (channels==2)<<2;
232    return toc;
233 }
234
235 #ifndef FIXED_POINT
236 void silk_biquad_float(
237     const opus_val16      *in,            /* I:    Input signal                   */
238     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
239     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
240     opus_val32            *S,             /* I/O:  State vector [2]               */
241     opus_val16            *out,           /* O:    Output signal                  */
242     const opus_int32      len,            /* I:    Signal length (must be even)   */
243     int stride
244 )
245 {
246     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
247     opus_int   k;
248     opus_val32 vout;
249     opus_val32 inval;
250     opus_val32 A[2], B[3];
251
252     A[0] = A_Q28[0] * (1./((opus_int32)1<<28));
253     A[1] = A_Q28[1] * (1./((opus_int32)1<<28));
254     B[0] = B_Q28[0] * (1./((opus_int32)1<<28));
255     B[1] = B_Q28[1] * (1./((opus_int32)1<<28));
256     B[2] = B_Q28[2] * (1./((opus_int32)1<<28));
257
258     /* Negate A_Q28 values and split in two parts */
259
260     for( k = 0; k < len; k++ ) {
261         /* S[ 0 ], S[ 1 ]: Q12 */
262         inval = in[ k*stride ];
263         vout = S[ 0 ] + B[0]*inval;
264
265         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
266
267         S[ 1 ] = - vout*A[1] + B[2]*inval;
268
269         /* Scale back to Q0 and saturate */
270         out[ k*stride ] = vout;
271     }
272 }
273 #endif
274
275 static void hp_cutoff(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
276 {
277    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
278    opus_int32 Fc_Q19, r_Q28, r_Q22;
279
280    SKP_assert( cutoff_Hz <= SKP_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
281    Fc_Q19 = SKP_DIV32_16( SKP_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
282    SKP_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
283
284    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - SKP_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
285
286    /* b = r * [ 1; -2; 1 ]; */
287    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
288    B_Q28[ 0 ] = r_Q28;
289    B_Q28[ 1 ] = SKP_LSHIFT( -r_Q28, 1 );
290    B_Q28[ 2 ] = r_Q28;
291
292    /* -r * ( 2 - Fc * Fc ); */
293    r_Q22  = SKP_RSHIFT( r_Q28, 6 );
294    A_Q28[ 0 ] = SKP_SMULWW( r_Q22, SKP_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
295    A_Q28[ 1 ] = SKP_SMULWW( r_Q22, r_Q22 );
296
297 #ifdef FIXED_POINT
298    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
299    if( channels == 2 ) {
300        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
301    }
302 #else
303    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
304    if( channels == 2 ) {
305        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
306    }
307 #endif
308 }
309
310 OpusEncoder *opus_encoder_create(int Fs, int channels, int mode, int *error)
311 {
312    int ret;
313    OpusEncoder *st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
314    if (st == NULL)
315    {
316       if (error)
317          *error = OPUS_ALLOC_FAIL;
318       return NULL;
319    }
320    ret = opus_encoder_init(st, Fs, channels, mode);
321    if (error)
322       *error = ret;
323    if (ret != OPUS_OK)
324    {
325       opus_free(st);
326       st = NULL;
327    }
328    return st;
329 }
330 #ifdef FIXED_POINT
331 int opus_encode(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
332                 unsigned char *data, int max_data_bytes)
333 #else
334 int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
335                       unsigned char *data, int max_data_bytes)
336 #endif
337 {
338     void *silk_enc;
339     CELTEncoder *celt_enc;
340     int i;
341     int ret=0;
342     int nBytes;
343     ec_enc enc;
344     int silk_internal_bandwidth=-1;
345     int bytes_target;
346     int prefill=0;
347     int start_band = 0;
348     int redundancy = 0;
349     int redundancy_bytes = 0;
350     int celt_to_silk = 0;
351     VARDECL(opus_val16, pcm_buf);
352     int nb_compr_bytes;
353     int to_celt = 0;
354     opus_int32 mono_rate;
355     opus_uint32 redundant_rng = 0;
356     int cutoff_Hz, hp_freq_smth1;
357     ALLOC_STACK;
358
359     st->rangeFinal = 0;
360     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
361          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
362     {
363        RESTORE_STACK;
364        return OPUS_BAD_ARG;
365     }
366     silk_enc = (char*)st+st->silk_enc_offset;
367     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
368
369     if (st->user_bitrate_bps==OPUS_BITRATE_AUTO)
370         st->bitrate_bps = 60*st->Fs/frame_size + st->Fs*st->channels;
371     else
372         st->bitrate_bps = st->user_bitrate_bps;
373
374     /* Rate-dependent mono-stereo decision */
375     if (st->force_mono)
376     {
377         st->stream_channels = 1;
378     } else if (st->mode == MODE_CELT_ONLY && st->channels == 2)
379     {
380         opus_int32 decision_rate;
381         decision_rate = st->bitrate_bps + st->voice_ratio*st->voice_ratio;
382         /* Add some hysteresis */
383         if (st->stream_channels == 2)
384             decision_rate += 4000;
385         else
386             decision_rate -= 4000;
387         if (decision_rate>48000)
388             st->stream_channels = 2;
389         else
390             st->stream_channels = 1;
391     } else {
392             st->stream_channels = st->channels;
393     }
394
395 #ifdef FUZZING
396     if (st->channels == 2 && (rand()&0x1F)==0)
397        st->stream_channels = 3-st->stream_channels;
398 #endif
399
400     /* Equivalent bit-rate for mono */
401     mono_rate = st->bitrate_bps;
402     if (st->stream_channels==2)
403         mono_rate = 2*mono_rate/3;
404     /* Compensate for smaller frame sizes assuming an equivalent overhead
405        of 60 bits/frame */
406     mono_rate -= 60*(st->Fs/frame_size - 50);
407
408 #ifdef FUZZING
409     if ((rand()&0xF)==0)
410     {
411        if ((rand()&0x1)==0)
412           st->mode = MODE_CELT_ONLY;
413        else
414           st->mode = MODE_SILK_ONLY;
415     } else {
416        if (st->prev_mode==MODE_CELT_ONLY)
417           st->mode = MODE_CELT_ONLY;
418        else
419           st->mode = MODE_SILK_ONLY;
420     }
421 #else
422     /* Mode selection depending on application and signal type */
423     if (st->application==OPUS_APPLICATION_VOIP)
424     {
425         opus_int32 threshold;
426         threshold = 20000;
427         /* OPUS_APPLICATION_VOIP default to auto high-pass */
428         st->silk_mode.HP_cutoff_Hz=0;
429         /* Hysteresis */
430         if (st->prev_mode == MODE_CELT_ONLY)
431             threshold -= 4000;
432         else if (st->prev_mode>0)
433             threshold += 4000;
434
435         /* OPUS_APPLICATION_VOIP defaults to MODE_SILK_ONLY */
436         if (st->signal_type == OPUS_SIGNAL_MUSIC && mono_rate > threshold)
437             st->mode = MODE_CELT_ONLY;
438         else
439             st->mode = MODE_SILK_ONLY;
440     } else {/* OPUS_APPLICATION_AUDIO */
441         opus_int32 threshold;
442         /* SILK/CELT threshold is higher for voice than for music */
443         threshold = 36000;
444         /* OPUS_APPLICATION_AUDIO disables the high-pass */
445         st->silk_mode.HP_cutoff_Hz=-1;
446         if (st->signal_type == OPUS_SIGNAL_MUSIC)
447             threshold -= 20000;
448         else if (st->signal_type == OPUS_SIGNAL_VOICE)
449             threshold += 8000;
450
451         /* Hysteresis */
452         if (st->prev_mode == MODE_CELT_ONLY)
453             threshold -= 4000;
454         else if (st->prev_mode>0)
455             threshold += 4000;
456
457         if (mono_rate>threshold)
458             st->mode = MODE_CELT_ONLY;
459         else
460             st->mode = MODE_SILK_ONLY;
461     }
462 #endif
463     /* Override the chosen mode to make sure we meet the requested frame size */
464     if (st->mode == MODE_CELT_ONLY && frame_size > st->Fs/50)
465        st->mode = MODE_SILK_ONLY;
466     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
467        st->mode = MODE_CELT_ONLY;
468
469     if (st->prev_mode > 0 &&
470         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
471     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
472     {
473         redundancy = 1;
474         celt_to_silk = (st->mode != MODE_CELT_ONLY);
475         if (!celt_to_silk)
476         {
477             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
478             if (frame_size >= st->Fs/100)
479             {
480                 st->mode = st->prev_mode;
481                 to_celt = 1;
482             } else {
483                 redundancy=0;
484             }
485         }
486     }
487     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
488     {
489         silk_EncControlStruct dummy;
490         silk_InitEncoder( silk_enc, &dummy);
491         prefill=1;
492     }
493
494     /* Automatic (rate-dependent) bandwidth selection */
495     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
496     {
497         const int *bandwidth_thresholds;
498         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
499
500         bandwidth_thresholds = st->mode == MODE_CELT_ONLY ? audio_bandwidth_thresholds : voice_bandwidth_thresholds;
501         do {
502             int threshold, hysteresis;
503             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
504             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
505             if (!st->first)
506             {
507                 if (st->bandwidth >= bandwidth)
508                     threshold -= hysteresis;
509                 else
510                     threshold += hysteresis;
511             }
512             if (mono_rate >= threshold)
513                 break;
514         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
515         st->bandwidth = bandwidth;
516         /* Prevents any transition to SWB/FB until the SILK layer has fully
517            switched to WB mode and turned the variable LP filter off */
518         if (st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
519             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
520     }
521
522     /* Prevents Opus from wasting bits on frequencies that are above
523        the Nyquist rate of the input signal */
524     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
525         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
526     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
527         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
528     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
529         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
530     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
531         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
532
533     if (st->user_bandwidth != OPUS_BANDWIDTH_AUTO)
534         st->bandwidth = st->user_bandwidth;
535
536     /* Can't support higher than wideband for >20 ms frames */
537     if (frame_size > st->Fs/50 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
538        st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
539
540     /* CELT mode doesn't support mediumband, use wideband instead */
541     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
542         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
543
544     /* Chooses the appropriate mode for speech
545        *NEVER* switch to/from CELT-only mode here as this will */
546     if (st->mode == MODE_SILK_ONLY && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
547         st->mode = MODE_HYBRID;
548     if (st->mode == MODE_HYBRID && st->bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
549         st->mode = MODE_SILK_ONLY;
550
551     bytes_target = st->bitrate_bps * frame_size / (st->Fs * 8) - 1;
552
553     data += 1;
554
555     ec_enc_init(&enc, data, max_data_bytes-1);
556
557     ALLOC(pcm_buf, (st->delay_compensation+frame_size)*st->channels, opus_val16);
558     for (i=0;i<st->delay_compensation*st->channels;i++)
559        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-st->delay_compensation)*st->channels+i];
560
561     if (st->mode == MODE_CELT_ONLY)
562        hp_freq_smth1 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
563     else
564        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
565
566     st->variable_HP_smth2_Q15 = SKP_SMLAWB( st->variable_HP_smth2_Q15,
567           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
568
569     /* convert from log scale to Hertz */
570     cutoff_Hz = silk_log2lin( SKP_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
571
572     if (st->application == OPUS_APPLICATION_VOIP)
573     {
574        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[st->delay_compensation*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
575     } else {
576        for (i=0;i<frame_size*st->channels;i++)
577           pcm_buf[st->delay_compensation*st->channels + i] = pcm[i];
578     }
579
580     /* SILK processing */
581     if (st->mode != MODE_CELT_ONLY)
582     {
583 #ifdef FIXED_POINT
584        const opus_int16 *pcm_silk;
585 #else
586        VARDECL(opus_int16, pcm_silk);
587        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
588 #endif
589         st->silk_mode.bitRate = st->bitrate_bps - 8*st->Fs/frame_size;
590         if( st->mode == MODE_HYBRID ) {
591             st->silk_mode.bitRate /= st->stream_channels;
592             if( st->bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND ) {
593                 if( st->Fs == 100 * frame_size ) {
594                     /* 24 kHz, 10 ms */
595                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 2000 + st->use_vbr * 1000 ) * 2 ) / 3;
596                 } else {
597                     /* 24 kHz, 20 ms */
598                     st->silk_mode.bitRate = ( ( st->silk_mode.bitRate + 1000 + st->use_vbr * 1000 ) * 2 ) / 3;
599                 }
600             } else {
601                 if( st->Fs == 100 * frame_size ) {
602                     /* 48 kHz, 10 ms */
603                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 8000 + st->use_vbr * 3000 ) / 2;
604                 } else {
605                     /* 48 kHz, 20 ms */
606                     st->silk_mode.bitRate = ( st->silk_mode.bitRate + 9000 + st->use_vbr * 1000 ) / 2;
607                 }
608             }
609             st->silk_mode.bitRate *= st->stream_channels;
610             /* don't let SILK use more than 80% */
611             if( st->silk_mode.bitRate > ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5 ) {
612                 st->silk_mode.bitRate = ( st->bitrate_bps - 8*st->Fs/frame_size ) * 4/5;
613             }
614         }
615
616         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
617         st->silk_mode.nChannelsAPI = st->channels;
618         st->silk_mode.nChannelsInternal = st->stream_channels;
619         if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
620             st->silk_mode.desiredInternalSampleRate = 8000;
621         } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
622             st->silk_mode.desiredInternalSampleRate = 12000;
623         } else {
624             SKP_assert( st->mode == MODE_HYBRID || st->bandwidth == OPUS_BANDWIDTH_WIDEBAND );
625             st->silk_mode.desiredInternalSampleRate = 16000;
626         }
627         if( st->mode == MODE_HYBRID ) {
628             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
629             st->silk_mode.minInternalSampleRate = 16000;
630         } else {
631             st->silk_mode.minInternalSampleRate = 8000;
632         }
633         st->silk_mode.maxInternalSampleRate = 16000;
634
635         /* Call SILK encoder for the low band */
636         nBytes = IMIN(1275, max_data_bytes-1);
637         if (prefill)
638         {
639             int zero=0;
640 #ifdef FIXED_POINT
641             pcm_silk = st->delay_buffer;
642 #else
643             for (i=0;i<st->encoder_buffer*st->channels;i++)
644                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
645 #endif
646             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
647         }
648
649 #ifdef FIXED_POINT
650         pcm_silk = pcm_buf+st->delay_compensation*st->channels;
651 #else
652         for (i=0;i<frame_size*st->channels;i++)
653             pcm_silk[i] = FLOAT2INT16(pcm_buf[st->delay_compensation*st->channels + i]);
654 #endif
655         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
656         if( ret ) {
657             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
658             /* Handle error */
659            return OPUS_INTERNAL_ERROR;
660         }
661         if (nBytes==0)
662         {
663            data[-1] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
664            RESTORE_STACK;
665            return 1;
666         }
667         /* Extract SILK internal bandwidth for signaling in first byte */
668         if( st->mode == MODE_SILK_ONLY ) {
669             if( st->silk_mode.internalSampleRate == 8000 ) {
670                 silk_internal_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
671             } else if( st->silk_mode.internalSampleRate == 12000 ) {
672                 silk_internal_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
673             } else if( st->silk_mode.internalSampleRate == 16000 ) {
674                 silk_internal_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
675             }
676         } else {
677             SKP_assert( st->silk_mode.internalSampleRate == 16000 );
678         }
679     }
680
681     /* CELT processing */
682     {
683         int endband=21;
684
685         switch(st->bandwidth)
686         {
687             case OPUS_BANDWIDTH_NARROWBAND:
688                 endband = 13;
689                 break;
690             case OPUS_BANDWIDTH_MEDIUMBAND:
691             case OPUS_BANDWIDTH_WIDEBAND:
692                 endband = 17;
693                 break;
694             case OPUS_BANDWIDTH_SUPERWIDEBAND:
695                 endband = 19;
696                 break;
697             case OPUS_BANDWIDTH_FULLBAND:
698                 endband = 21;
699                 break;
700         }
701         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
702         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
703     }
704     if (st->mode != MODE_SILK_ONLY)
705     {
706         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
707         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(-1));
708         if (st->prev_mode == MODE_SILK_ONLY)
709         {
710             unsigned char dummy[10];
711             celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
712             celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
713             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
714             /* TODO: This wastes CPU a bit compared to just prefilling the buffer */
715             celt_encode_with_ec(celt_enc, &st->delay_buffer[(st->encoder_buffer-st->delay_compensation-st->Fs/400)*st->channels], st->Fs/400, dummy, 10, NULL);
716         } else {
717             celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(2));
718         }
719
720         if (st->mode == MODE_HYBRID)
721         {
722             int len;
723
724             len = (ec_tell(&enc)+7)>>3;
725             if( st->use_vbr ) {
726                 nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
727             } else {
728                 /* check if SILK used up too much */
729                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
730             }
731         } else {
732             if (st->use_vbr)
733             {
734                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
735                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
736                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
737                 nb_compr_bytes = max_data_bytes-1;
738             } else {
739                 nb_compr_bytes = bytes_target;
740             }
741         }
742
743     } else {
744         nb_compr_bytes = 0;
745     }
746
747     for (i=0;i<st->encoder_buffer*st->channels;i++)
748         st->delay_buffer[i] = pcm_buf[(frame_size+st->delay_compensation-st->encoder_buffer)*st->channels+i];
749
750
751     if( st->mode == MODE_HYBRID && st->stream_channels == 2 ) {
752         /* Apply stereo width reduction (at low bitrates) */
753         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
754             int width_Q14, delta_Q14, nSamples_8ms, diff;
755             nSamples_8ms = ( st->Fs * 8 ) / 1000;
756             width_Q14 = (1 << 14 ) - st->hybrid_stereo_width_Q14;
757             delta_Q14 = ( st->hybrid_stereo_width_Q14 - st->silk_mode.stereoWidth_Q14 ) / nSamples_8ms;
758             for( i = 0; i < nSamples_8ms; i++ ) {
759                 width_Q14 += delta_Q14;
760                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
761                 diff = ( diff * width_Q14 ) >> 15;
762                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
763                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
764             }
765             for( ; i < frame_size; i++ ) {
766                 diff = pcm_buf[ 2*i+1 ] - (opus_int32)pcm_buf[ 2*i ];
767                 diff = ( diff * width_Q14 ) >> 15;
768                 pcm_buf[ 2*i ]   = (opus_int16)( pcm_buf[ 2*i ]   + diff );
769                 pcm_buf[ 2*i+1 ] = (opus_int16)( pcm_buf[ 2*i+1 ] - diff );
770             }
771             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
772         }
773     }
774
775     if (st->mode != MODE_CELT_ONLY)
776     {
777         /* Check if we have a redundant 0-8 kHz band */
778         ec_enc_bit_logp(&enc, redundancy, 12);
779         if (redundancy)
780         {
781             /* Target the same bit-rate for redundancy as for the rest,
782                up to a max of 257 bytes */
783             redundancy_bytes = IMIN(257, st->bitrate_bps/1600);
784             ec_enc_bit_logp(&enc, celt_to_silk, 1);
785             if (st->mode == MODE_HYBRID)
786                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
787         }
788         start_band = 17;
789     }
790
791     if (st->mode == MODE_SILK_ONLY)
792     {
793         ret = (ec_tell(&enc)+7)>>3;
794         ec_enc_done(&enc);
795         /*When in LPC only mode it's perfectly
796           reasonable to strip off trailing zero bytes as
797           the required range decoder behavior is to
798           fill these in. This can't be done when the MDCT
799           modes are used because the decoder needs to know
800           the actual length for allocation purposes.*/
801         if(!redundancy)
802             while(ret>2&&data[ret-1]==0)ret--;
803         nb_compr_bytes = ret;
804     } else {
805        nb_compr_bytes = IMIN(1275-redundancy_bytes, nb_compr_bytes);
806        ec_enc_shrink(&enc, nb_compr_bytes);
807     }
808
809
810     /* 5 ms redundant frame for CELT->SILK */
811     if (redundancy && celt_to_silk)
812     {
813         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
814         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
815         celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
816         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
817         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
818     }
819
820     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
821
822     if (st->mode != MODE_SILK_ONLY)
823     {
824         ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
825     }
826
827     /* 5 ms redundant frame for SILK->CELT */
828     if (redundancy && !celt_to_silk)
829     {
830         int N2, N4;
831         N2 = st->Fs/200;
832         N4 = st->Fs/400;
833
834         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
835         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
836         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
837
838         /* TODO: We could speed up prefilling here */
839         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, data+nb_compr_bytes, redundancy_bytes, NULL);
840
841         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
842         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
843     }
844
845
846
847     /* Signalling the mode in the first byte */
848     data--;
849     data[0] = gen_toc(st->mode, st->Fs/frame_size, st->bandwidth, silk_internal_bandwidth, st->stream_channels);
850
851     st->rangeFinal = enc.rng ^ redundant_rng;
852
853     if (to_celt)
854         st->prev_mode = MODE_CELT_ONLY;
855     else
856         st->prev_mode = st->mode;
857     st->first = 0;
858     RESTORE_STACK;
859     return ret+1+redundancy_bytes;
860 }
861
862 #ifdef FIXED_POINT
863
864 #ifndef DISABLE_FLOAT_API
865 int opus_encode_float(OpusEncoder *st, const float *pcm, int frame_size,
866       unsigned char *data, int max_data_bytes)
867 {
868    int i, ret;
869    VARDECL(opus_int16, in);
870    ALLOC_STACK;
871
872    ALLOC(in, frame_size*st->channels, opus_int16);
873
874    for (i=0;i<frame_size*st->channels;i++)
875       in[i] = FLOAT2INT16(pcm[i]);
876    ret = opus_encode(st, in, frame_size, data, max_data_bytes);
877    RESTORE_STACK;
878    return ret;
879 }
880 #endif
881
882 #else
883 int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
884       unsigned char *data, int max_data_bytes)
885 {
886    int i, ret;
887    VARDECL(float, in);
888    ALLOC_STACK;
889
890    ALLOC(in, frame_size*st->channels, float);
891
892    for (i=0;i<frame_size*st->channels;i++)
893       in[i] = (1./32768)*pcm[i];
894    ret = opus_encode_float(st, in, frame_size, data, max_data_bytes);
895    RESTORE_STACK;
896    return ret;
897 }
898 #endif
899
900
901 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
902 {
903     int ret;
904     CELTEncoder *celt_enc;
905     va_list ap;
906
907     ret = OPUS_OK;
908     va_start(ap, request);
909
910     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
911
912     switch (request)
913     {
914         case OPUS_SET_APPLICATION_REQUEST:
915         {
916             opus_int32 value = va_arg(ap, opus_int32);
917             st->application = value;
918         }
919         break;
920         case OPUS_GET_APPLICATION_REQUEST:
921         {
922             opus_int32 *value = va_arg(ap, opus_int32*);
923             *value = st->mode;
924         }
925         break;
926         case OPUS_SET_BITRATE_REQUEST:
927         {
928             opus_int32 value = va_arg(ap, opus_int32);
929             if (value != OPUS_BITRATE_AUTO)
930             {
931                 if (value <= 0)
932                     goto bad_arg;
933                 else if (value <= 500)
934                     value = 500;
935             }
936             st->user_bitrate_bps = value;
937         }
938         break;
939         case OPUS_GET_BITRATE_REQUEST:
940         {
941             opus_int32 *value = va_arg(ap, opus_int32*);
942             *value = st->bitrate_bps;
943         }
944         break;
945         case OPUS_SET_FORCE_MONO_REQUEST:
946         {
947             opus_int32 value = va_arg(ap, opus_int32);
948             st->force_mono = value;
949         }
950         break;
951         case OPUS_GET_FORCE_MONO_REQUEST:
952         {
953             opus_int32 *value = va_arg(ap, opus_int32*);
954             *value = !!st->force_mono;
955         }
956         break;
957         case OPUS_SET_BANDWIDTH_REQUEST:
958         {
959             opus_int32 value = va_arg(ap, opus_int32);
960             if (value < OPUS_BANDWIDTH_AUTO || value > OPUS_BANDWIDTH_FULLBAND)
961                 return OPUS_BAD_ARG;
962             st->user_bandwidth = value;
963             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
964                 st->silk_mode.maxInternalSampleRate = 8000;
965             } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
966                 st->silk_mode.maxInternalSampleRate = 12000;
967             } else {
968                 st->silk_mode.maxInternalSampleRate = 16000;
969             }
970         }
971         break;
972         case OPUS_GET_BANDWIDTH_REQUEST:
973         {
974             opus_int32 *value = va_arg(ap, opus_int32*);
975             *value = st->bandwidth;
976         }
977         break;
978         case OPUS_SET_DTX_REQUEST:
979         {
980             opus_int32 value = va_arg(ap, opus_int32);
981             st->silk_mode.useDTX = value;
982         }
983         break;
984         case OPUS_GET_DTX_REQUEST:
985         {
986             opus_int32 *value = va_arg(ap, opus_int32*);
987             *value = st->silk_mode.useDTX;
988         }
989         break;
990         case OPUS_SET_COMPLEXITY_REQUEST:
991         {
992             opus_int32 value = va_arg(ap, opus_int32);
993             st->silk_mode.complexity = value;
994             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
995         }
996         break;
997         case OPUS_GET_COMPLEXITY_REQUEST:
998         {
999             opus_int32 *value = va_arg(ap, opus_int32*);
1000             *value = st->silk_mode.complexity;
1001         }
1002         break;
1003         case OPUS_SET_INBAND_FEC_REQUEST:
1004         {
1005             opus_int32 value = va_arg(ap, opus_int32);
1006             st->silk_mode.useInBandFEC = value;
1007         }
1008         break;
1009         case OPUS_GET_INBAND_FEC_REQUEST:
1010         {
1011             opus_int32 *value = va_arg(ap, opus_int32*);
1012             *value = st->silk_mode.useInBandFEC;
1013         }
1014         break;
1015         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1016         {
1017             opus_int32 value = va_arg(ap, opus_int32);
1018             if (value < 0 || value > 100)
1019                 return OPUS_BAD_ARG;
1020             st->silk_mode.packetLossPercentage = value;
1021             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
1022         }
1023         break;
1024         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1025         {
1026             opus_int32 *value = va_arg(ap, opus_int32*);
1027             *value = st->silk_mode.packetLossPercentage;
1028         }
1029         break;
1030         case OPUS_SET_VBR_REQUEST:
1031         {
1032             opus_int32 value = va_arg(ap, opus_int32);
1033             st->use_vbr = value;
1034             st->silk_mode.useCBR = 1-value;
1035         }
1036         break;
1037         case OPUS_GET_VBR_REQUEST:
1038         {
1039             opus_int32 *value = va_arg(ap, opus_int32*);
1040             *value = st->use_vbr;
1041         }
1042         break;
1043         case OPUS_SET_VOICE_RATIO_REQUEST:
1044         {
1045             opus_int32 value = va_arg(ap, opus_int32);
1046             if (value>100 || value<0)
1047                 goto bad_arg;
1048             st->voice_ratio = value;
1049         }
1050         break;
1051         case OPUS_GET_VOICE_RATIO_REQUEST:
1052         {
1053             opus_int32 *value = va_arg(ap, opus_int32*);
1054             *value = st->voice_ratio;
1055         }
1056         break;
1057         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1058         {
1059             opus_int32 value = va_arg(ap, opus_int32);
1060             st->vbr_constraint = value;
1061         }
1062         break;
1063         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1064         {
1065             opus_int32 *value = va_arg(ap, opus_int32*);
1066             *value = st->vbr_constraint;
1067         }
1068         break;
1069         case OPUS_SET_SIGNAL_REQUEST:
1070         {
1071             opus_int32 value = va_arg(ap, opus_int32);
1072             st->signal_type = value;
1073         }
1074         break;
1075         case OPUS_GET_SIGNAL_REQUEST:
1076         {
1077             opus_int32 *value = va_arg(ap, opus_int32*);
1078             *value = st->signal_type;
1079         }
1080         break;
1081         case OPUS_GET_LOOKAHEAD_REQUEST:
1082         {
1083             opus_int32 *value = va_arg(ap, opus_int32*);
1084             *value = st->delay_compensation+st->Fs/400;
1085         }
1086         break;
1087         case OPUS_GET_FINAL_RANGE_REQUEST:
1088         {
1089             opus_uint32 *value = va_arg(ap, opus_uint32*);
1090             *value = st->rangeFinal;
1091         }
1092         break;
1093         case OPUS_RESET_STATE:
1094         {
1095            void *silk_enc;
1096            silk_EncControlStruct dummy;
1097            silk_enc = (char*)st+st->silk_enc_offset;
1098
1099            OPUS_CLEAR((char*)&st->OPUS_ENCODER_RESET_START,
1100                  opus_encoder_get_size(st->channels)-
1101                  ((char*)&st->OPUS_ENCODER_RESET_START - (char*)st));
1102
1103            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
1104            silk_InitEncoder( silk_enc, &dummy );
1105            st->stream_channels = st->channels;
1106            st->hybrid_stereo_width_Q14             = 1 << 14;
1107            st->first = 1;
1108            st->mode = MODE_HYBRID;
1109            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
1110            st->variable_HP_smth2_Q15 = SKP_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1111         }
1112         break;
1113         default:
1114             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
1115             ret = OPUS_UNIMPLEMENTED;
1116             break;
1117     }
1118     va_end(ap);
1119     return ret;
1120 bad_arg:
1121     va_end(ap);
1122     return OPUS_BAD_ARG;
1123 }
1124
1125 void opus_encoder_destroy(OpusEncoder *st)
1126 {
1127     opus_free(st);
1128 }