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 COPYRIGHT OWNER
  19    OR 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 "API.h"
  37 #include "stack_alloc.h"
  38 #include "float_cast.h"
  39 #include "opus.h"
  40 #include "arch.h"
  41 #include "pitch.h"
  42 #include "opus_private.h"
  43 #include "os_support.h"
  44 #include "cpu_support.h"
  45 #include "analysis.h"
  46 #include "mathops.h"
  47 #include "tuning_parameters.h"
  48 #ifdef FIXED_POINT
  49 #include "fixed/structs_FIX.h"
  50 #else
  51 #include "float/structs_FLP.h"
  52 #endif
  53
  54 #define MAX_ENCODER_BUFFER 480
  55
  56 #ifndef DISABLE_FLOAT_API
  57 #define PSEUDO_SNR_THRESHOLD 316.23f    /* 10^(25/10) */
  58 #endif
  59
  60 typedef struct {
  61    opus_val32 XX, XY, YY;
  62    opus_val16 smoothed_width;
  63    opus_val16 max_follower;
  64 } StereoWidthState;
  65
  66 struct OpusEncoder {
  67     int          celt_enc_offset;
  68     int          silk_enc_offset;
  69     silk_EncControlStruct silk_mode;
  70     int          application;
  71     int          channels;
  72     int          delay_compensation;
  73     int          force_channels;
  74     int          signal_type;
  75     int          user_bandwidth;
  76     int          max_bandwidth;
  77     int          user_forced_mode;
  78     int          voice_ratio;
  79     opus_int32   Fs;
  80     int          use_vbr;
  81     int          vbr_constraint;
  82     int          variable_duration;
  83     opus_int32   bitrate_bps;
  84     opus_int32   user_bitrate_bps;
  85     int          lsb_depth;
  86     int          encoder_buffer;
  87     int          lfe;
  88     int          arch;
  89     int          use_dtx;                 /* general DTX for both SILK and CELT */
  90 #ifndef DISABLE_FLOAT_API
  91     TonalityAnalysisState analysis;
  92 #endif
  93
  94 #define OPUS_ENCODER_RESET_START stream_channels
  95     int          stream_channels;
  96     opus_int16   hybrid_stereo_width_Q14;
  97     opus_int32   variable_HP_smth2_Q15;
  98     opus_val16   prev_HB_gain;
  99     opus_val32   hp_mem[4];
 100     int          mode;
 101     int          prev_mode;
 102     int          prev_channels;
 103     int          prev_framesize;
 104     int          bandwidth;
 105     /* Bandwidth determined automatically from the rate (before any other adjustment) */
 106     int          auto_bandwidth;
 107     int          silk_bw_switch;
 108     /* Sampling rate (at the API level) */
 109     int          first;
 110     opus_val16 * energy_masking;
 111     StereoWidthState width_mem;
 112     opus_val16   delay_buffer[MAX_ENCODER_BUFFER*2];
 113 #ifndef DISABLE_FLOAT_API
 114     int          detected_bandwidth;
 115     int          nb_no_activity_frames;
 116     opus_val32   peak_signal_energy;
 117 #endif
 118     int          nonfinal_frame; /* current frame is not the final in a packet */
 119     opus_uint32  rangeFinal;
 120 };
 121
 122 /* Transition tables for the voice and music. First column is the
 123    middle (memoriless) threshold. The second column is the hysteresis
 124    (difference with the middle) */
 125 static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
 126         10000, 1000, /* NB<->MB */
 127         11000, 1000, /* MB<->WB */
 128         13500, 1000, /* WB<->SWB */
 129         14000, 2000, /* SWB<->FB */
 130 };
 131 static const opus_int32 mono_music_bandwidth_thresholds[8] = {
 132         10000, 1000, /* NB<->MB */
 133         11000, 1000, /* MB<->WB */
 134         13500, 1000, /* WB<->SWB */
 135         14000, 2000, /* SWB<->FB */
 136 };
 137 static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
 138         10000, 1000, /* NB<->MB */
 139         11000, 1000, /* MB<->WB */
 140         13500, 1000, /* WB<->SWB */
 141         14000, 2000, /* SWB<->FB */
 142 };
 143 static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
 144         10000, 1000, /* NB<->MB */
 145         11000, 1000, /* MB<->WB */
 146         13500, 1000, /* WB<->SWB */
 147         14000, 2000, /* SWB<->FB */
 148 };
 149 /* Threshold bit-rates for switching between mono and stereo */
 150 static const opus_int32 stereo_voice_threshold = 24000;
 151 static const opus_int32 stereo_music_threshold = 24000;
 152
 153 /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
 154 static const opus_int32 mode_thresholds[2][2] = {
 155       /* voice */ /* music */
 156       {  64000,      16000}, /* mono */
 157       {  36000,      16000}, /* stereo */
 158 };
 159
 160 static const opus_int32 fec_thresholds[] = {
 161         12000, 1000, /* NB */
 162         14000, 1000, /* MB */
 163         16000, 1000, /* WB */
 164         20000, 1000, /* SWB */
 165         22000, 1000, /* FB */
 166 };
 167
 168 int opus_encoder_get_size(int channels)
 169 {
 170     int silkEncSizeBytes, celtEncSizeBytes;
 171     int ret;
 172     if (channels<1 || channels > 2)
 173         return 0;
 174     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
 175     if (ret)
 176         return 0;
 177     silkEncSizeBytes = align(silkEncSizeBytes);
 178     celtEncSizeBytes = celt_encoder_get_size(channels);
 179     return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
 180 }
 181
 182 int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
 183 {
 184     void *silk_enc;
 185     CELTEncoder *celt_enc;
 186     int err;
 187     int ret, silkEncSizeBytes;
 188
 189    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
 190         (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
 191         && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
 192         return OPUS_BAD_ARG;
 193
 194     OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
 195     /* Create SILK encoder */
 196     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
 197     if (ret)
 198         return OPUS_BAD_ARG;
 199     silkEncSizeBytes = align(silkEncSizeBytes);
 200     st->silk_enc_offset = align(sizeof(OpusEncoder));
 201     st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
 202     silk_enc = (char*)st+st->silk_enc_offset;
 203     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
 204
 205     st->stream_channels = st->channels = channels;
 206
 207     st->Fs = Fs;
 208
 209     st->arch = opus_select_arch();
 210
 211     ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
 212     if(ret)return OPUS_INTERNAL_ERROR;
 213
 214     /* default SILK parameters */
 215     st->silk_mode.nChannelsAPI              = channels;
 216     st->silk_mode.nChannelsInternal         = channels;
 217     st->silk_mode.API_sampleRate            = st->Fs;
 218     st->silk_mode.maxInternalSampleRate     = 16000;
 219     st->silk_mode.minInternalSampleRate     = 8000;
 220     st->silk_mode.desiredInternalSampleRate = 16000;
 221     st->silk_mode.payloadSize_ms            = 20;
 222     st->silk_mode.bitRate                   = 25000;
 223     st->silk_mode.packetLossPercentage      = 0;
 224     st->silk_mode.complexity                = 9;
 225     st->silk_mode.useInBandFEC              = 0;
 226     st->silk_mode.useDTX                    = 0;
 227     st->silk_mode.useCBR                    = 0;
 228     st->silk_mode.reducedDependency         = 0;
 229
 230     /* Create CELT encoder */
 231     /* Initialize CELT encoder */
 232     err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
 233     if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR;
 234
 235     celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0));
 236     celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity));
 237
 238     st->use_vbr = 1;
 239     /* Makes constrained VBR the default (safer for real-time use) */
 240     st->vbr_constraint = 1;
 241     st->user_bitrate_bps = OPUS_AUTO;
 242     st->bitrate_bps = 3000+Fs*channels;
 243     st->application = application;
 244     st->signal_type = OPUS_AUTO;
 245     st->user_bandwidth = OPUS_AUTO;
 246     st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND;
 247     st->force_channels = OPUS_AUTO;
 248     st->user_forced_mode = OPUS_AUTO;
 249     st->voice_ratio = -1;
 250     st->encoder_buffer = st->Fs/100;
 251     st->lsb_depth = 24;
 252     st->variable_duration = OPUS_FRAMESIZE_ARG;
 253
 254     /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
 255        + 1.5 ms for SILK resamplers and stereo prediction) */
 256     st->delay_compensation = st->Fs/250;
 257
 258     st->hybrid_stereo_width_Q14 = 1 << 14;
 259     st->prev_HB_gain = Q15ONE;
 260     st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
 261     st->first = 1;
 262     st->mode = MODE_HYBRID;
 263     st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
 264
 265 #ifndef DISABLE_FLOAT_API
 266     tonality_analysis_init(&st->analysis);
 267 #endif
 268
 269     return OPUS_OK;
 270 }
 271
 272 static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
 273 {
 274    int period;
 275    unsigned char toc;
 276    period = 0;
 277    while (framerate < 400)
 278    {
 279        framerate <<= 1;
 280        period++;
 281    }
 282    if (mode == MODE_SILK_ONLY)
 283    {
 284        toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5;
 285        toc |= (period-2)<<3;
 286    } else if (mode == MODE_CELT_ONLY)
 287    {
 288        int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND;
 289        if (tmp < 0)
 290            tmp = 0;
 291        toc = 0x80;
 292        toc |= tmp << 5;
 293        toc |= period<<3;
 294    } else /* Hybrid */
 295    {
 296        toc = 0x60;
 297        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
 298        toc |= (period-2)<<3;
 299    }
 300    toc |= (channels==2)<<2;
 301    return toc;
 302 }
 303
 304 #ifndef FIXED_POINT
 305 static void silk_biquad_float(
 306     const opus_val16      *in,            /* I:    Input signal                   */
 307     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
 308     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
 309     opus_val32            *S,             /* I/O:  State vector [2]               */
 310     opus_val16            *out,           /* O:    Output signal                  */
 311     const opus_int32      len,            /* I:    Signal length (must be even)   */
 312     int stride
 313 )
 314 {
 315     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
 316     opus_int   k;
 317     opus_val32 vout;
 318     opus_val32 inval;
 319     opus_val32 A[2], B[3];
 320
 321     A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
 322     A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
 323     B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
 324     B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
 325     B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
 326
 327     /* Negate A_Q28 values and split in two parts */
 328
 329     for( k = 0; k < len; k++ ) {
 330         /* S[ 0 ], S[ 1 ]: Q12 */
 331         inval = in[ k*stride ];
 332         vout = S[ 0 ] + B[0]*inval;
 333
 334         S[ 0 ] = S[1] - vout*A[0] + B[1]*inval;
 335
 336         S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL;
 337
 338         /* Scale back to Q0 and saturate */
 339         out[ k*stride ] = vout;
 340     }
 341 }
 342 #endif
 343
 344 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)
 345 {
 346    opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
 347    opus_int32 Fc_Q19, r_Q28, r_Q22;
 348
 349    silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
 350    Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 );
 351    silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
 352
 353    r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 );
 354
 355    /* b = r * [ 1; -2; 1 ]; */
 356    /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
 357    B_Q28[ 0 ] = r_Q28;
 358    B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 );
 359    B_Q28[ 2 ] = r_Q28;
 360
 361    /* -r * ( 2 - Fc * Fc ); */
 362    r_Q22  = silk_RSHIFT( r_Q28, 6 );
 363    A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0,  22 ) );
 364    A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 );
 365
 366 #ifdef FIXED_POINT
 367    silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
 368    if( channels == 2 ) {
 369        silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
 370    }
 371 #else
 372    silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
 373    if( channels == 2 ) {
 374        silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
 375    }
 376 #endif
 377 }
 378
 379 #ifdef FIXED_POINT
 380 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
 381 {
 382    int c, i;
 383    int shift;
 384
 385    /* Approximates -round(log2(4.*cutoff_Hz/Fs)) */
 386    shift=celt_ilog2(Fs/(cutoff_Hz*3));
 387    for (c=0;c<channels;c++)
 388    {
 389       for (i=0;i<len;i++)
 390       {
 391          opus_val32 x, tmp, y;
 392          x = SHL32(EXTEND32(in[channels*i+c]), 14);
 393          /* First stage */
 394          tmp = x-hp_mem[2*c];
 395          hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift);
 396          /* Second stage */
 397          y = tmp - hp_mem[2*c+1];
 398          hp_mem[2*c+1] = hp_mem[2*c+1] + PSHR32(tmp - hp_mem[2*c+1], shift);
 399          out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 14), 32767));
 400       }
 401    }
 402 }
 403
 404 #else
 405 static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs)
 406 {
 407    int i;
 408    float coef, coef2;
 409    coef = 4.0f*cutoff_Hz/Fs;
 410    coef2 = 1-coef;
 411    if (channels==2)
 412    {
 413       float m0, m1, m2, m3;
 414       m0 = hp_mem[0];
 415       m1 = hp_mem[1];
 416       m2 = hp_mem[2];
 417       m3 = hp_mem[3];
 418       for (i=0;i<len;i++)
 419       {
 420          opus_val32 x0, x1, tmp0, tmp1, y0, y1;
 421          x0 = in[2*i+0];
 422          x1 = in[2*i+1];
 423          /* First stage */
 424          tmp0 = x0-m0;
 425          tmp1 = x1-m2;
 426          m0 = coef*x0 + VERY_SMALL + coef2*m0;
 427          m2 = coef*x1 + VERY_SMALL + coef2*m2;
 428          /* Second stage */
 429          y0 = tmp0 - m1;
 430          y1 = tmp1 - m3;
 431          m1 = coef*tmp0 + VERY_SMALL + coef2*m1;
 432          m3 = coef*tmp1 + VERY_SMALL + coef2*m3;
 433          out[2*i+0] = y0;
 434          out[2*i+1] = y1;
 435       }
 436       hp_mem[0] = m0;
 437       hp_mem[1] = m1;
 438       hp_mem[2] = m2;
 439       hp_mem[3] = m3;
 440    } else {
 441       float m0, m1;
 442       m0 = hp_mem[0];
 443       m1 = hp_mem[1];
 444       for (i=0;i<len;i++)
 445       {
 446          opus_val32 x, tmp, y;
 447          x = in[i];
 448          /* First stage */
 449          tmp = x-m0;
 450          m0 = coef*x + VERY_SMALL + coef2*m0;
 451          /* Second stage */
 452          y = tmp - m1;
 453          m1 = coef*tmp + VERY_SMALL + coef2*m1;
 454          out[i] = y;
 455       }
 456       hp_mem[0] = m0;
 457       hp_mem[1] = m1;
 458    }
 459 }
 460 #endif
 461
 462 static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
 463         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
 464 {
 465     int i;
 466     int overlap;
 467     int inc;
 468     inc = 48000/Fs;
 469     overlap=overlap48/inc;
 470     g1 = Q15ONE-g1;
 471     g2 = Q15ONE-g2;
 472     for (i=0;i<overlap;i++)
 473     {
 474        opus_val32 diff;
 475        opus_val16 g, w;
 476        w = MULT16_16_Q15(window[i*inc], window[i*inc]);
 477        g = SHR32(MAC16_16(MULT16_16(w,g2),
 478              Q15ONE-w, g1), 15);
 479        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
 480        diff = MULT16_16_Q15(g, diff);
 481        out[i*channels] = out[i*channels] - diff;
 482        out[i*channels+1] = out[i*channels+1] + diff;
 483     }
 484     for (;i<frame_size;i++)
 485     {
 486        opus_val32 diff;
 487        diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1]));
 488        diff = MULT16_16_Q15(g2, diff);
 489        out[i*channels] = out[i*channels] - diff;
 490        out[i*channels+1] = out[i*channels+1] + diff;
 491     }
 492 }
 493
 494 static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2,
 495         int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
 496 {
 497     int i;
 498     int inc;
 499     int overlap;
 500     int c;
 501     inc = 48000/Fs;
 502     overlap=overlap48/inc;
 503     if (channels==1)
 504     {
 505        for (i=0;i<overlap;i++)
 506        {
 507           opus_val16 g, w;
 508           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
 509           g = SHR32(MAC16_16(MULT16_16(w,g2),
 510                 Q15ONE-w, g1), 15);
 511           out[i] = MULT16_16_Q15(g, in[i]);
 512        }
 513     } else {
 514        for (i=0;i<overlap;i++)
 515        {
 516           opus_val16 g, w;
 517           w = MULT16_16_Q15(window[i*inc], window[i*inc]);
 518           g = SHR32(MAC16_16(MULT16_16(w,g2),
 519                 Q15ONE-w, g1), 15);
 520           out[i*2] = MULT16_16_Q15(g, in[i*2]);
 521           out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]);
 522        }
 523     }
 524     c=0;do {
 525        for (i=overlap;i<frame_size;i++)
 526        {
 527           out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]);
 528        }
 529     }
 530     while (++c<channels);
 531 }
 532
 533 OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error)
 534 {
 535    int ret;
 536    OpusEncoder *st;
 537    if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)||
 538        (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO
 539        && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY))
 540    {
 541       if (error)
 542          *error = OPUS_BAD_ARG;
 543       return NULL;
 544    }
 545    st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
 546    if (st == NULL)
 547    {
 548       if (error)
 549          *error = OPUS_ALLOC_FAIL;
 550       return NULL;
 551    }
 552    ret = opus_encoder_init(st, Fs, channels, application);
 553    if (error)
 554       *error = ret;
 555    if (ret != OPUS_OK)
 556    {
 557       opus_free(st);
 558       st = NULL;
 559    }
 560    return st;
 561 }
 562
 563 static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
 564 {
 565   if(!frame_size)frame_size=st->Fs/400;
 566   if (st->user_bitrate_bps==OPUS_AUTO)
 567     return 60*st->Fs/frame_size + st->Fs*st->channels;
 568   else if (st->user_bitrate_bps==OPUS_BITRATE_MAX)
 569     return max_data_bytes*8*st->Fs/frame_size;
 570   else
 571     return st->user_bitrate_bps;
 572 }
 573
 574 #ifndef DISABLE_FLOAT_API
 575 /* Don't use more than 60 ms for the frame size analysis */
 576 #define MAX_DYNAMIC_FRAMESIZE 24
 577 /* Estimates how much the bitrate will be boosted based on the sub-frame energy */
 578 static float transient_boost(const float *E, const float *E_1, int LM, int maxM)
 579 {
 580    int i;
 581    int M;
 582    float sumE=0, sumE_1=0;
 583    float metric;
 584
 585    M = IMIN(maxM, (1<<LM)+1);
 586    for (i=0;i<M;i++)
 587    {
 588       sumE += E[i];
 589       sumE_1 += E_1[i];
 590    }
 591    metric = sumE*sumE_1/(M*M);
 592    /*if (LM==3)
 593       printf("%f\n", metric);*/
 594    /*return metric>10 ? 1 : 0;*/
 595    /*return MAX16(0,1-exp(-.25*(metric-2.)));*/
 596    return MIN16(1,(float)sqrt(MAX16(0,.05f*(metric-2))));
 597 }
 598
 599 /* Viterbi decoding trying to find the best frame size combination using look-ahead
 600
 601    State numbering:
 602     0: unused
 603     1:  2.5 ms
 604     2:  5 ms (#1)
 605     3:  5 ms (#2)
 606     4: 10 ms (#1)
 607     5: 10 ms (#2)
 608     6: 10 ms (#3)
 609     7: 10 ms (#4)
 610     8: 20 ms (#1)
 611     9: 20 ms (#2)
 612    10: 20 ms (#3)
 613    11: 20 ms (#4)
 614    12: 20 ms (#5)
 615    13: 20 ms (#6)
 616    14: 20 ms (#7)
 617    15: 20 ms (#8)
 618 */
 619 static int transient_viterbi(const float *E, const float *E_1, int N, int frame_cost, int rate)
 620 {
 621    int i;
 622    float cost[MAX_DYNAMIC_FRAMESIZE][16];
 623    int states[MAX_DYNAMIC_FRAMESIZE][16];
 624    float best_cost;
 625    int best_state;
 626    float factor;
 627    /* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
 628    if (rate<80)
 629       factor=0;
 630    else if (rate>160)
 631       factor=1;
 632    else
 633       factor = (rate-80.f)/80.f;
 634    /* Makes variable framesize less aggressive at lower bitrates, but I can't
 635       find any valid theoretical justification for this (other than it seems
 636       to help) */
 637    for (i=0;i<16;i++)
 638    {
 639       /* Impossible state */
 640       states[0][i] = -1;
 641       cost[0][i] = 1e10;
 642    }
 643    for (i=0;i<4;i++)
 644    {
 645       cost[0][1<<i] = (frame_cost + rate*(1<<i))*(1+factor*transient_boost(E, E_1, i, N+1));
 646       states[0][1<<i] = i;
 647    }
 648    for (i=1;i<N;i++)
 649    {
 650       int j;
 651
 652       /* Follow continuations */
 653       for (j=2;j<16;j++)
 654       {
 655          cost[i][j] = cost[i-1][j-1];
 656          states[i][j] = j-1;
 657       }
 658
 659       /* New frames */
 660       for(j=0;j<4;j++)
 661       {
 662          int k;
 663          float min_cost;
 664          float curr_cost;
 665          states[i][1<<j] = 1;
 666          min_cost = cost[i-1][1];
 667          for(k=1;k<4;k++)
 668          {
 669             float tmp = cost[i-1][(1<<(k+1))-1];
 670             if (tmp < min_cost)
 671             {
 672                states[i][1<<j] = (1<<(k+1))-1;
 673                min_cost = tmp;
 674             }
 675          }
 676          curr_cost = (frame_cost + rate*(1<<j))*(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
 677          cost[i][1<<j] = min_cost;
 678          /* If part of the frame is outside the analysis window, only count part of the cost */
 679          if (N-i < (1<<j))
 680             cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
 681          else
 682             cost[i][1<<j] += curr_cost;
 683       }
 684    }
 685
 686    best_state=1;
 687    best_cost = cost[N-1][1];
 688    /* Find best end state (doesn't force a frame to end at N-1) */
 689    for (i=2;i<16;i++)
 690    {
 691       if (cost[N-1][i]<best_cost)
 692       {
 693          best_cost = cost[N-1][i];
 694          best_state = i;
 695       }
 696    }
 697
 698    /* Follow transitions back */
 699    for (i=N-1;i>=0;i--)
 700    {
 701       /*printf("%d ", best_state);*/
 702       best_state = states[i][best_state];
 703    }
 704    /*printf("%d\n", best_state);*/
 705    return best_state;
 706 }
 707
 708 static int optimize_framesize(const void *x, int len, int C, opus_int32 Fs,
 709                 int bitrate, opus_val16 tonality, float *mem, int buffering,
 710                 downmix_func downmix)
 711 {
 712    int N;
 713    int i;
 714    float e[MAX_DYNAMIC_FRAMESIZE+4];
 715    float e_1[MAX_DYNAMIC_FRAMESIZE+3];
 716    opus_val32 memx;
 717    int bestLM=0;
 718    int subframe;
 719    int pos;
 720    int offset;
 721    VARDECL(opus_val32, sub);
 722
 723    subframe = Fs/400;
 724    ALLOC(sub, subframe, opus_val32);
 725    e[0]=mem[0];
 726    e_1[0]=1.f/(EPSILON+mem[0]);
 727    if (buffering)
 728    {
 729       /* Consider the CELT delay when not in restricted-lowdelay */
 730       /* We assume the buffering is between 2.5 and 5 ms */
 731       offset = 2*subframe - buffering;
 732       celt_assert(offset>=0 && offset <= subframe);
 733       len -= offset;
 734       e[1]=mem[1];
 735       e_1[1]=1.f/(EPSILON+mem[1]);
 736       e[2]=mem[2];
 737       e_1[2]=1.f/(EPSILON+mem[2]);
 738       pos = 3;
 739    } else {
 740       pos=1;
 741       offset=0;
 742    }
 743    N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE);
 744    /* Just silencing a warning, it's really initialized later */
 745    memx = 0;
 746    for (i=0;i<N;i++)
 747    {
 748       float tmp;
 749       opus_val32 tmpx;
 750       int j;
 751       tmp=EPSILON;
 752
 753       downmix(x, sub, subframe, i*subframe+offset, 0, -2, C);
 754       if (i==0)
 755          memx = sub[0];
 756       for (j=0;j<subframe;j++)
 757       {
 758          tmpx = sub[j];
 759          tmp += (tmpx-memx)*(float)(tmpx-memx);
 760          memx = tmpx;
 761       }
 762       e[i+pos] = tmp;
 763       e_1[i+pos] = 1.f/tmp;
 764    }
 765    /* Hack to get 20 ms working with APPLICATION_AUDIO
 766       The real problem is that the corresponding memory needs to use 1.5 ms
 767       from this frame and 1 ms from the next frame */
 768    e[i+pos] = e[i+pos-1];
 769    if (buffering)
 770       N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2);
 771    bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5f*tonality)*(60*C+40)), bitrate/400);
 772    mem[0] = e[1<<bestLM];
 773    if (buffering)
 774    {
 775       mem[1] = e[(1<<bestLM)+1];
 776       mem[2] = e[(1<<bestLM)+2];
 777    }
 778    return bestLM;
 779 }
 780
 781 #endif
 782
 783 #ifndef DISABLE_FLOAT_API
 784 #ifdef FIXED_POINT
 785 #define PCM2VAL(x) FLOAT2INT16(x)
 786 #else
 787 #define PCM2VAL(x) SCALEIN(x)
 788 #endif
 789 void downmix_float(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
 790 {
 791    const float *x;
 792    opus_val32 scale;
 793    int j;
 794    x = (const float *)_x;
 795    for (j=0;j<subframe;j++)
 796       sub[j] = PCM2VAL(x[(j+offset)*C+c1]);
 797    if (c2>-1)
 798    {
 799       for (j=0;j<subframe;j++)
 800          sub[j] += PCM2VAL(x[(j+offset)*C+c2]);
 801    } else if (c2==-2)
 802    {
 803       int c;
 804       for (c=1;c<C;c++)
 805       {
 806          for (j=0;j<subframe;j++)
 807             sub[j] += PCM2VAL(x[(j+offset)*C+c]);
 808       }
 809    }
 810 #ifdef FIXED_POINT
 811    scale = (1<<SIG_SHIFT);
 812 #else
 813    scale = 1.f;
 814 #endif
 815    if (c2==-2)
 816       scale /= C;
 817    else if (c2>-1)
 818       scale /= 2;
 819    for (j=0;j<subframe;j++)
 820       sub[j] *= scale;
 821 }
 822 #endif
 823
 824 void downmix_int(const void *_x, opus_val32 *sub, int subframe, int offset, int c1, int c2, int C)
 825 {
 826    const opus_int16 *x;
 827    opus_val32 scale;
 828    int j;
 829    x = (const opus_int16 *)_x;
 830    for (j=0;j<subframe;j++)
 831       sub[j] = x[(j+offset)*C+c1];
 832    if (c2>-1)
 833    {
 834       for (j=0;j<subframe;j++)
 835          sub[j] += x[(j+offset)*C+c2];
 836    } else if (c2==-2)
 837    {
 838       int c;
 839       for (c=1;c<C;c++)
 840       {
 841          for (j=0;j<subframe;j++)
 842             sub[j] += x[(j+offset)*C+c];
 843       }
 844    }
 845 #ifdef FIXED_POINT
 846    scale = (1<<SIG_SHIFT);
 847 #else
 848    scale = 1.f/32768;
 849 #endif
 850    if (c2==-2)
 851       scale /= C;
 852    else if (c2>-1)
 853       scale /= 2;
 854    for (j=0;j<subframe;j++)
 855       sub[j] *= scale;
 856 }
 857
 858 opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
 859 {
 860    int new_size;
 861    if (frame_size<Fs/400)
 862       return -1;
 863    if (variable_duration == OPUS_FRAMESIZE_ARG)
 864       new_size = frame_size;
 865    else if (variable_duration == OPUS_FRAMESIZE_VARIABLE)
 866       new_size = Fs/50;
 867    else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_120_MS)
 868    {
 869       if (variable_duration <= OPUS_FRAMESIZE_40_MS)
 870          new_size = (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS);
 871       else
 872          new_size = (variable_duration-OPUS_FRAMESIZE_2_5_MS-2)*Fs/50;
 873    }
 874    else
 875       return -1;
 876    if (new_size>frame_size)
 877       return -1;
 878    if (400*new_size!=Fs   && 200*new_size!=Fs   && 100*new_size!=Fs   &&
 879         50*new_size!=Fs   &&  25*new_size!=Fs   &&  50*new_size!=3*Fs &&
 880         50*new_size!=4*Fs &&  50*new_size!=5*Fs &&  50*new_size!=6*Fs)
 881       return -1;
 882    return new_size;
 883 }
 884
 885 opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
 886       int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
 887       int delay_compensation, downmix_func downmix
 888 #ifndef DISABLE_FLOAT_API
 889       , float *subframe_mem
 890 #endif
 891       )
 892 {
 893 #ifndef DISABLE_FLOAT_API
 894    if (variable_duration == OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs/200)
 895    {
 896       int LM = 3;
 897       LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
 898             0, subframe_mem, delay_compensation, downmix);
 899       while ((Fs/400<<LM)>frame_size)
 900          LM--;
 901       frame_size = (Fs/400<<LM);
 902    } else
 903 #else
 904    (void)analysis_pcm;
 905    (void)C;
 906    (void)bitrate_bps;
 907    (void)delay_compensation;
 908    (void)downmix;
 909 #endif
 910    {
 911       frame_size = frame_size_select(frame_size, variable_duration, Fs);
 912    }
 913    if (frame_size<0)
 914       return -1;
 915    return frame_size;
 916 }
 917
 918 opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem)
 919 {
 920    opus_val32 xx, xy, yy;
 921    opus_val16 sqrt_xx, sqrt_yy;
 922    opus_val16 qrrt_xx, qrrt_yy;
 923    int frame_rate;
 924    int i;
 925    opus_val16 short_alpha;
 926
 927    frame_rate = Fs/frame_size;
 928    short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate);
 929    xx=xy=yy=0;
 930    /* Unroll by 4. The frame size is always a multiple of 4 *except* for
 931       2.5 ms frames at 12 kHz. Since this setting is very rare (and very
 932       stupid), we just discard the last two samples. */
 933    for (i=0;i<frame_size-3;i+=4)
 934    {
 935       opus_val32 pxx=0;
 936       opus_val32 pxy=0;
 937       opus_val32 pyy=0;
 938       opus_val16 x, y;
 939       x = pcm[2*i];
 940       y = pcm[2*i+1];
 941       pxx = SHR32(MULT16_16(x,x),2);
 942       pxy = SHR32(MULT16_16(x,y),2);
 943       pyy = SHR32(MULT16_16(y,y),2);
 944       x = pcm[2*i+2];
 945       y = pcm[2*i+3];
 946       pxx += SHR32(MULT16_16(x,x),2);
 947       pxy += SHR32(MULT16_16(x,y),2);
 948       pyy += SHR32(MULT16_16(y,y),2);
 949       x = pcm[2*i+4];
 950       y = pcm[2*i+5];
 951       pxx += SHR32(MULT16_16(x,x),2);
 952       pxy += SHR32(MULT16_16(x,y),2);
 953       pyy += SHR32(MULT16_16(y,y),2);
 954       x = pcm[2*i+6];
 955       y = pcm[2*i+7];
 956       pxx += SHR32(MULT16_16(x,x),2);
 957       pxy += SHR32(MULT16_16(x,y),2);
 958       pyy += SHR32(MULT16_16(y,y),2);
 959
 960       xx += SHR32(pxx, 10);
 961       xy += SHR32(pxy, 10);
 962       yy += SHR32(pyy, 10);
 963    }
 964    mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX);
 965    mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY);
 966    mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY);
 967    mem->XX = MAX32(0, mem->XX);
 968    mem->XY = MAX32(0, mem->XY);
 969    mem->YY = MAX32(0, mem->YY);
 970    if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18))
 971    {
 972       opus_val16 corr;
 973       opus_val16 ldiff;
 974       opus_val16 width;
 975       sqrt_xx = celt_sqrt(mem->XX);
 976       sqrt_yy = celt_sqrt(mem->YY);
 977       qrrt_xx = celt_sqrt(sqrt_xx);
 978       qrrt_yy = celt_sqrt(sqrt_yy);
 979       /* Inter-channel correlation */
 980       mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy);
 981       corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16);
 982       /* Approximate loudness difference */
 983       ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy);
 984       width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff);
 985       /* Smoothing over one second */
 986       mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
 987       /* Peak follower */
 988       mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width);
 989    }
 990    /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/
 991    return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower)));
 992 }
 993
 994 static int decide_fec(int useInBandFEC, int PacketLoss_perc, int last_fec, int mode, int *bandwidth, opus_int32 rate)
 995 {
 996    int orig_bandwidth;
 997    if (!useInBandFEC || PacketLoss_perc == 0 || mode == MODE_CELT_ONLY)
 998       return 0;
 999    orig_bandwidth = *bandwidth;
1000    for (;;)
1001    {
1002       opus_int32 hysteresis;
1003       opus_int32 LBRR_rate_thres_bps;
1004       /* Compute threshold for using FEC at the current bandwidth setting */
1005       LBRR_rate_thres_bps = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND)];
1006       hysteresis = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND) + 1];
1007       if (last_fec == 1) LBRR_rate_thres_bps -= hysteresis;
1008       if (last_fec == 0) LBRR_rate_thres_bps += hysteresis;
1009       LBRR_rate_thres_bps = silk_SMULWB( silk_MUL( LBRR_rate_thres_bps,
1010             125 - silk_min( PacketLoss_perc, 25 ) ), SILK_FIX_CONST( 0.01, 16 ) );
1011       /* If loss <= 5%, we look at whether we have enough rate to enable FEC.
1012          If loss > 5%, we decrease the bandwidth until we can enable FEC. */
1013       if (rate > LBRR_rate_thres_bps)
1014          return 1;
1015       else if (PacketLoss_perc <= 5)
1016          return 0;
1017       else if (*bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1018          (*bandwidth)--;
1019       else
1020          break;
1021    }
1022    /* Couldn't find any bandwidth to enable FEC, keep original bandwidth. */
1023    *bandwidth = orig_bandwidth;
1024    return 0;
1025 }
1026
1027 static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr, int fec) {
1028    int entry;
1029    int i;
1030    int N;
1031    int silk_rate;
1032    static int rate_table[][5] = {
1033   /*  |total| |-------- SILK------------|
1034               |-- No FEC -| |--- FEC ---|
1035                10ms   20ms   10ms   20ms */
1036       {    0,     0,     0,     0,     0},
1037       {12000, 10000, 10000, 11000, 11000},
1038       {16000, 13500, 13500, 15000, 15000},
1039       {20000, 16000, 16000, 18000, 18000},
1040       {24000, 18000, 18000, 21000, 21000},
1041       {32000, 22000, 22000, 28000, 28000},
1042       {64000, 38000, 38000, 50000, 50000}
1043    };
1044    entry = 1 + frame20ms + 2*fec;
1045    N = sizeof(rate_table)/sizeof(rate_table[0]);
1046    for (i=1;i<N;i++)
1047    {
1048       if (rate_table[i][0] > rate) break;
1049    }
1050    if (i == N)
1051    {
1052       silk_rate = rate_table[i-1][entry];
1053       /* For now, just give 50% of the extra bits to SILK. */
1054       silk_rate += (rate-rate_table[i-1][0])/2;
1055    } else {
1056       opus_int32 lo, hi, x0, x1;
1057       lo = rate_table[i-1][entry];
1058       hi = rate_table[i][entry];
1059       x0 = rate_table[i-1][0];
1060       x1 = rate_table[i][0];
1061       silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0);
1062    }
1063    if (!vbr)
1064    {
1065       /* Tiny boost to SILK for CBR. We should probably tune this better. */
1066       silk_rate += 100;
1067    }
1068    if (bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND)
1069       silk_rate += 300;
1070    return silk_rate;
1071 }
1072
1073 /* Returns the equivalent bitrate corresponding to 20 ms frames,
1074    complexity 10 VBR operation. */
1075 static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels,
1076       int frame_rate, int vbr, int mode, int complexity, int loss)
1077 {
1078    opus_int32 equiv;
1079    equiv = bitrate;
1080    /* Take into account overhead from smaller frames. */
1081    equiv -= (40*channels+20)*(frame_rate - 50);
1082    /* CBR is about a 8% penalty for both SILK and CELT. */
1083    if (!vbr)
1084       equiv -= equiv/12;
1085    /* Complexity makes about 10% difference (from 0 to 10) in general. */
1086    equiv = equiv * (90+complexity)/100;
1087    if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID)
1088    {
1089       /* SILK complexity 0-1 uses the non-delayed-decision NSQ, which
1090          costs about 20%. */
1091       if (complexity<2)
1092          equiv = equiv*4/5;
1093       equiv -= equiv*loss/(6*loss + 10);
1094    } else if (mode == MODE_CELT_ONLY) {
1095       /* CELT complexity 0-4 doesn't have the pitch filter, which costs
1096          about 10%. */
1097       if (complexity<5)
1098          equiv = equiv*9/10;
1099    } else {
1100       /* Mode not known yet */
1101       /* Half the SILK loss*/
1102       equiv -= equiv*loss/(12*loss + 20);
1103    }
1104    return equiv;
1105 }
1106
1107 #ifndef DISABLE_FLOAT_API
1108
1109 static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth)
1110 {
1111    int silence = 0;
1112    opus_val32 sample_max = 0;
1113
1114    sample_max = celt_maxabs16(pcm, frame_size*channels);
1115
1116 #ifdef FIXED_POINT
1117    silence = (sample_max == 0);
1118    (void)lsb_depth;
1119 #else
1120    silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth));
1121 #endif
1122
1123    return silence;
1124 }
1125
1126 #ifdef FIXED_POINT
1127 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
1128 {
1129    int i;
1130    opus_val32 sample_max;
1131    int max_shift;
1132    int shift;
1133    opus_val32 energy = 0;
1134    int len = frame_size*channels;
1135    (void)arch;
1136    /* Max amplitude in the signal */
1137    sample_max = celt_maxabs16(pcm, len);
1138
1139    /* Compute the right shift required in the MAC to avoid an overflow */
1140    max_shift = celt_ilog2(len);
1141    shift = IMAX(0, (celt_ilog2(sample_max) << 1) + max_shift - 28);
1142
1143    /* Compute the energy */
1144    for (i=0; i<len; i++)
1145       energy += SHR32(MULT16_16(pcm[i], pcm[i]), shift);
1146
1147    /* Normalize energy by the frame size and left-shift back to the original position */
1148    energy /= len;
1149    energy = SHL32(energy, shift);
1150
1151    return energy;
1152 }
1153 #else
1154 static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch)
1155 {
1156    int len = frame_size*channels;
1157    return celt_inner_prod(pcm, pcm, len, arch)/len;
1158 }
1159 #endif
1160
1161 /* Decides if DTX should be turned on (=1) or off (=0) */
1162 static int decide_dtx_mode(float activity_probability,    /* probability that current frame contains speech/music */
1163                            int *nb_no_activity_frames,    /* number of consecutive frames with no activity */
1164                            opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */
1165                            const opus_val16 *pcm,         /* input pcm signal */
1166                            int frame_size,                /* frame size */
1167                            int channels,
1168                            int is_silence,                 /* only digital silence detected in this frame */
1169                            int arch
1170                           )
1171 {
1172    int is_noise;
1173    opus_val32 noise_energy;
1174    int is_sufficiently_quiet;
1175
1176    if (!is_silence)
1177    {
1178       is_noise = activity_probability < DTX_ACTIVITY_THRESHOLD;
1179       if (is_noise)
1180       {
1181          noise_energy = compute_frame_energy(pcm, frame_size, channels, arch);
1182          is_sufficiently_quiet = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy);
1183       }
1184    }
1185
1186    if (is_silence || (is_noise && is_sufficiently_quiet))
1187    {
1188       /* The number of consecutive DTX frames should be within the allowed bounds */
1189       (*nb_no_activity_frames)++;
1190
1191       if (*nb_no_activity_frames > NB_SPEECH_FRAMES_BEFORE_DTX)
1192       {
1193          if (*nb_no_activity_frames <= (NB_SPEECH_FRAMES_BEFORE_DTX + MAX_CONSECUTIVE_DTX))
1194             /* Valid frame for DTX! */
1195             return 1;
1196          else
1197             (*nb_no_activity_frames) = NB_SPEECH_FRAMES_BEFORE_DTX;
1198       }
1199    } else
1200       (*nb_no_activity_frames) = 0;
1201
1202    return 0;
1203 }
1204
1205 #endif
1206
1207 static opus_int32 encode_multiframe_packet(OpusEncoder *st,
1208                                            const opus_val16 *pcm,
1209                                            int nb_frames,
1210                                            int frame_size,
1211                                            unsigned char *data,
1212                                            opus_int32 out_data_bytes,
1213                                            int to_celt,
1214                                            int lsb_depth,
1215                                            int float_api)
1216 {
1217    int i;
1218    int ret = 0;
1219    VARDECL(unsigned char, tmp_data);
1220    int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1221    VARDECL(OpusRepacketizer, rp);
1222    int max_header_bytes;
1223    opus_int32 bytes_per_frame;
1224    opus_int32 cbr_bytes;
1225    opus_int32 repacketize_len;
1226    int tmp_len;
1227    ALLOC_STACK;
1228
1229    /* Worst cases:
1230     * 2 frames: Code 2 with different compressed sizes
1231     * >2 frames: Code 3 VBR */
1232    max_header_bytes = nb_frames == 2 ? 3 : (2+(nb_frames-1)*2);
1233
1234    if (st->use_vbr || st->user_bitrate_bps==OPUS_BITRATE_MAX)
1235       repacketize_len = out_data_bytes;
1236    else {
1237       cbr_bytes = 3*st->bitrate_bps/(3*8*st->Fs/(frame_size*nb_frames));
1238       repacketize_len = IMIN(cbr_bytes, out_data_bytes);
1239    }
1240    bytes_per_frame = IMIN(1276, 1+(repacketize_len-max_header_bytes)/nb_frames);
1241
1242    ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char);
1243    ALLOC(rp, 1, OpusRepacketizer);
1244    opus_repacketizer_init(rp);
1245
1246    bak_mode = st->user_forced_mode;
1247    bak_bandwidth = st->user_bandwidth;
1248    bak_channels = st->force_channels;
1249
1250    st->user_forced_mode = st->mode;
1251    st->user_bandwidth = st->bandwidth;
1252    st->force_channels = st->stream_channels;
1253
1254    bak_to_mono = st->silk_mode.toMono;
1255    if (bak_to_mono)
1256       st->force_channels = 1;
1257    else
1258       st->prev_channels = st->stream_channels;
1259
1260    for (i=0;i<nb_frames;i++)
1261    {
1262       st->silk_mode.toMono = 0;
1263       st->nonfinal_frame = i<(nb_frames-1);
1264
1265       /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1266       if (to_celt && i==nb_frames-1)
1267          st->user_forced_mode = MODE_CELT_ONLY;
1268
1269       tmp_len = opus_encode_native(st, pcm+i*(st->channels*frame_size), frame_size,
1270          tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth, NULL, 0, 0, 0, 0,
1271          NULL, float_api);
1272
1273       if (tmp_len<0)
1274       {
1275          RESTORE_STACK;
1276          return OPUS_INTERNAL_ERROR;
1277       }
1278
1279       ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1280
1281       if (ret<0)
1282       {
1283          RESTORE_STACK;
1284          return OPUS_INTERNAL_ERROR;
1285       }
1286    }
1287
1288    /* If encoding multiframes recursively, the true number of frames is rp->nb_frames. */
1289    ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1290
1291    if (ret<0)
1292    {
1293       RESTORE_STACK;
1294       return OPUS_INTERNAL_ERROR;
1295    }
1296
1297    /* Discard configs that were forced locally for the purpose of repacketization */
1298    st->user_forced_mode = bak_mode;
1299    st->user_bandwidth = bak_bandwidth;
1300    st->force_channels = bak_channels;
1301    st->silk_mode.toMono = bak_to_mono;
1302
1303    RESTORE_STACK;
1304    return ret;
1305 }
1306
1307 opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
1308                 unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
1309                 const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2,
1310                 int analysis_channels, downmix_func downmix, int float_api)
1311 {
1312     void *silk_enc;
1313     CELTEncoder *celt_enc;
1314     int i;
1315     int ret=0;
1316     opus_int32 nBytes;
1317     ec_enc enc;
1318     int bytes_target;
1319     int prefill=0;
1320     int start_band = 0;
1321     int redundancy = 0;
1322     int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
1323     int celt_to_silk = 0;
1324     VARDECL(opus_val16, pcm_buf);
1325     int nb_compr_bytes;
1326     int to_celt = 0;
1327     opus_uint32 redundant_rng = 0;
1328     int cutoff_Hz, hp_freq_smth1;
1329     int voice_est; /* Probability of voice in Q7 */
1330     opus_int32 equiv_rate;
1331     int delay_compensation;
1332     int frame_rate;
1333     opus_int32 max_rate; /* Max bitrate we're allowed to use */
1334     int curr_bandwidth;
1335     opus_val16 HB_gain;
1336     opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
1337     int total_buffer;
1338     opus_val16 stereo_width;
1339     const CELTMode *celt_mode;
1340 #ifndef DISABLE_FLOAT_API
1341     AnalysisInfo analysis_info;
1342     int analysis_read_pos_bak=-1;
1343     int analysis_read_subframe_bak=-1;
1344     int is_silence = 0;
1345 #endif
1346     VARDECL(opus_val16, tmp_prefill);
1347
1348     ALLOC_STACK;
1349
1350     max_data_bytes = IMIN(1276, out_data_bytes);
1351
1352     st->rangeFinal = 0;
1353     if ((!st->variable_duration && 400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
1354          50*frame_size != st->Fs && 25*frame_size != st->Fs && 50*frame_size != 3*st->Fs && 50*frame_size != 4*st->Fs &&
1355          50*frame_size != 5*st->Fs && 50*frame_size != 6*st->Fs)
1356          || (400*frame_size < st->Fs)
1357          || max_data_bytes<=0
1358          )
1359     {
1360        RESTORE_STACK;
1361        return OPUS_BAD_ARG;
1362     }
1363
1364     /* Cannot encode 100 ms in 1 byte */
1365     if (max_data_bytes==1 && st->Fs==(frame_size*10))
1366     {
1367       RESTORE_STACK;
1368       return OPUS_BUFFER_TOO_SMALL;
1369     }
1370
1371     silk_enc = (char*)st+st->silk_enc_offset;
1372     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
1373     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1374        delay_compensation = 0;
1375     else
1376        delay_compensation = st->delay_compensation;
1377
1378     lsb_depth = IMIN(lsb_depth, st->lsb_depth);
1379
1380     celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode));
1381 #ifndef DISABLE_FLOAT_API
1382     analysis_info.valid = 0;
1383 #ifdef FIXED_POINT
1384     if (st->silk_mode.complexity >= 10 && st->Fs==48000)
1385 #else
1386     if (st->silk_mode.complexity >= 7 && st->Fs==48000)
1387 #endif
1388     {
1389        if (is_digital_silence(pcm, frame_size, st->channels, lsb_depth))
1390        {
1391           is_silence = 1;
1392        } else {
1393           analysis_read_pos_bak = st->analysis.read_pos;
1394           analysis_read_subframe_bak = st->analysis.read_subframe;
1395           run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
1396                 c1, c2, analysis_channels, st->Fs,
1397                 lsb_depth, downmix, &analysis_info);
1398        }
1399
1400        /* Track the peak signal energy */
1401        if (!is_silence && analysis_info.activity_probability > DTX_ACTIVITY_THRESHOLD)
1402           st->peak_signal_energy = MAX32(MULT16_32_Q15(QCONST16(0.999, 15), st->peak_signal_energy),
1403                 compute_frame_energy(pcm, frame_size, st->channels, st->arch));
1404     }
1405 #else
1406     (void)analysis_pcm;
1407     (void)analysis_size;
1408 #endif
1409
1410 #ifndef DISABLE_FLOAT_API
1411     /* Reset voice_ratio if this frame is not silent or if analysis is disabled.
1412      * Otherwise, preserve voice_ratio from the last non-silent frame */
1413     if (!is_silence)
1414       st->voice_ratio = -1;
1415
1416     st->detected_bandwidth = 0;
1417     if (analysis_info.valid)
1418     {
1419        int analysis_bandwidth;
1420        if (st->signal_type == OPUS_AUTO)
1421           st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1422
1423        analysis_bandwidth = analysis_info.bandwidth;
1424        if (analysis_bandwidth<=12)
1425           st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1426        else if (analysis_bandwidth<=14)
1427           st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1428        else if (analysis_bandwidth<=16)
1429           st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1430        else if (analysis_bandwidth<=18)
1431           st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1432        else
1433           st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1434     }
1435 #else
1436     st->voice_ratio = -1;
1437 #endif
1438
1439     if (st->channels==2 && st->force_channels!=1)
1440        stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1441     else
1442        stereo_width = 0;
1443     total_buffer = delay_compensation;
1444     st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1445
1446     frame_rate = st->Fs/frame_size;
1447     if (!st->use_vbr)
1448     {
1449        int cbrBytes;
1450        /* Multiply by 3 to make sure the division is exact. */
1451        int frame_rate6 = 6*st->Fs/frame_size;
1452        /* We need to make sure that "int" values always fit in 16 bits. */
1453        cbrBytes = IMIN( (6*st->bitrate_bps/8 + frame_rate6/2)/frame_rate6, max_data_bytes);
1454        st->bitrate_bps = cbrBytes*(opus_int32)frame_rate6*8/6;
1455        /* Make sure we provide at least one byte to avoid failing. */
1456        max_data_bytes = IMAX(1, cbrBytes);
1457     }
1458     if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8
1459        || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400)))
1460     {
1461        /*If the space is too low to do something useful, emit 'PLC' frames.*/
1462        int tocmode = st->mode;
1463        int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth;
1464        int packet_code = 0;
1465        int num_multiframes = 0;
1466
1467        if (tocmode==0)
1468           tocmode = MODE_SILK_ONLY;
1469        if (frame_rate>100)
1470           tocmode = MODE_CELT_ONLY;
1471        /* 40 ms -> 2 x 20 ms if in CELT_ONLY or HYBRID mode */
1472        if (frame_rate==25 && tocmode!=MODE_SILK_ONLY)
1473        {
1474           frame_rate = 50;
1475           packet_code = 1;
1476        }
1477
1478        /* >= 60 ms frames */
1479        if (frame_rate<=16)
1480        {
1481           /* 1 x 60 ms, 2 x 40 ms, 2 x 60 ms */
1482           if (out_data_bytes==1 || (tocmode==MODE_SILK_ONLY && frame_rate!=10))
1483           {
1484              tocmode = MODE_SILK_ONLY;
1485
1486              packet_code = frame_rate <= 12;
1487              frame_rate = frame_rate == 12 ? 25 : 16;
1488           }
1489           else
1490           {
1491              num_multiframes = 50/frame_rate;
1492              frame_rate = 50;
1493              packet_code = 3;
1494           }
1495        }
1496
1497        if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND)
1498           bw=OPUS_BANDWIDTH_WIDEBAND;
1499        else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND)
1500           bw=OPUS_BANDWIDTH_NARROWBAND;
1501        else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND)
1502           bw=OPUS_BANDWIDTH_SUPERWIDEBAND;
1503
1504        data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1505        data[0] |= packet_code;
1506
1507        ret = packet_code <= 1 ? 1 : 2;
1508
1509        max_data_bytes = IMAX(max_data_bytes, ret);
1510
1511        if (packet_code==3)
1512           data[1] = num_multiframes;
1513
1514        if (!st->use_vbr)
1515        {
1516           ret = opus_packet_pad(data, ret, max_data_bytes);
1517           if (ret == OPUS_OK)
1518              ret = max_data_bytes;
1519           else
1520              ret = OPUS_INTERNAL_ERROR;
1521        }
1522        RESTORE_STACK;
1523        return ret;
1524     }
1525     max_rate = frame_rate*max_data_bytes*8;
1526
1527     /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1528     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size,
1529           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1530
1531     if (st->signal_type == OPUS_SIGNAL_VOICE)
1532        voice_est = 127;
1533     else if (st->signal_type == OPUS_SIGNAL_MUSIC)
1534        voice_est = 0;
1535     else if (st->voice_ratio >= 0)
1536     {
1537        voice_est = st->voice_ratio*327>>8;
1538        /* For AUDIO, never be more than 90% confident of having speech */
1539        if (st->application == OPUS_APPLICATION_AUDIO)
1540           voice_est = IMIN(voice_est, 115);
1541     } else if (st->application == OPUS_APPLICATION_VOIP)
1542        voice_est = 115;
1543     else
1544        voice_est = 48;
1545
1546     if (st->force_channels!=OPUS_AUTO && st->channels == 2)
1547     {
1548         st->stream_channels = st->force_channels;
1549     } else {
1550 #ifdef FUZZING
1551        /* Random mono/stereo decision */
1552        if (st->channels == 2 && (rand()&0x1F)==0)
1553           st->stream_channels = 3-st->stream_channels;
1554 #else
1555        /* Rate-dependent mono-stereo decision */
1556        if (st->channels == 2)
1557        {
1558           opus_int32 stereo_threshold;
1559           stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14);
1560           if (st->stream_channels == 2)
1561              stereo_threshold -= 1000;
1562           else
1563              stereo_threshold += 1000;
1564           st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1565        } else {
1566           st->stream_channels = st->channels;
1567        }
1568 #endif
1569     }
1570     /* Update equivalent rate for channels decision. */
1571     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1572           st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1573
1574     /* Mode selection depending on application and signal type */
1575     if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
1576     {
1577        st->mode = MODE_CELT_ONLY;
1578     } else if (st->user_forced_mode == OPUS_AUTO)
1579     {
1580 #ifdef FUZZING
1581        /* Random mode switching */
1582        if ((rand()&0xF)==0)
1583        {
1584           if ((rand()&0x1)==0)
1585              st->mode = MODE_CELT_ONLY;
1586           else
1587              st->mode = MODE_SILK_ONLY;
1588        } else {
1589           if (st->prev_mode==MODE_CELT_ONLY)
1590              st->mode = MODE_CELT_ONLY;
1591           else
1592              st->mode = MODE_SILK_ONLY;
1593        }
1594 #else
1595        opus_int32 mode_voice, mode_music;
1596        opus_int32 threshold;
1597
1598        /* Interpolate based on stereo width */
1599        mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])
1600              + MULT16_32_Q15(stereo_width,mode_thresholds[1][0]));
1601        mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])
1602              + MULT16_32_Q15(stereo_width,mode_thresholds[1][1]));
1603        /* Interpolate based on speech/music probability */
1604        threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14);
1605        /* Bias towards SILK for VoIP because of some useful features */
1606        if (st->application == OPUS_APPLICATION_VOIP)
1607           threshold += 8000;
1608
1609        /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/
1610        /* Hysteresis */
1611        if (st->prev_mode == MODE_CELT_ONLY)
1612            threshold -= 4000;
1613        else if (st->prev_mode>0)
1614            threshold += 4000;
1615
1616        st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY;
1617
1618        /* When FEC is enabled and there's enough packet loss, use SILK */
1619        if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1620           st->mode = MODE_SILK_ONLY;
1621        /* When encoding voice and DTX is enabled but the generalized DTX cannot be used,
1622           because of complexity and sampling frequency settings, switch to SILK DTX and
1623           set the encoder to SILK mode */
1624 #ifndef DISABLE_FLOAT_API
1625        st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence);
1626 #else
1627        st->silk_mode.useDTX = st->use_dtx;
1628 #endif
1629        if (st->silk_mode.useDTX && voice_est > 100)
1630           st->mode = MODE_SILK_ONLY;
1631 #endif
1632
1633        /* If max_data_bytes represents less than 6 kb/s, switch to CELT-only mode */
1634        if (max_data_bytes < (frame_rate > 50 ? 9000 : 6000)*frame_size / (st->Fs * 8))
1635           st->mode = MODE_CELT_ONLY;
1636     } else {
1637        st->mode = st->user_forced_mode;
1638     }
1639
1640     /* Override the chosen mode to make sure we meet the requested frame size */
1641     if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100)
1642        st->mode = MODE_CELT_ONLY;
1643     if (st->lfe)
1644        st->mode = MODE_CELT_ONLY;
1645
1646     if (st->prev_mode > 0 &&
1647         ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) ||
1648     (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)))
1649     {
1650         redundancy = 1;
1651         celt_to_silk = (st->mode != MODE_CELT_ONLY);
1652         if (!celt_to_silk)
1653         {
1654             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
1655             if (frame_size >= st->Fs/100)
1656             {
1657                 st->mode = st->prev_mode;
1658                 to_celt = 1;
1659             } else {
1660                 redundancy=0;
1661             }
1662         }
1663     }
1664
1665     /* When encoding multiframes, we can ask for a switch to CELT only in the last frame. This switch
1666      * is processed above as the requested mode shouldn't interrupt stereo->mono transition. */
1667     if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1668           && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY)
1669     {
1670        /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1671        st->silk_mode.toMono = 1;
1672        st->stream_channels = 2;
1673     } else {
1674        st->silk_mode.toMono = 0;
1675     }
1676
1677     /* Update equivalent rate with mode decision. */
1678     equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size,
1679           st->use_vbr, st->mode, st->silk_mode.complexity, st->silk_mode.packetLossPercentage);
1680
1681     /* For the first frame at a new SILK bandwidth */
1682     if (st->silk_bw_switch)
1683     {
1684        redundancy = 1;
1685        celt_to_silk = 1;
1686        st->silk_bw_switch = 0;
1687        prefill=1;
1688     }
1689
1690     if (redundancy)
1691     {
1692        /* Fair share of the max size allowed */
1693        redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
1694        /* For VBR, target the actual bitrate (subject to the limit above) */
1695        if (st->use_vbr)
1696           redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
1697     }
1698
1699     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
1700     {
1701         silk_EncControlStruct dummy;
1702         silk_InitEncoder( silk_enc, st->arch, &dummy);
1703         prefill=1;
1704     }
1705
1706     /* Automatic (rate-dependent) bandwidth selection */
1707     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
1708     {
1709         const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds;
1710         opus_int32 bandwidth_thresholds[8];
1711         int bandwidth = OPUS_BANDWIDTH_FULLBAND;
1712
1713         if (st->channels==2 && st->force_channels!=1)
1714         {
1715            voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1716            music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1717         } else {
1718            voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1719            music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1720         }
1721         /* Interpolate bandwidth thresholds depending on voice estimation */
1722         for (i=0;i<8;i++)
1723         {
1724            bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1725                     + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1726         }
1727         do {
1728             int threshold, hysteresis;
1729             threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)];
1730             hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1];
1731             if (!st->first)
1732             {
1733                 if (st->auto_bandwidth >= bandwidth)
1734                     threshold -= hysteresis;
1735                 else
1736                     threshold += hysteresis;
1737             }
1738             if (equiv_rate >= threshold)
1739                 break;
1740         } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND);
1741         st->bandwidth = st->auto_bandwidth = bandwidth;
1742         /* Prevents any transition to SWB/FB until the SILK layer has fully
1743            switched to WB mode and turned the variable LP filter off */
1744         if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1745             st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1746     }
1747
1748     if (st->bandwidth>st->max_bandwidth)
1749        st->bandwidth = st->max_bandwidth;
1750
1751     if (st->user_bandwidth != OPUS_AUTO)
1752         st->bandwidth = st->user_bandwidth;
1753
1754     /* This prevents us from using hybrid at unsafe CBR/max rates */
1755     if (st->mode != MODE_CELT_ONLY && max_rate < 15000)
1756     {
1757        st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND);
1758     }
1759
1760     /* Prevents Opus from wasting bits on frequencies that are above
1761        the Nyquist rate of the input signal */
1762     if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND)
1763         st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1764     if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1765         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1766     if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND)
1767         st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1768     if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND)
1769         st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1770 #ifndef DISABLE_FLOAT_API
1771     /* Use detected bandwidth to reduce the encoded bandwidth. */
1772     if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO)
1773     {
1774        int min_detected_bandwidth;
1775        /* Makes bandwidth detection more conservative just in case the detector
1776           gets it wrong when we could have coded a high bandwidth transparently.
1777           When operating in SILK/hybrid mode, we don't go below wideband to avoid
1778           more complicated switches that require redundancy. */
1779        if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1780           min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1781        else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY)
1782           min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
1783        else if (equiv_rate <= 30000*st->stream_channels)
1784           min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1785        else if (equiv_rate <= 44000*st->stream_channels)
1786           min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND;
1787        else
1788           min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND;
1789
1790        st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth);
1791        st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth);
1792     }
1793 #endif
1794     st->silk_mode.LBRR_coded = decide_fec(st->silk_mode.useInBandFEC, st->silk_mode.packetLossPercentage,
1795           st->silk_mode.LBRR_coded, st->mode, &st->bandwidth, equiv_rate);
1796     celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth));
1797
1798     /* CELT mode doesn't support mediumband, use wideband instead */
1799     if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1800         st->bandwidth = OPUS_BANDWIDTH_WIDEBAND;
1801     if (st->lfe)
1802        st->bandwidth = OPUS_BANDWIDTH_NARROWBAND;
1803
1804     curr_bandwidth = st->bandwidth;
1805
1806     /* Chooses the appropriate mode for speech
1807        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
1808     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
1809         st->mode = MODE_HYBRID;
1810     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
1811         st->mode = MODE_SILK_ONLY;
1812
1813     /* Can't support higher than >60 ms frames, and >20 ms when in Hybrid or CELT-only modes */
1814     if ((frame_size > st->Fs/50 && (st->mode != MODE_SILK_ONLY)) || frame_size > 3*st->Fs/50)
1815     {
1816        int enc_frame_size;
1817        int nb_frames;
1818
1819        if (st->mode == MODE_SILK_ONLY)
1820        {
1821          if (frame_size == 2*st->Fs/25)  /* 80 ms -> 2x 40 ms */
1822            enc_frame_size = st->Fs/25;
1823          if (frame_size == 3*st->Fs/25)  /* 120 ms -> 2x 60 ms */
1824            enc_frame_size = 3*st->Fs/50;
1825          else                            /* 100 ms -> 5x 20 ms */
1826            enc_frame_size = st->Fs/50;
1827        }
1828        else
1829          enc_frame_size = st->Fs/50;
1830
1831        nb_frames = frame_size/enc_frame_size;
1832
1833 #ifndef DISABLE_FLOAT_API
1834        if (analysis_read_pos_bak!= -1)
1835        {
1836           st->analysis.read_pos = analysis_read_pos_bak;
1837           st->analysis.read_subframe = analysis_read_subframe_bak;
1838        }
1839 #endif
1840
1841        ret = encode_multiframe_packet(st, pcm, nb_frames, enc_frame_size, data,
1842                                       out_data_bytes, to_celt, lsb_depth, float_api);
1843
1844        RESTORE_STACK;
1845        return ret;
1846     }
1847
1848     /* If we decided to go with CELT, make sure redundancy is off, no matter what
1849        we decided earlier. */
1850     if (st->mode == MODE_CELT_ONLY)
1851     {
1852         redundancy = 0;
1853         redundancy_bytes = 0;
1854     }
1855
1856     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1857     bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
1858
1859     data += 1;
1860
1861     ec_enc_init(&enc, data, max_data_bytes-1);
1862
1863     ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16);
1864     OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels);
1865
1866     if (st->mode == MODE_CELT_ONLY)
1867        hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
1868     else
1869        hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1870
1871     st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,
1872           hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) );
1873
1874     /* convert from log scale to Hertz */
1875     cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) );
1876
1877     if (st->application == OPUS_APPLICATION_VOIP)
1878     {
1879        hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1880     } else {
1881        dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1882     }
1883 #ifndef FIXED_POINT
1884     if (float_api)
1885     {
1886        opus_val32 sum;
1887        sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch);
1888        /* This should filter out both NaNs and ridiculous signals that could
1889           cause NaNs further down. */
1890        if (!(sum < 1e9f) || celt_isnan(sum))
1891        {
1892           OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels);
1893           st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0;
1894        }
1895     }
1896 #endif
1897
1898
1899     /* SILK processing */
1900     HB_gain = Q15ONE;
1901     if (st->mode != MODE_CELT_ONLY)
1902     {
1903         opus_int32 total_bitRate, celt_rate;
1904 #ifdef FIXED_POINT
1905        const opus_int16 *pcm_silk;
1906 #else
1907        VARDECL(opus_int16, pcm_silk);
1908        ALLOC(pcm_silk, st->channels*frame_size, opus_int16);
1909 #endif
1910
1911         /* Distribute bits between SILK and CELT */
1912         total_bitRate = 8 * bytes_target * frame_rate;
1913         if( st->mode == MODE_HYBRID ) {
1914             /* Base rate for SILK */
1915             st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate,
1916                   curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
1917             if (!st->energy_masking)
1918             {
1919                /* Increasingly attenuate high band when it gets allocated fewer bits */
1920                celt_rate = total_bitRate - st->silk_mode.bitRate;
1921                HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1);
1922             }
1923         } else {
1924             /* SILK gets all bits */
1925             st->silk_mode.bitRate = total_bitRate;
1926         }
1927
1928         /* Surround masking for SILK */
1929         if (st->energy_masking && st->use_vbr && !st->lfe)
1930         {
1931            opus_val32 mask_sum=0;
1932            opus_val16 masking_depth;
1933            opus_int32 rate_offset;
1934            int c;
1935            int end = 17;
1936            opus_int16 srate = 16000;
1937            if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
1938            {
1939               end = 13;
1940               srate = 8000;
1941            } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)
1942            {
1943               end = 15;
1944               srate = 12000;
1945            }
1946            for (c=0;c<st->channels;c++)
1947            {
1948               for(i=0;i<end;i++)
1949               {
1950                  opus_val16 mask;
1951                  mask = MAX16(MIN16(st->energy_masking[21*c+i],
1952                         QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1953                  if (mask > 0)
1954                     mask = HALF16(mask);
1955                  mask_sum += mask;
1956               }
1957            }
1958            /* Conservative rate reduction, we cut the masking in half */
1959            masking_depth = mask_sum / end*st->channels;
1960            masking_depth += QCONST16(.2f, DB_SHIFT);
1961            rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT);
1962            rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3);
1963            /* Split the rate change between the SILK and CELT part for hybrid. */
1964            if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND)
1965               st->silk_mode.bitRate += 3*rate_offset/5;
1966            else
1967               st->silk_mode.bitRate += rate_offset;
1968            bytes_target += rate_offset * frame_size / (8 * st->Fs);
1969         }
1970
1971         st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1972         st->silk_mode.nChannelsAPI = st->channels;
1973         st->silk_mode.nChannelsInternal = st->stream_channels;
1974         if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
1975             st->silk_mode.desiredInternalSampleRate = 8000;
1976         } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
1977             st->silk_mode.desiredInternalSampleRate = 12000;
1978         } else {
1979             silk_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1980             st->silk_mode.desiredInternalSampleRate = 16000;
1981         }
1982         if( st->mode == MODE_HYBRID ) {
1983             /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1984             st->silk_mode.minInternalSampleRate = 16000;
1985         } else {
1986             st->silk_mode.minInternalSampleRate = 8000;
1987         }
1988
1989         st->silk_mode.maxInternalSampleRate = 16000;
1990         if (st->mode == MODE_SILK_ONLY)
1991         {
1992            opus_int32 effective_max_rate = max_rate;
1993            if (frame_rate > 50)
1994               effective_max_rate = effective_max_rate*2/3;
1995            if (effective_max_rate < 8000)
1996            {
1997               st->silk_mode.maxInternalSampleRate = 12000;
1998               st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate);
1999            }
2000            if (effective_max_rate < 7000)
2001            {
2002               st->silk_mode.maxInternalSampleRate = 8000;
2003               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
2004            }
2005         }
2006
2007         st->silk_mode.useCBR = !st->use_vbr;
2008
2009         /* Call SILK encoder for the low band */
2010
2011         /* Max bits for SILK, counting ToC, redundancy bytes, and optionally redundancy. */
2012         st->silk_mode.maxBits = IMIN(1275, max_data_bytes-1-redundancy_bytes)*8;
2013         if (redundancy)
2014         {
2015            /* Counting 1 bit for redundancy position and 20 bits for flag+size (only for hybrid). */
2016            st->silk_mode.maxBits -= 1;
2017            if (st->mode == MODE_HYBRID)
2018               st->silk_mode.maxBits -= 20;
2019         }
2020         if (st->silk_mode.useCBR)
2021         {
2022            if (st->mode == MODE_HYBRID)
2023            {
2024               st->silk_mode.maxBits = IMIN(st->silk_mode.maxBits, st->silk_mode.bitRate * frame_size / st->Fs);
2025            }
2026         } else {
2027            /* Constrained VBR. */
2028            if (st->mode == MODE_HYBRID)
2029            {
2030               /* Compute SILK bitrate corresponding to the max total bits available */
2031               opus_int32 maxBitRate = compute_silk_rate_for_hybrid(st->silk_mode.maxBits*st->Fs / frame_size,
2032                     curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded);
2033               st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs;
2034            }
2035         }
2036
2037         if (prefill)
2038         {
2039             opus_int32 zero=0;
2040             int prefill_offset;
2041             /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
2042                a discontinuity. The exact location is what we need to avoid leaving any "gap"
2043                in the audio when mixing with the redundant CELT frame. Here we can afford to
2044                overwrite st->delay_buffer because the only thing that uses it before it gets
2045                rewritten is tmp_prefill[] and even then only the part after the ramp really
2046                gets used (rather than sent to the encoder and discarded) */
2047             prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
2048             gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
2049                   0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
2050             OPUS_CLEAR(st->delay_buffer, prefill_offset);
2051 #ifdef FIXED_POINT
2052             pcm_silk = st->delay_buffer;
2053 #else
2054             for (i=0;i<st->encoder_buffer*st->channels;i++)
2055                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
2056 #endif
2057             silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, 1 );
2058         }
2059
2060 #ifdef FIXED_POINT
2061         pcm_silk = pcm_buf+total_buffer*st->channels;
2062 #else
2063         for (i=0;i<frame_size*st->channels;i++)
2064             pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
2065 #endif
2066         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
2067         if( ret ) {
2068             /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
2069             /* Handle error */
2070            RESTORE_STACK;
2071            return OPUS_INTERNAL_ERROR;
2072         }
2073
2074         /* Extract SILK internal bandwidth for signaling in first byte */
2075         if( st->mode == MODE_SILK_ONLY ) {
2076             if( st->silk_mode.internalSampleRate == 8000 ) {
2077                curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND;
2078             } else if( st->silk_mode.internalSampleRate == 12000 ) {
2079                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
2080             } else if( st->silk_mode.internalSampleRate == 16000 ) {
2081                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
2082             }
2083         } else {
2084             silk_assert( st->silk_mode.internalSampleRate == 16000 );
2085         }
2086
2087         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady && !st->nonfinal_frame;
2088
2089         if (nBytes==0)
2090         {
2091            st->rangeFinal = 0;
2092            data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2093            RESTORE_STACK;
2094            return 1;
2095         }
2096
2097         /* FIXME: How do we allocate the redundancy for CBR? */
2098         if (st->silk_mode.opusCanSwitch)
2099         {
2100            redundancy = 1;
2101            celt_to_silk = 0;
2102            st->silk_bw_switch = 1;
2103         }
2104     }
2105
2106     /* CELT processing */
2107     {
2108         int endband=21;
2109
2110         switch(curr_bandwidth)
2111         {
2112             case OPUS_BANDWIDTH_NARROWBAND:
2113                 endband = 13;
2114                 break;
2115             case OPUS_BANDWIDTH_MEDIUMBAND:
2116             case OPUS_BANDWIDTH_WIDEBAND:
2117                 endband = 17;
2118                 break;
2119             case OPUS_BANDWIDTH_SUPERWIDEBAND:
2120                 endband = 19;
2121                 break;
2122             case OPUS_BANDWIDTH_FULLBAND:
2123                 endband = 21;
2124                 break;
2125         }
2126         celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband));
2127         celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels));
2128     }
2129     celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2130     if (st->mode != MODE_SILK_ONLY)
2131     {
2132         opus_val32 celt_pred=2;
2133         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2134         /* We may still decide to disable prediction later */
2135         if (st->silk_mode.reducedDependency)
2136            celt_pred = 0;
2137         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred));
2138
2139         if (st->mode == MODE_HYBRID)
2140         {
2141             int len;
2142
2143             len = (ec_tell(&enc)+7)>>3;
2144             if (redundancy)
2145                len += st->mode == MODE_HYBRID ? 3 : 1;
2146             if( st->use_vbr ) {
2147                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2148                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2149                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0));
2150             } else {
2151                 /* check if SILK used up too much */
2152                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
2153             }
2154         } else {
2155             if (st->use_vbr)
2156             {
2157                 opus_int32 bonus=0;
2158 #ifndef DISABLE_FLOAT_API
2159                 if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != st->Fs/50)
2160                 {
2161                    bonus = (60*st->stream_channels+40)*(st->Fs/frame_size-50);
2162                    if (analysis_info.valid)
2163                       bonus = (opus_int32)(bonus*(1.f+.5f*analysis_info.tonality));
2164                 }
2165 #endif
2166                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
2167                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
2168                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus));
2169                 nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
2170             } else {
2171                 nb_compr_bytes = bytes_target;
2172             }
2173         }
2174
2175     } else {
2176         nb_compr_bytes = 0;
2177     }
2178
2179     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
2180     if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0)
2181     {
2182        OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400);
2183     }
2184
2185     if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0)
2186     {
2187        OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer));
2188        OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)],
2189              &pcm_buf[0],
2190              (frame_size+total_buffer)*st->channels);
2191     } else {
2192        OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels);
2193     }
2194     /* gain_fade() and stereo_fade() need to be after the buffer copying
2195        because we don't want any of this to affect the SILK part */
2196     if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) {
2197        gain_fade(pcm_buf, pcm_buf,
2198              st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
2199     }
2200     st->prev_HB_gain = HB_gain;
2201     if (st->mode != MODE_HYBRID || st->stream_channels==1)
2202        st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2*IMAX(0,equiv_rate-24000));
2203     if( !st->energy_masking && st->channels == 2 ) {
2204         /* Apply stereo width reduction (at low bitrates) */
2205         if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
2206             opus_val16 g1, g2;
2207             g1 = st->hybrid_stereo_width_Q14;
2208             g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
2209 #ifdef FIXED_POINT
2210             g1 = g1==16384 ? Q15ONE : SHL16(g1,1);
2211             g2 = g2==16384 ? Q15ONE : SHL16(g2,1);
2212 #else
2213             g1 *= (1.f/16384);
2214             g2 *= (1.f/16384);
2215 #endif
2216             stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
2217                   frame_size, st->channels, celt_mode->window, st->Fs);
2218             st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
2219         }
2220     }
2221
2222     if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1))
2223     {
2224         /* For SILK mode, the redundancy is inferred from the length */
2225         if (st->mode == MODE_HYBRID && (redundancy || ec_tell(&enc)+37 <= 8*nb_compr_bytes))
2226            ec_enc_bit_logp(&enc, redundancy, 12);
2227         if (redundancy)
2228         {
2229             int max_redundancy;
2230             ec_enc_bit_logp(&enc, celt_to_silk, 1);
2231             if (st->mode == MODE_HYBRID)
2232                max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
2233             else
2234                max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
2235             /* Target the same bit-rate for redundancy as for the rest,
2236                up to a max of 257 bytes */
2237             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
2238             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
2239             if (st->mode == MODE_HYBRID)
2240                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
2241         }
2242     } else {
2243         redundancy = 0;
2244     }
2245
2246     if (!redundancy)
2247     {
2248        st->silk_bw_switch = 0;
2249        redundancy_bytes = 0;
2250     }
2251     if (st->mode != MODE_CELT_ONLY)start_band=17;
2252
2253     if (st->mode == MODE_SILK_ONLY)
2254     {
2255         ret = (ec_tell(&enc)+7)>>3;
2256         ec_enc_done(&enc);
2257         nb_compr_bytes = ret;
2258     } else {
2259        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
2260        ec_enc_shrink(&enc, nb_compr_bytes);
2261     }
2262
2263 #ifndef DISABLE_FLOAT_API
2264     if (redundancy || st->mode != MODE_SILK_ONLY)
2265        celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info));
2266 #endif
2267     if (st->mode == MODE_HYBRID) {
2268        SILKInfo info;
2269        info.signalType = st->silk_mode.signalType;
2270        info.offset = st->silk_mode.offset;
2271        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info));
2272     } else {
2273        celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO((SILKInfo*)NULL));
2274     }
2275
2276     /* 5 ms redundant frame for CELT->SILK */
2277     if (redundancy && celt_to_silk)
2278     {
2279         int err;
2280         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2281         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2282         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2283         err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL);
2284         if (err < 0)
2285         {
2286            RESTORE_STACK;
2287            return OPUS_INTERNAL_ERROR;
2288         }
2289         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2290         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2291     }
2292
2293     celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band));
2294
2295     if (st->mode != MODE_SILK_ONLY)
2296     {
2297         if (st->mode != st->prev_mode && st->prev_mode > 0)
2298         {
2299            unsigned char dummy[2];
2300            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2301
2302            /* Prefilling */
2303            celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL);
2304            celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2305         }
2306         /* If false, we already busted the budget and we'll end up with a "PLC packet" */
2307         if (ec_tell(&enc) <= 8*nb_compr_bytes)
2308         {
2309            /* Set the bitrate again if it was overridden in the redundancy code above*/
2310            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2311               celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate));
2312            celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr));
2313            ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc);
2314            if (ret < 0)
2315            {
2316               RESTORE_STACK;
2317               return OPUS_INTERNAL_ERROR;
2318            }
2319            /* Put CELT->SILK redundancy data in the right place. */
2320            if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr)
2321            {
2322               OPUS_MOVE(data+ret, data+nb_compr_bytes, redundancy_bytes);
2323               nb_compr_bytes = nb_compr_bytes+redundancy_bytes;
2324            }
2325         }
2326     }
2327
2328     /* 5 ms redundant frame for SILK->CELT */
2329     if (redundancy && !celt_to_silk)
2330     {
2331         int err;
2332         unsigned char dummy[2];
2333         int N2, N4;
2334         N2 = st->Fs/200;
2335         N4 = st->Fs/400;
2336
2337         celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2338         celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0));
2339         celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0));
2340         celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0));
2341         celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX));
2342
2343         if (st->mode == MODE_HYBRID)
2344         {
2345            /* Shrink packet to what the encoder actually used. */
2346            nb_compr_bytes = ret;
2347            ec_enc_shrink(&enc, nb_compr_bytes);
2348         }
2349         /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
2350         celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL);
2351
2352         err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL);
2353         if (err < 0)
2354         {
2355            RESTORE_STACK;
2356            return OPUS_INTERNAL_ERROR;
2357         }
2358         celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng));
2359     }
2360
2361
2362
2363     /* Signalling the mode in the first byte */
2364     data--;
2365     data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2366
2367     st->rangeFinal = enc.rng ^ redundant_rng;
2368
2369     if (to_celt)
2370         st->prev_mode = MODE_CELT_ONLY;
2371     else
2372         st->prev_mode = st->mode;
2373     st->prev_channels = st->stream_channels;
2374     st->prev_framesize = frame_size;
2375
2376     st->first = 0;
2377
2378     /* DTX decision */
2379 #ifndef DISABLE_FLOAT_API
2380     if (st->use_dtx && (analysis_info.valid || is_silence))
2381     {
2382        if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames,
2383              st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch))
2384        {
2385           st->rangeFinal = 0;
2386           data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
2387           RESTORE_STACK;
2388           return 1;
2389        }
2390     }
2391 #endif
2392
2393     /* In the unlikely case that the SILK encoder busted its target, tell
2394        the decoder to call the PLC */
2395     if (ec_tell(&enc) > (max_data_bytes-1)*8)
2396     {
2397        if (max_data_bytes < 2)
2398        {
2399           RESTORE_STACK;
2400           return OPUS_BUFFER_TOO_SMALL;
2401        }
2402        data[1] = 0;
2403        ret = 1;
2404        st->rangeFinal = 0;
2405     } else if (st->mode==MODE_SILK_ONLY&&!redundancy)
2406     {
2407        /*When in LPC only mode it's perfectly
2408          reasonable to strip off trailing zero bytes as
2409          the required range decoder behavior is to
2410          fill these in. This can't be done when the MDCT
2411          modes are used because the decoder needs to know
2412          the actual length for allocation purposes.*/
2413        while(ret>2&&data[ret]==0)ret--;
2414     }
2415     /* Count ToC and redundancy */
2416     ret += 1+redundancy_bytes;
2417     if (!st->use_vbr)
2418     {
2419        if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK)
2420
2421        {
2422           RESTORE_STACK;
2423           return OPUS_INTERNAL_ERROR;
2424        }
2425        ret = max_data_bytes;
2426     }
2427     RESTORE_STACK;
2428     return ret;
2429 }
2430
2431 #ifdef FIXED_POINT
2432
2433 #ifndef DISABLE_FLOAT_API
2434 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2435       unsigned char *data, opus_int32 max_data_bytes)
2436 {
2437    int i, ret;
2438    int frame_size;
2439    int delay_compensation;
2440    VARDECL(opus_int16, in);
2441    ALLOC_STACK;
2442
2443    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2444       delay_compensation = 0;
2445    else
2446       delay_compensation = st->delay_compensation;
2447    frame_size = compute_frame_size(pcm, analysis_frame_size,
2448          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2449          delay_compensation, downmix_float, st->analysis.subframe_mem);
2450
2451    ALLOC(in, frame_size*st->channels, opus_int16);
2452
2453    for (i=0;i<frame_size*st->channels;i++)
2454       in[i] = FLOAT2INT16(pcm[i]);
2455    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2456                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2457    RESTORE_STACK;
2458    return ret;
2459 }
2460 #endif
2461
2462 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2463                 unsigned char *data, opus_int32 out_data_bytes)
2464 {
2465    int frame_size;
2466    int delay_compensation;
2467    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2468       delay_compensation = 0;
2469    else
2470       delay_compensation = st->delay_compensation;
2471    frame_size = compute_frame_size(pcm, analysis_frame_size,
2472          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2473          delay_compensation, downmix_int
2474 #ifndef DISABLE_FLOAT_API
2475          , st->analysis.subframe_mem
2476 #endif
2477          );
2478    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16,
2479                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2480 }
2481
2482 #else
2483 opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size,
2484       unsigned char *data, opus_int32 max_data_bytes)
2485 {
2486    int i, ret;
2487    int frame_size;
2488    int delay_compensation;
2489    VARDECL(float, in);
2490    ALLOC_STACK;
2491
2492    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2493       delay_compensation = 0;
2494    else
2495       delay_compensation = st->delay_compensation;
2496    frame_size = compute_frame_size(pcm, analysis_frame_size,
2497          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2498          delay_compensation, downmix_int, st->analysis.subframe_mem);
2499
2500    ALLOC(in, frame_size*st->channels, float);
2501
2502    for (i=0;i<frame_size*st->channels;i++)
2503       in[i] = (1.0f/32768)*pcm[i];
2504    ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16,
2505                             pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0);
2506    RESTORE_STACK;
2507    return ret;
2508 }
2509 opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size,
2510                       unsigned char *data, opus_int32 out_data_bytes)
2511 {
2512    int frame_size;
2513    int delay_compensation;
2514    if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2515       delay_compensation = 0;
2516    else
2517       delay_compensation = st->delay_compensation;
2518    frame_size = compute_frame_size(pcm, analysis_frame_size,
2519          st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2520          delay_compensation, downmix_float, st->analysis.subframe_mem);
2521    return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2522                              pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1);
2523 }
2524 #endif
2525
2526
2527 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2528 {
2529     int ret;
2530     CELTEncoder *celt_enc;
2531     va_list ap;
2532
2533     ret = OPUS_OK;
2534     va_start(ap, request);
2535
2536     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
2537
2538     switch (request)
2539     {
2540         case OPUS_SET_APPLICATION_REQUEST:
2541         {
2542             opus_int32 value = va_arg(ap, opus_int32);
2543             if (   (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO
2544                  && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2545                || (!st->first && st->application != value))
2546             {
2547                ret = OPUS_BAD_ARG;
2548                break;
2549             }
2550             st->application = value;
2551         }
2552         break;
2553         case OPUS_GET_APPLICATION_REQUEST:
2554         {
2555             opus_int32 *value = va_arg(ap, opus_int32*);
2556             if (!value)
2557             {
2558                goto bad_arg;
2559             }
2560             *value = st->application;
2561         }
2562         break;
2563         case OPUS_SET_BITRATE_REQUEST:
2564         {
2565             opus_int32 value = va_arg(ap, opus_int32);
2566             if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
2567             {
2568                 if (value <= 0)
2569                     goto bad_arg;
2570                 else if (value <= 500)
2571                     value = 500;
2572                 else if (value > (opus_int32)300000*st->channels)
2573                     value = (opus_int32)300000*st->channels;
2574             }
2575             st->user_bitrate_bps = value;
2576         }
2577         break;
2578         case OPUS_GET_BITRATE_REQUEST:
2579         {
2580             opus_int32 *value = va_arg(ap, opus_int32*);
2581             if (!value)
2582             {
2583                goto bad_arg;
2584             }
2585             *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2586         }
2587         break;
2588         case OPUS_SET_FORCE_CHANNELS_REQUEST:
2589         {
2590             opus_int32 value = va_arg(ap, opus_int32);
2591             if((value<1 || value>st->channels) && value != OPUS_AUTO)
2592             {
2593                goto bad_arg;
2594             }
2595             st->force_channels = value;
2596         }
2597         break;
2598         case OPUS_GET_FORCE_CHANNELS_REQUEST:
2599         {
2600             opus_int32 *value = va_arg(ap, opus_int32*);
2601             if (!value)
2602             {
2603                goto bad_arg;
2604             }
2605             *value = st->force_channels;
2606         }
2607         break;
2608         case OPUS_SET_MAX_BANDWIDTH_REQUEST:
2609         {
2610             opus_int32 value = va_arg(ap, opus_int32);
2611             if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND)
2612             {
2613                goto bad_arg;
2614             }
2615             st->max_bandwidth = value;
2616             if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2617                 st->silk_mode.maxInternalSampleRate = 8000;
2618             } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2619                 st->silk_mode.maxInternalSampleRate = 12000;
2620             } else {
2621                 st->silk_mode.maxInternalSampleRate = 16000;
2622             }
2623         }
2624         break;
2625         case OPUS_GET_MAX_BANDWIDTH_REQUEST:
2626         {
2627             opus_int32 *value = va_arg(ap, opus_int32*);
2628             if (!value)
2629             {
2630                goto bad_arg;
2631             }
2632             *value = st->max_bandwidth;
2633         }
2634         break;
2635         case OPUS_SET_BANDWIDTH_REQUEST:
2636         {
2637             opus_int32 value = va_arg(ap, opus_int32);
2638             if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO)
2639             {
2640                goto bad_arg;
2641             }
2642             st->user_bandwidth = value;
2643             if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) {
2644                 st->silk_mode.maxInternalSampleRate = 8000;
2645             } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) {
2646                 st->silk_mode.maxInternalSampleRate = 12000;
2647             } else {
2648                 st->silk_mode.maxInternalSampleRate = 16000;
2649             }
2650         }
2651         break;
2652         case OPUS_GET_BANDWIDTH_REQUEST:
2653         {
2654             opus_int32 *value = va_arg(ap, opus_int32*);
2655             if (!value)
2656             {
2657                goto bad_arg;
2658             }
2659             *value = st->bandwidth;
2660         }
2661         break;
2662         case OPUS_SET_DTX_REQUEST:
2663         {
2664             opus_int32 value = va_arg(ap, opus_int32);
2665             if(value<0 || value>1)
2666             {
2667                goto bad_arg;
2668             }
2669             st->use_dtx = value;
2670         }
2671         break;
2672         case OPUS_GET_DTX_REQUEST:
2673         {
2674             opus_int32 *value = va_arg(ap, opus_int32*);
2675             if (!value)
2676             {
2677                goto bad_arg;
2678             }
2679             *value = st->use_dtx;
2680         }
2681         break;
2682         case OPUS_SET_COMPLEXITY_REQUEST:
2683         {
2684             opus_int32 value = va_arg(ap, opus_int32);
2685             if(value<0 || value>10)
2686             {
2687                goto bad_arg;
2688             }
2689             st->silk_mode.complexity = value;
2690             celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value));
2691         }
2692         break;
2693         case OPUS_GET_COMPLEXITY_REQUEST:
2694         {
2695             opus_int32 *value = va_arg(ap, opus_int32*);
2696             if (!value)
2697             {
2698                goto bad_arg;
2699             }
2700             *value = st->silk_mode.complexity;
2701         }
2702         break;
2703         case OPUS_SET_INBAND_FEC_REQUEST:
2704         {
2705             opus_int32 value = va_arg(ap, opus_int32);
2706             if(value<0 || value>1)
2707             {
2708                goto bad_arg;
2709             }
2710             st->silk_mode.useInBandFEC = value;
2711         }
2712         break;
2713         case OPUS_GET_INBAND_FEC_REQUEST:
2714         {
2715             opus_int32 *value = va_arg(ap, opus_int32*);
2716             if (!value)
2717             {
2718                goto bad_arg;
2719             }
2720             *value = st->silk_mode.useInBandFEC;
2721         }
2722         break;
2723         case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2724         {
2725             opus_int32 value = va_arg(ap, opus_int32);
2726             if (value < 0 || value > 100)
2727             {
2728                goto bad_arg;
2729             }
2730             st->silk_mode.packetLossPercentage = value;
2731             celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value));
2732         }
2733         break;
2734         case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
2735         {
2736             opus_int32 *value = va_arg(ap, opus_int32*);
2737             if (!value)
2738             {
2739                goto bad_arg;
2740             }
2741             *value = st->silk_mode.packetLossPercentage;
2742         }
2743         break;
2744         case OPUS_SET_VBR_REQUEST:
2745         {
2746             opus_int32 value = va_arg(ap, opus_int32);
2747             if(value<0 || value>1)
2748             {
2749                goto bad_arg;
2750             }
2751             st->use_vbr = value;
2752             st->silk_mode.useCBR = 1-value;
2753         }
2754         break;
2755         case OPUS_GET_VBR_REQUEST:
2756         {
2757             opus_int32 *value = va_arg(ap, opus_int32*);
2758             if (!value)
2759             {
2760                goto bad_arg;
2761             }
2762             *value = st->use_vbr;
2763         }
2764         break;
2765         case OPUS_SET_VOICE_RATIO_REQUEST:
2766         {
2767             opus_int32 value = va_arg(ap, opus_int32);
2768             if (value<-1 || value>100)
2769             {
2770                goto bad_arg;
2771             }
2772             st->voice_ratio = value;
2773         }
2774         break;
2775         case OPUS_GET_VOICE_RATIO_REQUEST:
2776         {
2777             opus_int32 *value = va_arg(ap, opus_int32*);
2778             if (!value)
2779             {
2780                goto bad_arg;
2781             }
2782             *value = st->voice_ratio;
2783         }
2784         break;
2785         case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2786         {
2787             opus_int32 value = va_arg(ap, opus_int32);
2788             if(value<0 || value>1)
2789             {
2790                goto bad_arg;
2791             }
2792             st->vbr_constraint = value;
2793         }
2794         break;
2795         case OPUS_GET_VBR_CONSTRAINT_REQUEST:
2796         {
2797             opus_int32 *value = va_arg(ap, opus_int32*);
2798             if (!value)
2799             {
2800                goto bad_arg;
2801             }
2802             *value = st->vbr_constraint;
2803         }
2804         break;
2805         case OPUS_SET_SIGNAL_REQUEST:
2806         {
2807             opus_int32 value = va_arg(ap, opus_int32);
2808             if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC)
2809             {
2810                goto bad_arg;
2811             }
2812             st->signal_type = value;
2813         }
2814         break;
2815         case OPUS_GET_SIGNAL_REQUEST:
2816         {
2817             opus_int32 *value = va_arg(ap, opus_int32*);
2818             if (!value)
2819             {
2820                goto bad_arg;
2821             }
2822             *value = st->signal_type;
2823         }
2824         break;
2825         case OPUS_GET_LOOKAHEAD_REQUEST:
2826         {
2827             opus_int32 *value = va_arg(ap, opus_int32*);
2828             if (!value)
2829             {
2830                goto bad_arg;
2831             }
2832             *value = st->Fs/400;
2833             if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)
2834                 *value += st->delay_compensation;
2835         }
2836         break;
2837         case OPUS_GET_SAMPLE_RATE_REQUEST:
2838         {
2839             opus_int32 *value = va_arg(ap, opus_int32*);
2840             if (!value)
2841             {
2842                goto bad_arg;
2843             }
2844             *value = st->Fs;
2845         }
2846         break;
2847         case OPUS_GET_FINAL_RANGE_REQUEST:
2848         {
2849             opus_uint32 *value = va_arg(ap, opus_uint32*);
2850             if (!value)
2851             {
2852                goto bad_arg;
2853             }
2854             *value = st->rangeFinal;
2855         }
2856         break;
2857         case OPUS_SET_LSB_DEPTH_REQUEST:
2858         {
2859             opus_int32 value = va_arg(ap, opus_int32);
2860             if (value<8 || value>24)
2861             {
2862                goto bad_arg;
2863             }
2864             st->lsb_depth=value;
2865         }
2866         break;
2867         case OPUS_GET_LSB_DEPTH_REQUEST:
2868         {
2869             opus_int32 *value = va_arg(ap, opus_int32*);
2870             if (!value)
2871             {
2872                goto bad_arg;
2873             }
2874             *value = st->lsb_depth;
2875         }
2876         break;
2877         case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2878         {
2879             opus_int32 value = va_arg(ap, opus_int32);
2880             if (value != OPUS_FRAMESIZE_ARG    && value != OPUS_FRAMESIZE_2_5_MS &&
2881                 value != OPUS_FRAMESIZE_5_MS   && value != OPUS_FRAMESIZE_10_MS  &&
2882                 value != OPUS_FRAMESIZE_20_MS  && value != OPUS_FRAMESIZE_40_MS  &&
2883                 value != OPUS_FRAMESIZE_60_MS  && value != OPUS_FRAMESIZE_80_MS  &&
2884                 value != OPUS_FRAMESIZE_100_MS && value != OPUS_FRAMESIZE_120_MS &&
2885                 value != OPUS_FRAMESIZE_VARIABLE)
2886             {
2887                goto bad_arg;
2888             }
2889             st->variable_duration = value;
2890             celt_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value));
2891         }
2892         break;
2893         case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
2894         {
2895             opus_int32 *value = va_arg(ap, opus_int32*);
2896             if (!value)
2897             {
2898                goto bad_arg;
2899             }
2900             *value = st->variable_duration;
2901         }
2902         break;
2903         case OPUS_SET_PREDICTION_DISABLED_REQUEST:
2904         {
2905            opus_int32 value = va_arg(ap, opus_int32);
2906            if (value > 1 || value < 0)
2907               goto bad_arg;
2908            st->silk_mode.reducedDependency = value;
2909         }
2910         break;
2911         case OPUS_GET_PREDICTION_DISABLED_REQUEST:
2912         {
2913            opus_int32 *value = va_arg(ap, opus_int32*);
2914            if (!value)
2915               goto bad_arg;
2916            *value = st->silk_mode.reducedDependency;
2917         }
2918         break;
2919         case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2920         {
2921             opus_int32 value = va_arg(ap, opus_int32);
2922             if(value<0 || value>1)
2923             {
2924                goto bad_arg;
2925             }
2926             celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value));
2927         }
2928         break;
2929         case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2930         {
2931             opus_int32 *value = va_arg(ap, opus_int32*);
2932             if (!value)
2933             {
2934                goto bad_arg;
2935             }
2936             celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value));
2937         }
2938         break;
2939         case OPUS_RESET_STATE:
2940         {
2941            void *silk_enc;
2942            silk_EncControlStruct dummy;
2943            char *start;
2944            silk_enc = (char*)st+st->silk_enc_offset;
2945 #ifndef DISABLE_FLOAT_API
2946            tonality_analysis_reset(&st->analysis);
2947 #endif
2948
2949            start = (char*)&st->OPUS_ENCODER_RESET_START;
2950            OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st));
2951
2952            celt_encoder_ctl(celt_enc, OPUS_RESET_STATE);
2953            silk_InitEncoder( silk_enc, st->arch, &dummy );
2954            st->stream_channels = st->channels;
2955            st->hybrid_stereo_width_Q14 = 1 << 14;
2956            st->prev_HB_gain = Q15ONE;
2957            st->first = 1;
2958            st->mode = MODE_HYBRID;
2959            st->bandwidth = OPUS_BANDWIDTH_FULLBAND;
2960            st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 );
2961         }
2962         break;
2963         case OPUS_SET_FORCE_MODE_REQUEST:
2964         {
2965             opus_int32 value = va_arg(ap, opus_int32);
2966             if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO)
2967             {
2968                goto bad_arg;
2969             }
2970             st->user_forced_mode = value;
2971         }
2972         break;
2973         case OPUS_SET_LFE_REQUEST:
2974         {
2975             opus_int32 value = va_arg(ap, opus_int32);
2976             st->lfe = value;
2977             ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value));
2978         }
2979         break;
2980         case OPUS_SET_ENERGY_MASK_REQUEST:
2981         {
2982             opus_val16 *value = va_arg(ap, opus_val16*);
2983             st->energy_masking = value;
2984             ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value));
2985         }
2986         break;
2987
2988         case CELT_GET_MODE_REQUEST:
2989         {
2990            const CELTMode ** value = va_arg(ap, const CELTMode**);
2991            if (!value)
2992            {
2993               goto bad_arg;
2994            }
2995            ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value));
2996         }
2997         break;
2998         default:
2999             /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
3000             ret = OPUS_UNIMPLEMENTED;
3001             break;
3002     }
3003     va_end(ap);
3004     return ret;
3005 bad_arg:
3006     va_end(ap);
3007     return OPUS_BAD_ARG;
3008 }
3009
3010 void opus_encoder_destroy(OpusEncoder *st)
3011 {
3012     opus_free(st);
3013 }