/root/firefox-clang/media/libopus/celt/celt

Bug Summary

File:	root/firefox-clang/media/libopus/celt/celt_encoder.c
Warning:	line 1102, column 17 The left operand of '>' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name celt_encoder.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libopus -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libopus -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D OPUS_BUILD -D OPUS_VERSION=b64041270050d5a84e22fa3df0b3166edef810ea -D USE_ALLOCA -D ENABLE_HARDENING -D OPUS_EXPORT= -D ENABLE_ASSERTIONS -D HAVE_LRINTF -D OPUS_HAVE_RTCD -D CPU_INFO_BY_ASM -D OPUS_X86_MAY_HAVE_SSE -D OPUS_X86_MAY_HAVE_SSE2 -D OPUS_X86_MAY_HAVE_SSE4_1 -D OPUS_X86_MAY_HAVE_AVX -D MOZ_HAS_MOZGLUE -I /root/firefox-clang/media/libopus -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/media/libopus -I /root/firefox-clang/media/libopus/celt -I /root/firefox-clang/media/libopus/include -I /root/firefox-clang/media/libopus/silk -I /root/firefox-clang/media/libopus/silk/fixed -I /root/firefox-clang/media/libopus/silk/float -I /root/firefox-clang/media/libopus/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-#pragma-messages -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c /root/firefox-clang/media/libopus/celt/celt_encoder.c
1/* Copyright (c) 2007-2008 CSIRO
 Copyright (c) 2007-2010 Xiph.Org Foundation
 Copyright (c) 2008 Gregory Maxwell
 Written by Jean-Marc Valin and Gregory Maxwell */
5/*
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:

 - Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.

 - Redistributions in binary form must reproduce the above copyright
 notice, this list of conditions and the following disclaimer in the
 documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28*/

30#ifdef HAVE_CONFIG_H
31#include "config.h"
32#endif

34#define CELT_ENCODER_C

36#include "cpu_support.h"
37#include "os_support.h"
38#include "mdct.h"
39#include <math.h>
40#include "celt.h"
41#include "pitch.h"
42#include "bands.h"
43#include "modes.h"
44#include "entcode.h"
45#include "quant_bands.h"
46#include "rate.h"
47#include "stack_alloc.h"
48#include "mathops.h"
49#include "float_cast.h"
50#include <stdarg.h>
51#include "celt_lpc.h"
52#include "vq.h"


55#ifndef M_PI3.14159265358979323846
56#define M_PI3.14159265358979323846 3.141592653
57#endif


60/** Encoder state
@brief Encoder state
*/
63struct OpusCustomEncoder {
 const OpusCustomMode *mode;     /**< Mode used by the encoder */
 int channels;
 int stream_channels;

 int force_intra;
 int clip;
 int disable_pf;
 int complexity;
 int upsample;
 int start, end;

 opus_int32 bitrate;
 int vbr;
 int signalling;
 int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
 int loss_rate;
 int lsb_depth;
 int lfe;
 int disable_inv;
 int arch;

 /* Everything beyond this point gets cleared on a reset */
86#define ENCODER_RESET_STARTrng rng

 opus_uint32 rng;
 int spread_decision;
 opus_val32 delayedIntra;
 int tonal_average;
 int lastCodedBands;
 int hf_average;
 int tapset_decision;

 int prefilter_period;
 opus_val16 prefilter_gain;
 int prefilter_tapset;
99#ifdef RESYNTH
 int prefilter_period_old;
 opus_val16 prefilter_gain_old;
 int prefilter_tapset_old;
103#endif
 int consec_transient;
 AnalysisInfo analysis;
 SILKInfo silk_info;

 opus_val32 preemph_memE[2];
 opus_val32 preemph_memD[2];

 /* VBR-related parameters */
 opus_int32 vbr_reservoir;
 opus_int32 vbr_drift;
 opus_int32 vbr_offset;
 opus_int32 vbr_count;
 opus_val32 overlap_max;
 opus_val16 stereo_saving;
 int intensity;
 celt_glog *energy_mask;
 celt_glog spec_avg;

122#ifdef RESYNTH
 /* +MAX_PERIOD/2 to make space for overlap */
 celt_sig syn_mem[2][2*MAX_PERIOD1024+MAX_PERIOD1024/2];
125#endif

 celt_sig in_mem[1]; /* Size = channels*mode->overlap */
 /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_MAXPERIOD */
 /* celt_glog oldBandE[],     Size = channels*mode->nbEBands */
 /* celt_glog oldLogE[],      Size = channels*mode->nbEBands */
 /* celt_glog oldLogE2[],     Size = channels*mode->nbEBands */
 /* celt_glog energyError[],  Size = channels*mode->nbEBands */
133};

135int celt_encoder_get_size(int channels)
136{
 CELTModeOpusCustomMode *mode = opus_custom_mode_create(48000, 960, NULL((void*)0));
 return opus_custom_encoder_get_size(mode, channels);
139}

141OPUS_CUSTOM_NOSTATICstatic inline int opus_custom_encoder_get_size(const CELTModeOpusCustomMode *mode, int channels)
142{
 int size = sizeof(struct CELTEncoderOpusCustomEncoder)
       + (channels*mode->overlap-1)*sizeof(celt_sig)    /* celt_sig in_mem[channels*mode->overlap]; */
       + channels*COMBFILTER_MAXPERIOD1024*sizeof(celt_sig) /* celt_sig prefilter_mem[channels*COMBFILTER_MAXPERIOD]; */
       + 4*channels*mode->nbEBands*sizeof(celt_glog);   /* celt_glog oldBandE[channels*mode->nbEBands]; */
                                                        /* celt_glog oldLogE[channels*mode->nbEBands]; */
                                                        /* celt_glog oldLogE2[channels*mode->nbEBands]; */
                                                        /* celt_glog energyError[channels*mode->nbEBands]; */
 return size;
151}

153#ifdef CUSTOM_MODES
154CELTEncoderOpusCustomEncoder *opus_custom_encoder_create(const CELTModeOpusCustomMode *mode, int channels, int *error)
155{
 int ret;
 CELTEncoderOpusCustomEncoder *st = (CELTEncoderOpusCustomEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels));
 /* init will handle the NULL case */
 ret = opus_custom_encoder_init(st, mode, channels);
 if (ret != OPUS_OK0)
 {
    opus_custom_encoder_destroy(st);
    st = NULL((void*)0);
 }
 if (error)
    *error = ret;
 return st;
168}
169#endif /* CUSTOM_MODES */

171static int opus_custom_encoder_init_arch(CELTEncoderOpusCustomEncoder *st, const CELTModeOpusCustomMode *mode,
                                       int channels, int arch)
173{
 if (channels < 0 || channels > 2)
    return OPUS_BAD_ARG-1;

 if (st==NULL((void*)0) || mode==NULL((void*)0))
    return OPUS_ALLOC_FAIL-7;

 OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels))(memset(((char*)st), 0, (opus_custom_encoder_get_size(mode, channels
))*sizeof(*((char*)st))));

 st->mode = mode;
 st->stream_channels = st->channels = channels;

 st->upsample = 1;
 st->start = 0;
 st->end = st->mode->effEBands;
 st->signalling = 1;
 st->arch = arch;

 st->constrained_vbr = 1;
 st->clip = 1;

 st->bitrate = OPUS_BITRATE_MAX-1;
 st->vbr = 0;
 st->force_intra  = 0;
 st->complexity = 5;
 st->lsb_depth=24;

 opus_custom_encoder_ctl(st, OPUS_RESET_STATE4028);

 return OPUS_OK0;
203}

205#ifdef CUSTOM_MODES
206int opus_custom_encoder_init(CELTEncoderOpusCustomEncoder *st, const CELTModeOpusCustomMode *mode, int channels)
207{
 return opus_custom_encoder_init_arch(st, mode, channels, opus_select_arch());
209}
210#endif

212int celt_encoder_init(CELTEncoderOpusCustomEncoder *st, opus_int32 sampling_rate, int channels,
                    int arch)
214{
 int ret;
 ret = opus_custom_encoder_init_arch(st,
         opus_custom_mode_create(48000, 960, NULL((void*)0)), channels, arch);
 if (ret != OPUS_OK0)
    return ret;
 st->upsample = resampling_factor(sampling_rate);
 return OPUS_OK0;
222}

224#ifdef CUSTOM_MODES
225void opus_custom_encoder_destroy(CELTEncoderOpusCustomEncoder *st)
226{
 opus_free(st);
228}
229#endif /* CUSTOM_MODES */


232static int transient_analysis(const opus_val32 * OPUS_RESTRICTrestrict in, int len, int C,
                            opus_val16 *tf_estimate, int *tf_chan, int allow_weak_transients,
                            int *weak_transient, opus_val16 tone_freq, opus_val32 toneishness)
235{
 int i;
 VARDECL(opus_val16, tmp)opus_val16 *tmp;
 opus_val32 mem0,mem1;
 int is_transient = 0;
 opus_int32 mask_metric = 0;
 int c;
 opus_val16 tf_max;
 int len2;
 /* Forward masking: 6.7 dB/ms. */
245#ifdef FIXED_POINT
 int forward_shift = 4;
247#else
 opus_val16 forward_decay = QCONST16(.0625f,15)(.0625f);
249#endif
 /* Table of 6*64/x, trained on real data to minimize the average error */
 static const unsigned char inv_table[128] = {
       255,255,156,110, 86, 70, 59, 51, 45, 40, 37, 33, 31, 28, 26, 25,
        23, 22, 21, 20, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
        12, 12, 11, 11, 11, 10, 10, 10,  9,  9,  9,  9,  9,  9,  8,  8,
         8,  8,  8,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,
         6,  6,  6,  6,  6,  6,  6,  6,  6,  5,  5,  5,  5,  5,  5,  5,
         5,  5,  5,  5,  5,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  3,  3,
         3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,
 };
 SAVE_STACK;
262#ifdef FIXED_POINT
 int in_shift = IMAX(0, celt_ilog2(1+celt_maxabs32(in, C*len))-14)((0) > (celt_ilog2(1+celt_maxabs16(in,C*len))-14) ? (0) : (
celt_ilog2(1+celt_maxabs16(in,C*len))-14));
264#endif
 ALLOC(tmp, len, opus_val16)tmp = ((opus_val16*)__builtin_alloca (sizeof(opus_val16)*(len
)));

 *weak_transient = 0;
 /* For lower bitrates, let's be more conservative and have a forward masking
    decay of 3.3 dB/ms. This avoids having to code transients at very low
    bitrate (mostly for hybrid), which can result in unstable energy and/or
    partial collapse. */
 if (allow_weak_transients)
 {
274#ifdef FIXED_POINT
    forward_shift = 5;
276#else
    forward_decay = QCONST16(.03125f,15)(.03125f);
278#endif
 }
 len2=len/2;
 for (c=0;c<C;c++)
 {
    opus_val32 mean;
    opus_int32 unmask=0;
    opus_val32 norm;
    opus_val16 maxE;
    mem0=0;
    mem1=0;
    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
    for (i=0;i<len;i++)
    {
292#ifndef FIXED_POINT
       float mem00;
294#endif
       opus_val32 x,y;
       x = SHR32(in[i+c*len],in_shift)(in[i+c*len]);
       y = ADD32(mem0, x)((mem0)+(x));
298#ifdef FIXED_POINT
       mem0 = mem1 + y - SHL32(x,1)(x);
       mem1 = x - SHR32(y,1)(y);
301#else
       /* Original code:
       mem0 = mem1 + y - 2*x;
       mem1 = x - .5f*y;
       Modified code to shorten dependency chains: */
       mem00=mem0;
       mem0 = mem0 - x + .5f*mem1;
       mem1 =  x - mem00;
309#endif
       tmp[i] = SROUND16(y, 2)(y);
       /*printf("%f ", tmp[i]);*/
    }
    /*printf("\n");*/
    /* First few samples are bad because we don't propagate the memory */
    OPUS_CLEAR(tmp, 12)(memset((tmp), 0, (12)*sizeof(*(tmp))));

317#ifdef FIXED_POINT
    /* Normalize tmp to max range */
    {
       int shift=0;
       shift = 14-celt_ilog2(MAX16(1, celt_maxabs16(tmp, len))((1) > (celt_maxabs16(tmp, len)) ? (1) : (celt_maxabs16(tmp
, len))));
       if (shift!=0)
       {
          for (i=0;i<len;i++)
             tmp[i] = SHL16(tmp[i], shift)(tmp[i]);
       }
    }
328#endif

    mean=0;
    mem0=0;
    /* Grouping by two to reduce complexity */
    /* Forward pass to compute the post-echo threshold*/
    for (i=0;i<len2;i++)
    {
       opus_val32 x2 = PSHR32(MULT16_16(tmp[2*i],tmp[2*i]) + MULT16_16(tmp[2*i+1],tmp[2*i+1]),4)(((opus_val32)(tmp[2*i])*(opus_val32)(tmp[2*i])) + ((opus_val32
)(tmp[2*i+1])*(opus_val32)(tmp[2*i+1])));
       mean += PSHR32(x2, 12)(x2);
338#ifdef FIXED_POINT
       /* FIXME: Use PSHR16() instead */
       mem0 = mem0 + PSHR32(x2-mem0,forward_shift)(x2-mem0);
       tmp[i] = PSHR32(mem0, 12)(mem0);
342#else
       mem0 = x2 + (1.f-forward_decay)*mem0;
       tmp[i] = forward_decay*mem0;
345#endif
    }

    mem0=0;
    maxE=0;
    /* Backward pass to compute the pre-echo threshold */
    for (i=len2-1;i>=0;i--)
    {
       /* Backward masking: 13.9 dB/ms. */
354#ifdef FIXED_POINT
       /* FIXME: Use PSHR16() instead */
       mem0 = mem0 + PSHR32(SHL32(tmp[i],4)-mem0,3)((tmp[i])-mem0);
       tmp[i] = PSHR32(mem0, 4)(mem0);
       maxE = MAX16(maxE, tmp[i])((maxE) > (tmp[i]) ? (maxE) : (tmp[i]));
359#else
       mem0 = tmp[i] + 0.875f*mem0;
       tmp[i] = 0.125f*mem0;
       maxE = MAX16(maxE, 0.125f*mem0)((maxE) > (0.125f*mem0) ? (maxE) : (0.125f*mem0));
363#endif
    }
    /*for (i=0;i<len2;i++)printf("%f ", tmp[i]/mean);printf("\n");*/

    /* Compute the ratio of the "frame energy" over the harmonic mean of the energy.
       This essentially corresponds to a bitrate-normalized temporal noise-to-mask
       ratio */

    /* As a compromise with the old transient detector, frame energy is the
       geometric mean of the energy and half the max */
373#ifdef FIXED_POINT
    /* Costs two sqrt() to avoid overflows */
    mean = MULT16_16(celt_sqrt(mean), celt_sqrt(MULT16_16(maxE,len2>>1)))((opus_val32)(((float)sqrt(mean)))*(opus_val32)(((float)sqrt(
((opus_val32)(maxE)*(opus_val32)(len2>>1))))));
376#else
    mean = celt_sqrt(mean * maxE*.5*len2)((float)sqrt(mean * maxE*.5*len2));
378#endif
    /* Inverse of the mean energy in Q15+6 */
    norm = SHL32(EXTEND32(len2),6+14)((len2))/ADD32(EPSILON,SHR32(mean,1))((1e-15f)+((mean)));
    /* Compute harmonic mean discarding the unreliable boundaries
       The data is smooth, so we only take 1/4th of the samples */
    unmask=0;
    /* We should never see NaNs here. If we find any, then something really bad happened and we better abort
       before it does any damage later on. If these asserts are disabled (no hardening), then the table
       lookup a few lines below (id = ...) is likely to crash dur to an out-of-bounds read. DO NOT FIX
       that crash on NaN since it could result in a worse issue later on. */
    celt_assert(!celt_isnan(tmp[0])){if (!(!((tmp[0])!=(tmp[0])))) {celt_fatal("assertion failed: "
 "!celt_isnan(tmp[0])", "/root/firefox-clang/media/libopus/celt/celt_encoder.c"
, 388);}};
    celt_assert(!celt_isnan(norm)){if (!(!((norm)!=(norm)))) {celt_fatal("assertion failed: " "!celt_isnan(norm)"
, "/root/firefox-clang/media/libopus/celt/celt_encoder.c", 389
);}};
    for (i=12;i<len2-5;i+=4)
    {
       int id;
393#ifdef FIXED_POINT
       id = MAX32(0,MIN32(127,MULT16_32_Q15(tmp[i]+EPSILON,norm)))((0) > (((127) < (((tmp[i]+1e-15f)*(norm))) ? (127) : (
((tmp[i]+1e-15f)*(norm))))) ? (0) : (((127) < (((tmp[i]+1e-15f
)*(norm))) ? (127) : (((tmp[i]+1e-15f)*(norm)))))); /* Do not round to nearest */
395#else
       id = (int)MAX32(0,MIN32(127,floor(64*norm*(tmp[i]+EPSILON))))((0) > (((127) < (floor(64*norm*(tmp[i]+1e-15f))) ? (127
) : (floor(64*norm*(tmp[i]+1e-15f))))) ? (0) : (((127) < (
floor(64*norm*(tmp[i]+1e-15f))) ? (127) : (floor(64*norm*(tmp
[i]+1e-15f)))))); /* Do not round to nearest */
397#endif
       unmask += inv_table[id];
    }
    /*printf("%d\n", unmask);*/
    /* Normalize, compensate for the 1/4th of the sample and the factor of 6 in the inverse table */
    unmask = 64*unmask*4/(6*(len2-17));
    if (unmask>mask_metric)
    {
       *tf_chan = c;
       mask_metric = unmask;
    }
 }
 is_transient = mask_metric>200;
 /* Prevent the transient detector from confusing the partial cycle of a
    very low frequency tone with a transient. */
 if (toneishness > QCONST32(.98f, 29)(.98f) && tone_freq < QCONST16(0.026f, 13)(0.026f))
    is_transient = 0;
 /* For low bitrates, define "weak transients" that need to be
    handled differently to avoid partial collapse. */
 if (allow_weak_transients && is_transient && mask_metric<600) {
    is_transient = 0;
    *weak_transient = 1;
 }
 /* Arbitrary metric for VBR boost */
 tf_max = MAX16(0,celt_sqrt(27*mask_metric)-42)((0) > (((float)sqrt(27*mask_metric))-42) ? (0) : (((float
)sqrt(27*mask_metric))-42));
 /* *tf_estimate = 1 + MIN16(1, sqrt(MAX16(0, tf_max-30))/20); */
 *tf_estimate = celt_sqrt(MAX32(0, SHL32(MULT16_16(QCONST16(0.0069,14),MIN16(163,tf_max)),14)-QCONST32(0.139,28)))((float)sqrt(((0) > ((((opus_val32)((0.0069))*(opus_val32)
(((163) < (tf_max) ? (163) : (tf_max)))))-(0.139)) ? (0) :
 ((((opus_val32)((0.0069))*(opus_val32)(((163) < (tf_max) ?
 (163) : (tf_max)))))-(0.139)))));
 /*printf("%d %f\n", tf_max, mask_metric);*/
 RESTORE_STACK;
426#ifdef FUZZING
 is_transient = rand()&0x1;
428#endif
 /*printf("%d %f %d\n", is_transient, (float)*tf_estimate, tf_max);*/
 return is_transient;
431}

433/* Looks for sudden increases of energy to decide whether we need to patch
 the transient decision */
435static int patch_transient_decision(celt_glog *newE, celt_glog *oldE, int nbEBands,
    int start, int end, int C)
437{
 int i, c;
 opus_val32 mean_diff=0;
 celt_glog spread_old[26];
 /* Apply an aggressive (-6 dB/Bark) spreading function to the old frame to
    avoid false detection caused by irrelevant bands */
 if (C==1)
 {
    spread_old[start] = oldE[start];
    for (i=start+1;i<end;i++)
       spread_old[i] = MAXG(spread_old[i-1]-GCONST(1.0f), oldE[i])((spread_old[i-1]-(1.0f)) > (oldE[i]) ? (spread_old[i-1]-(
0f)) : (oldE[i]));
 } else {
    spread_old[start] = MAXG(oldE[start],oldE[start+nbEBands])((oldE[start]) > (oldE[start+nbEBands]) ? (oldE[start]) : (
oldE[start+nbEBands]));
    for (i=start+1;i<end;i++)
       spread_old[i] = MAXG(spread_old[i-1]-GCONST(1.0f),((spread_old[i-1]-(1.0f)) > (((oldE[i]) > (oldE[i+nbEBands
]) ? (oldE[i]) : (oldE[i+nbEBands]))) ? (spread_old[i-1]-(1.0f
)) : (((oldE[i]) > (oldE[i+nbEBands]) ? (oldE[i]) : (oldE[
i+nbEBands]))))
                             MAXG(oldE[i],oldE[i+nbEBands]))((spread_old[i-1]-(1.0f)) > (((oldE[i]) > (oldE[i+nbEBands
]) ? (oldE[i]) : (oldE[i+nbEBands]))) ? (spread_old[i-1]-(1.0f
)) : (((oldE[i]) > (oldE[i+nbEBands]) ? (oldE[i]) : (oldE[
i+nbEBands]))));
 }
 for (i=end-2;i>=start;i--)
    spread_old[i] = MAXG(spread_old[i], spread_old[i+1]-GCONST(1.0f))((spread_old[i]) > (spread_old[i+1]-(1.0f)) ? (spread_old[
i]) : (spread_old[i+1]-(1.0f)));
 /* Compute mean increase */
 c=0; do {
    for (i=IMAX(2,start)((2) > (start) ? (2) : (start));i<end-1;i++)
    {
       opus_val16 x1, x2;
       x1 = MAXG(0, newE[i + c*nbEBands])((0) > (newE[i + c*nbEBands]) ? (0) : (newE[i + c*nbEBands
]));
       x2 = MAXG(0, spread_old[i])((0) > (spread_old[i]) ? (0) : (spread_old[i]));
       mean_diff = ADD32(mean_diff, MAXG(0, SUB32(x1, x2)))((mean_diff)+(((0) > (((x1)-(x2))) ? (0) : (((x1)-(x2)))))
);
    }
 } while (++c<C);
 mean_diff = DIV32(mean_diff, C*(end-1-IMAX(2,start)))(((opus_val32)(mean_diff))/(opus_val32)(C*(end-1-((2) > (start
) ? (2) : (start)))));
 /*printf("%f %f %d\n", mean_diff, max_diff, count);*/
 return mean_diff > GCONST(1.f)(1.f);
469}

471/** Apply window and compute the MDCT for all sub-frames and
  all channels in a frame */
473static void compute_mdcts(const CELTModeOpusCustomMode *mode, int shortBlocks, celt_sig * OPUS_RESTRICTrestrict in,
                        celt_sig * OPUS_RESTRICTrestrict out, int C, int CC, int LM, int upsample,
                        int arch)
476{
 const int overlap = mode->overlap;
 int N;
 int B;
 int shift;
 int i, b, c;
 if (shortBlocks)
 {
    B = shortBlocks;
    N = mode->shortMdctSize;
    shift = mode->maxLM;
 } else {
    B = 1;
    N = mode->shortMdctSize<<LM;
    shift = mode->maxLM-LM;
 }
 c=0; do {
    for (b=0;b<B;b++)
    {
       /* Interleaving the sub-frames while doing the MDCTs */
       clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N,clt_mdct_forward_c(&mode->mdct, in+c*(B*N+overlap)+b*N
, &out[b+c*N*B], mode->window, overlap, shift, B, arch
)
                        &out[b+c*N*B], mode->window, overlap, shift, B,clt_mdct_forward_c(&mode->mdct, in+c*(B*N+overlap)+b*N
, &out[b+c*N*B], mode->window, overlap, shift, B, arch
)
                        arch)clt_mdct_forward_c(&mode->mdct, in+c*(B*N+overlap)+b*N
, &out[b+c*N*B], mode->window, overlap, shift, B, arch
);
    }
 } while (++c<CC);
 if (CC==2&&C==1)
 {
    for (i=0;i<B*N;i++)
       out[i] = ADD32(HALF32(out[i]), HALF32(out[B*N+i]))(((.5f*(out[i])))+((.5f*(out[B*N+i]))));
 }
 if (upsample != 1)
 {
    c=0; do
    {
       int bound = B*N/upsample;
       for (i=0;i<bound;i++)
          out[c*B*N+i] *= upsample;
       OPUS_CLEAR(&out[c*B*N+bound], B*N-bound)(memset((&out[c*B*N+bound]), 0, (B*N-bound)*sizeof(*(&
out[c*B*N+bound]))));
    } while (++c<C);
 }
516}


519void celt_preemphasis(const opus_res * OPUS_RESTRICTrestrict pcmp, celt_sig * OPUS_RESTRICTrestrict inp,
                      int N, int CC, int upsample, const opus_val16 *coef, celt_sig *mem, int clip)
521{
 int i;
 opus_val16 coef0;
 celt_sig m;
 int Nu;

 coef0 = coef[0];
 m = *mem;

 /* Fast path for the normal 48kHz case and no clipping */
 if (coef[1] == 0 && upsample == 1 && !clip)
 {
    for (i=0;i<N;i++)
    {
       celt_sig x;
       x = RES2SIG(pcmp[CC*i])(32768.f*(pcmp[CC*i]));
       /* Apply pre-emphasis */
       inp[i] = x - m;
       m = MULT16_32_Q15(coef0, x)((coef0)*(x));
    }
    *mem = m;
    return;
 }

 Nu = N/upsample;
 if (upsample!=1)
 {
    OPUS_CLEAR(inp, N)(memset((inp), 0, (N)*sizeof(*(inp))));
 }
 for (i=0;i<Nu;i++)
    inp[i*upsample] = RES2SIG(pcmp[CC*i])(32768.f*(pcmp[CC*i]));

553#ifndef FIXED_POINT
 if (clip)
 {
    /* Clip input to avoid encoding non-portable files */
    for (i=0;i<Nu;i++)
       inp[i*upsample] = MAX32(-65536.f, MIN32(65536.f,inp[i*upsample]))((-65536.f) > (((65536.f) < (inp[i*upsample]) ? (65536.f
) : (inp[i*upsample]))) ? (-65536.f) : (((65536.f) < (inp[
i*upsample]) ? (65536.f) : (inp[i*upsample]))));
 }
560#else
 (void)clip; /* Avoids a warning about clip being unused. */
562#endif
563#ifdef CUSTOM_MODES
 if (coef[1] != 0)
 {
    opus_val16 coef1 = coef[1];
    opus_val16 coef2 = coef[2];
    for (i=0;i<N;i++)
    {
       celt_sig x, tmp;
       x = inp[i];
       /* Apply pre-emphasis */
       tmp = SHL32(MULT16_32_Q15(coef2, x), 15-SIG_SHIFT)(((coef2)*(x)));
       inp[i] = tmp + m;
       m = MULT16_32_Q15(coef1, inp[i])((coef1)*(inp[i])) - MULT16_32_Q15(coef0, tmp)((coef0)*(tmp));
    }
 } else
578#endif
 {
    for (i=0;i<N;i++)
    {
       celt_sig x;
       x = inp[i];
       /* Apply pre-emphasis */
       inp[i] = x - m;
       m = MULT16_32_Q15(coef0, x)((coef0)*(x));
    }
 }
 *mem = m;
590}



594static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, opus_val16 bias)
595{
 int i;
 opus_val32 L1;
 L1 = 0;
 for (i=0;i<N;i++)
    L1 += EXTEND32(ABS16(tmp[i]))(((float)fabs(tmp[i])));
 /* When in doubt, prefer good freq resolution */
 L1 = MAC16_32_Q15(L1, LM*bias, L1)((L1)+(LM*bias)*(L1));
 return L1;

605}

607static int tf_analysis(const CELTModeOpusCustomMode *m, int len, int isTransient,
    int *tf_res, int lambda, celt_norm *X, int N0, int LM,
    opus_val16 tf_estimate, int tf_chan, int *importance)
610{
 int i;
 VARDECL(int, metric)int *metric;
 int cost0;
 int cost1;
 VARDECL(int, path0)int *path0;
 VARDECL(int, path1)int *path1;
 VARDECL(celt_norm, tmp)celt_norm *tmp;
 VARDECL(celt_norm, tmp_1)celt_norm *tmp_1;
 int sel;
 int selcost[2];
 int tf_select=0;
 opus_val16 bias;

 SAVE_STACK;
 bias = MULT16_16_Q14(QCONST16(.04f,15), MAX16(-QCONST16(.25f,14), QCONST16(.5f,14)-tf_estimate))(((.04f))*(((-(.25f)) > ((.5f)-tf_estimate) ? (-(.25f)) : (
(.5f)-tf_estimate))));
 /*printf("%f ", bias);*/

 ALLOC(metric, len, int)metric = ((int*)__builtin_alloca (sizeof(int)*(len)));
 ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm)tmp = ((celt_norm*)__builtin_alloca (sizeof(celt_norm)*((m->
eBands[len]-m->eBands[len-1])<<LM)));
 ALLOC(tmp_1, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm)tmp_1 = ((celt_norm*)__builtin_alloca (sizeof(celt_norm)*((m->
eBands[len]-m->eBands[len-1])<<LM)));
 ALLOC(path0, len, int)path0 = ((int*)__builtin_alloca (sizeof(int)*(len)));
 ALLOC(path1, len, int)path1 = ((int*)__builtin_alloca (sizeof(int)*(len)));

 for (i=0;i<len;i++)
 {
    int k, N;
    int narrow;
    opus_val32 L1, best_L1;
    int best_level=0;
    N = (m->eBands[i+1]-m->eBands[i])<<LM;
    /* band is too narrow to be split down to LM=-1 */
    narrow = (m->eBands[i+1]-m->eBands[i])==1;
    OPUS_COPY(tmp, &X[tf_chan*N0 + (m->eBands[i]<<LM)], N)(memcpy((tmp), (&X[tf_chan*N0 + (m->eBands[i]<<LM
)]), (N)*sizeof(*(tmp)) + 0*((tmp)-(&X[tf_chan*N0 + (m->
eBands[i]<<LM)])) ));
    /* Just add the right channel if we're in stereo */
    /*if (C==2)
       for (j=0;j<N;j++)
          tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));*/
    L1 = l1_metric(tmp, N, isTransient ? LM : 0, bias);
    best_L1 = L1;
    /* Check the -1 case for transients */
    if (isTransient && !narrow)
    {
       OPUS_COPY(tmp_1, tmp, N)(memcpy((tmp_1), (tmp), (N)*sizeof(*(tmp_1)) + 0*((tmp_1)-(tmp
)) ));
       haar1(tmp_1, N>>LM, 1<<LM);
       L1 = l1_metric(tmp_1, N, LM+1, bias);
       if (L1<best_L1)
       {
          best_L1 = L1;
          best_level = -1;
       }
    }
    /*printf ("%f ", L1);*/
    for (k=0;k<LM+!(isTransient||narrow);k++)
    {
       int B;

       if (isTransient)
          B = (LM-k-1);
       else
          B = k+1;

       haar1(tmp, N>>k, 1<<k);

       L1 = l1_metric(tmp, N, B, bias);

       if (L1 < best_L1)
       {
          best_L1 = L1;
          best_level = k+1;
       }
    }
    /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
    /* metric is in Q1 to be able to select the mid-point (-0.5) for narrower bands */
    if (isTransient)
       metric[i] = 2*best_level;
    else
       metric[i] = -2*best_level;
    /* For bands that can't be split to -1, set the metric to the half-way point to avoid
       biasing the decision */
    if (narrow && (metric[i]==0 || metric[i]==-2*LM))
       metric[i]-=1;
    /*printf("%d ", metric[i]/2 + (!isTransient)*LM);*/
 }
 /*printf("\n");*/
 /* Search for the optimal tf resolution, including tf_select */
 tf_select = 0;
 for (sel=0;sel<2;sel++)
 {
    cost0 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*sel+0]);
    cost1 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*sel+1]) + (isTransient ? 0 : lambda);
    for (i=1;i<len;i++)
    {
       int curr0, curr1;
       curr0 = IMIN(cost0, cost1 + lambda)((cost0) < (cost1 + lambda) ? (cost0) : (cost1 + lambda));
       curr1 = IMIN(cost0 + lambda, cost1)((cost0 + lambda) < (cost1) ? (cost0 + lambda) : (cost1));
       cost0 = curr0 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+0]);
       cost1 = curr1 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+1]);
    }
    cost0 = IMIN(cost0, cost1)((cost0) < (cost1) ? (cost0) : (cost1));
    selcost[sel]=cost0;
 }
 /* For now, we're conservative and only allow tf_select=1 for transients.
  * If tests confirm it's useful for non-transients, we could allow it. */
 if (selcost[1]<selcost[0] && isTransient)
    tf_select=1;
 cost0 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]);
 cost1 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]) + (isTransient ? 0 : lambda);
 /* Viterbi forward pass */
 for (i=1;i<len;i++)
 {
    int curr0, curr1;
    int from0, from1;

    from0 = cost0;
    from1 = cost1 + lambda;
    if (from0 < from1)
    {
       curr0 = from0;
       path0[i]= 0;
    } else {
       curr0 = from1;
       path0[i]= 1;
    }

    from0 = cost0 + lambda;
    from1 = cost1;
    if (from0 < from1)
    {
       curr1 = from0;
       path1[i]= 0;
    } else {
       curr1 = from1;
       path1[i]= 1;
    }
    cost0 = curr0 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]);
    cost1 = curr1 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]);
 }
 tf_res[len-1] = cost0 < cost1 ? 0 : 1;
 /* Viterbi backward pass to check the decisions */
 for (i=len-2;i>=0;i--)
 {
    if (tf_res[i+1] == 1)
       tf_res[i] = path1[i+1];
    else
       tf_res[i] = path0[i+1];
 }
 /*printf("%d %f\n", *tf_sum, tf_estimate);*/
 RESTORE_STACK;
759#ifdef FUZZING
 tf_select = rand()&0x1;
 tf_res[0] = rand()&0x1;
 for (i=1;i<len;i++)
    tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
764#endif
 return tf_select;
766}

768static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
769{
 int curr, i;
 int tf_select_rsv;
 int tf_changed;
 int logp;
 opus_uint32 budget;
 opus_uint32 tell;
 budget = enc->storage*8;
 tell = ec_tell(enc);
 logp = isTransient ? 2 : 4;
 /* Reserve space to code the tf_select decision. */
 tf_select_rsv = LM>0 && tell+logp+1 <= budget;
 budget -= tf_select_rsv;
 curr = tf_changed = 0;
 for (i=start;i<end;i++)
 {
    if (tell+logp<=budget)
    {
       ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
       tell = ec_tell(enc);
       curr = tf_res[i];
       tf_changed |= curr;
    }
    else
       tf_res[i] = curr;
    logp = isTransient ? 4 : 5;
 }
 /* Only code tf_select if it would actually make a difference. */
 if (tf_select_rsv &&
       tf_select_table[LM][4*isTransient+0+tf_changed]!=
       tf_select_table[LM][4*isTransient+2+tf_changed])
    ec_enc_bit_logp(enc, tf_select, 1);
 else
    tf_select = 0;
 for (i=start;i<end;i++)
    tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
 /*for(i=0;i<end;i++)printf("%d ", isTransient ? tf_res[i] : LM+tf_res[i]);printf("\n");*/
806}


809static int alloc_trim_analysis(const CELTModeOpusCustomMode *m, const celt_norm *X,
    const celt_glog *bandLogE, int end, int LM, int C, int N0,
    AnalysisInfo *analysis, opus_val16 *stereo_saving, opus_val16 tf_estimate,
    int intensity, celt_glog surround_trim, opus_int32 equiv_rate, int arch)
813{
 int i;
 opus_val32 diff=0;
 int c;
 int trim_index;
 opus_val16 trim = QCONST16(5.f, 8)(5.f);
 opus_val16 logXC, logXC2;
 /* At low bitrate, reducing the trim seems to help. At higher bitrates, it's less
    clear what's best, so we're keeping it as it was before, at least for now. */
 if (equiv_rate < 64000) {
    trim = QCONST16(4.f, 8)(4.f);
 } else if (equiv_rate < 80000) {
    opus_int32 frac = (equiv_rate-64000) >> 10;
    trim = QCONST16(4.f, 8)(4.f) + QCONST16(1.f/16.f, 8)(1.f/16.f)*frac;
 }
 if (C==2)
 {
    opus_val16 sum = 0; /* Q10 */
    opus_val16 minXC; /* Q10 */
    /* Compute inter-channel correlation for low frequencies */
    for (i=0;i<8;i++)
    {
       opus_val32 partial;
       partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)],((*CELT_INNER_PROD_IMPL[(arch) & 7])(&X[m->eBands[
i]<<LM], &X[N0+(m->eBands[i]<<LM)], (m->
eBands[i+1]-m->eBands[i])<<LM))
             (m->eBands[i+1]-m->eBands[i])<<LM, arch)((*CELT_INNER_PROD_IMPL[(arch) & 7])(&X[m->eBands[
i]<<LM], &X[N0+(m->eBands[i]<<LM)], (m->
eBands[i+1]-m->eBands[i])<<LM));
       sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)))((sum)+(((partial))));
    }
    sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum)(((1.f/8))*(sum));
    sum = MIN16(QCONST16(1.f, 10), ABS16(sum))(((1.f)) < (((float)fabs(sum))) ? ((1.f)) : (((float)fabs(
sum))));
    minXC = sum;
    for (i=8;i<intensity;i++)
    {
       opus_val32 partial;
       partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)],((*CELT_INNER_PROD_IMPL[(arch) & 7])(&X[m->eBands[
i]<<LM], &X[N0+(m->eBands[i]<<LM)], (m->
eBands[i+1]-m->eBands[i])<<LM))
             (m->eBands[i+1]-m->eBands[i])<<LM, arch)((*CELT_INNER_PROD_IMPL[(arch) & 7])(&X[m->eBands[
i]<<LM], &X[N0+(m->eBands[i]<<LM)], (m->
eBands[i+1]-m->eBands[i])<<LM));
       minXC = MIN16(minXC, ABS16(EXTRACT16(SHR32(partial, 18))))((minXC) < (((float)fabs(((partial))))) ? (minXC) : (((float
)fabs(((partial))))));
    }
    minXC = MIN16(QCONST16(1.f, 10), ABS16(minXC))(((1.f)) < (((float)fabs(minXC))) ? ((1.f)) : (((float)fabs
(minXC))));
    /*printf ("%f\n", sum);*/
    /* mid-side savings estimations based on the LF average*/
    logXC = celt_log2(QCONST32(1.001f, 20)-MULT16_16(sum, sum))((float)(1.442695040888963387*log((1.001f)-((opus_val32)(sum)
*(opus_val32)(sum)))));
    /* mid-side savings estimations based on min correlation */
    logXC2 = MAX16(HALF16(logXC), celt_log2(QCONST32(1.001f, 20)-MULT16_16(minXC, minXC)))(((.5f*(logXC))) > (((float)(1.442695040888963387*log((1.001f
)-((opus_val32)(minXC)*(opus_val32)(minXC)))))) ? ((.5f*(logXC
))) : (((float)(1.442695040888963387*log((1.001f)-((opus_val32
)(minXC)*(opus_val32)(minXC)))))));
856#ifdef FIXED_POINT
    /* Compensate for Q20 vs Q14 input and convert output to Q8 */
    logXC = PSHR32(logXC-QCONST16(6.f, 10),10-8)(logXC-(6.f));
    logXC2 = PSHR32(logXC2-QCONST16(6.f, 10),10-8)(logXC2-(6.f));
860#endif

    trim += MAX16(-QCONST16(4.f, 8), MULT16_16_Q15(QCONST16(.75f,15),logXC))((-(4.f)) > ((((.75f))*(logXC))) ? (-(4.f)) : ((((.75f))*(
logXC))));
    *stereo_saving = MIN16(*stereo_saving + QCONST16(0.25f, 8), -HALF16(logXC2))((*stereo_saving + (0.25f)) < (-(.5f*(logXC2))) ? (*stereo_saving
 + (0.25f)) : (-(.5f*(logXC2))));
 }

 /* Estimate spectral tilt */
 c=0; do {
    for (i=0;i<end-1;i++)
    {
       diff += SHR32(bandLogE[i+c*m->nbEBands], 5)(bandLogE[i+c*m->nbEBands])*(opus_int32)(2+2*i-end);
    }
 } while (++c<C);
 diff /= C*(end-1);
 /*printf("%f\n", diff);*/
 trim -= MAX32(-QCONST16(2.f, 8), MIN32(QCONST16(2.f, 8), SHR32(diff+QCONST32(1.f, DB_SHIFT-5),DB_SHIFT-13)/6 ))((-(2.f)) > ((((2.f)) < ((diff+(1.f))/6) ? ((2.f)) : ((
diff+(1.f))/6))) ? (-(2.f)) : ((((2.f)) < ((diff+(1.f))/6)
 ? ((2.f)) : ((diff+(1.f))/6))));
 trim -= SHR16(surround_trim, DB_SHIFT-8)(surround_trim);
 trim -= 2*SHR16(tf_estimate, 14-8)(tf_estimate);
878#ifndef DISABLE_FLOAT_API
 if (analysis->valid)
 {
    trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8),((-(2.f)) > ((((2.f)) < ((opus_val16)((2.f)*(analysis->
tonality_slope+.05f))) ? ((2.f)) : ((opus_val16)((2.f)*(analysis
->tonality_slope+.05f))))) ? (-(2.f)) : ((((2.f)) < ((opus_val16
)((2.f)*(analysis->tonality_slope+.05f))) ? ((2.f)) : ((opus_val16
)((2.f)*(analysis->tonality_slope+.05f))))))
          (opus_val16)(QCONST16(2.f, 8)*(analysis->tonality_slope+.05f))))((-(2.f)) > ((((2.f)) < ((opus_val16)((2.f)*(analysis->
tonality_slope+.05f))) ? ((2.f)) : ((opus_val16)((2.f)*(analysis
->tonality_slope+.05f))))) ? (-(2.f)) : ((((2.f)) < ((opus_val16
)((2.f)*(analysis->tonality_slope+.05f))) ? ((2.f)) : ((opus_val16
)((2.f)*(analysis->tonality_slope+.05f))))));
 }
884#else
 (void)analysis;
886#endif

888#ifdef FIXED_POINT
 trim_index = PSHR32(trim, 8)(trim);
890#else
 trim_index = (int)floor(.5f+trim);
892#endif
 trim_index = IMAX(0, IMIN(10, trim_index))((0) > (((10) < (trim_index) ? (10) : (trim_index))) ? (
0) : (((10) < (trim_index) ? (10) : (trim_index))));
 /*printf("%d\n", trim_index);*/
895#ifdef FUZZING
 trim_index = rand()%11;
897#endif
 return trim_index;
899}

901static int stereo_analysis(const CELTModeOpusCustomMode *m, const celt_norm *X,
    int LM, int N0)
903{
 int i;
 int thetas;
 opus_val32 sumLR = EPSILON1e-15f, sumMS = EPSILON1e-15f;

 /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
 for (i=0;i<13;i++)
 {
    int j;
    for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
    {
       opus_val32 L, R, M, S;
       /* We cast to 32-bit first because of the -32768 case */
       L = EXTEND32(X[j])(X[j]);
       R = EXTEND32(X[N0+j])(X[N0+j]);
       M = ADD32(L, R)((L)+(R));
       S = SUB32(L, R)((L)-(R));
       sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)))((sumLR)+(((((float)fabs(L)))+(((float)fabs(R))))));
       sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)))((sumMS)+(((((float)fabs(M)))+(((float)fabs(S))))));
    }
 }
 sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS)(((0.707107f))*(sumMS));
 thetas = 13;
 /* We don't need thetas for lower bands with LM<=1 */
 if (LM<=1)
    thetas -= 8;
 return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)(((m->eBands[13]<<(LM+1))+thetas)*(sumMS))
       > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR)((m->eBands[13]<<(LM+1))*(sumLR));
931}

933#define MSWAP(a,b)do {celt_glog tmp = a;a=b;b=tmp;} while(0) do {celt_glog tmp = a;a=b;b=tmp;} while(0)
934static celt_glog median_of_5(const celt_glog *x)
935{
 celt_glog t0, t1, t2, t3, t4;
 t2 = x[2];
 if (x[0] > x[1])
 {
    t0 = x[1];
    t1 = x[0];
 } else {
    t0 = x[0];
    t1 = x[1];
 }
 if (x[3] > x[4])
 {
    t3 = x[4];
    t4 = x[3];
 } else {
    t3 = x[3];
    t4 = x[4];
 }
 if (t0 > t3)
 {
    MSWAP(t0, t3)do {celt_glog tmp = t0;t0=t3;t3=tmp;} while(0);
    MSWAP(t1, t4)do {celt_glog tmp = t1;t1=t4;t4=tmp;} while(0);
 }
 if (t2 > t1)
 {
    if (t1 < t3)
       return MING(t2, t3)((t2) < (t3) ? (t2) : (t3));
    else
       return MING(t4, t1)((t4) < (t1) ? (t4) : (t1));
 } else {
    if (t2 < t3)
       return MING(t1, t3)((t1) < (t3) ? (t1) : (t3));
    else
       return MING(t2, t4)((t2) < (t4) ? (t2) : (t4));
 }
971}

973static celt_glog median_of_3(const celt_glog *x)
974{
 celt_glog t0, t1, t2;
 if (x[0] > x[1])
 {
    t0 = x[1];
    t1 = x[0];
 } else {
    t0 = x[0];
    t1 = x[1];
 }
 t2 = x[2];
 if (t1 < t2)
    return t1;
 else if (t0 < t2)
    return t2;
 else
    return t0;
991}

993static celt_glog dynalloc_analysis(const celt_glog *bandLogE, const celt_glog *bandLogE2, const celt_glog *oldBandE,
    int nbEBands, int start, int end, int C, int *offsets, int lsb_depth, const opus_int16 *logN,
    int isTransient, int vbr, int constrained_vbr, const opus_int16 *eBands, int LM,
    int effectiveBytes, opus_int32 *tot_boost_, int lfe, celt_glog *surround_dynalloc,
    AnalysisInfo *analysis, int *importance, int *spread_weight, opus_val16 tone_freq, opus_val32 toneishness)
998{
 int i, c;
 opus_int32 tot_boost=0;
 celt_glog maxDepth;
 VARDECL(celt_glog, follower)celt_glog *follower;
 VARDECL(celt_glog, noise_floor)celt_glog *noise_floor;
 VARDECL(celt_glog, bandLogE3)celt_glog *bandLogE3;
 SAVE_STACK;
 ALLOC(follower, C*nbEBands, celt_glog)follower = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*(
C*nbEBands)));
 ALLOC(noise_floor, C*nbEBands, celt_glog)noise_floor = ((celt_glog*)__builtin_alloca (sizeof(celt_glog
)*(C*nbEBands)));
 ALLOC(bandLogE3, nbEBands, celt_glog)bandLogE3 = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*
(nbEBands)));
 OPUS_CLEAR(offsets, nbEBands)(memset((offsets), 0, (nbEBands)*sizeof(*(offsets))));
 /* Dynamic allocation code */
 maxDepth=-GCONST(31.9f)(31.9f);
 for (i=0;i<end;i++)
1
Assuming 'i' is >= 'end'→
2
←
Loop condition is false. Execution continues on line 1020→
 {
    /* Noise floor must take into account eMeans, the depth, the width of the bands
       and the preemphasis filter (approx. square of bark band ID) */
    noise_floor[i] = GCONST(0.0625f)(0.0625f)*logN[i]
          +GCONST(.5f)(.5f)+SHL32(9-lsb_depth,DB_SHIFT)(9-lsb_depth)-SHL32(eMeans[i],DB_SHIFT-4)(eMeans[i])
          +GCONST(.0062f)(.0062f)*(i+5)*(i+5);
 }
 c=0;do
5
←
Loop condition is false.  Exiting loop→
 {
    for (i=0;i2.1
'i' is >= 'end'
<end;i++)
3
←
Loop condition is false. Execution continues on line 1024→
       maxDepth = MAXG(maxDepth, bandLogE[c*nbEBands+i]-noise_floor[i])((maxDepth) > (bandLogE[c*nbEBands+i]-noise_floor[i]) ? (maxDepth
) : (bandLogE[c*nbEBands+i]-noise_floor[i]));
 } while (++c<C);
4
←
Assuming the condition is false→
 {
    /* Compute a really simple masking model to avoid taking into account completely masked
       bands when computing the spreading decision. */
    VARDECL(celt_glog, mask)celt_glog *mask;
    VARDECL(celt_glog, sig)celt_glog *sig;
    ALLOC(mask, nbEBands, celt_glog)mask = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*(nbEBands
)));
    ALLOC(sig, nbEBands, celt_glog)sig = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*(nbEBands
)));
    for (i=0;i5.1
'i' is >= 'end'
<end;i++)
6
←
Loop condition is false. Execution continues on line 1034→
       mask[i] = bandLogE[i]-noise_floor[i];
    if (C6.1
'C' is not equal to 2
==2)
7
←
Taking false branch→
    {
       for (i=0;i<end;i++)
          mask[i] = MAXG(mask[i], bandLogE[nbEBands+i]-noise_floor[i])((mask[i]) > (bandLogE[nbEBands+i]-noise_floor[i]) ? (mask
[i]) : (bandLogE[nbEBands+i]-noise_floor[i]));
    }
    OPUS_COPY(sig, mask, end)(memcpy((sig), (mask), (end)*sizeof(*(sig)) + 0*((sig)-(mask)
) ));
    for (i=1;i7.1
'i' is >= 'end'
<end;i++)
8
←
Loop condition is false. Execution continues on line 1042→
       mask[i] = MAXG(mask[i], mask[i-1] - GCONST(2.f))((mask[i]) > (mask[i-1] - (2.f)) ? (mask[i]) : (mask[i-1] -
 (2.f)));
    for (i=end-2;i>=0;i--)
9
←
Assuming 'i' is < 0→
10
←
Loop condition is false. Execution continues on line 1044→
       mask[i] = MAXG(mask[i], mask[i+1] - GCONST(3.f))((mask[i]) > (mask[i+1] - (3.f)) ? (mask[i]) : (mask[i+1] -
 (3.f)));
    for (i=0;i10.1
'i' is >= 'end'
<end;i++)
    {
       /* Compute SMR: Mask is never more than 72 dB below the peak and never below the noise floor.*/
       celt_glog smr = sig[i]-MAXG(MAXG(0, maxDepth-GCONST(12.f)), mask[i])((((0) > (maxDepth-(12.f)) ? (0) : (maxDepth-(12.f)))) >
 (mask[i]) ? (((0) > (maxDepth-(12.f)) ? (0) : (maxDepth-(
f)))) : (mask[i]));
       /* Clamp SMR to make sure we're not shifting by something negative or too large. */
1049#ifdef FIXED_POINT
       /* FIXME: Use PSHR16() instead */
       int shift = -PSHR32(MAXG(-GCONST(5.f), MING(0, smr)), DB_SHIFT)(((-(5.f)) > (((0) < (smr) ? (0) : (smr))) ? (-(5.f)) :
 (((0) < (smr) ? (0) : (smr)))));
1052#else
       int shift = IMIN(5, IMAX(0, -(int)floor(.5f + smr)))((5) < (((0) > (-(int)floor(.5f + smr)) ? (0) : (-(int)
floor(.5f + smr)))) ? (5) : (((0) > (-(int)floor(.5f + smr
)) ? (0) : (-(int)floor(.5f + smr)))));
1054#endif
       spread_weight[i] = 32 >> shift;
    }
    /*for (i=0;i<end;i++)
       printf("%d ", spread_weight[i]);
    printf("\n");*/
 }
 /* Make sure that dynamic allocation can't make us bust the budget.
    We enable the feature starting at 24 kb/s for 20-ms frames
    and 96 kb/s for 2.5 ms frames.  */
 if (effectiveBytes >= (30 + 5*LM) && !lfe)
11
←
Assuming the condition is true→
12
←
Assuming 'lfe' is 0→
13
←
Taking true branch→
 {
    int last=0;
    c=0;do
    {
       celt_glog offset;
       celt_glog tmp;
       celt_glog *f;
       OPUS_COPY(bandLogE3, &bandLogE2[c*nbEBands], end)(memcpy((bandLogE3), (&bandLogE2[c*nbEBands]), (end)*sizeof
(*(bandLogE3)) + 0*((bandLogE3)-(&bandLogE2[c*nbEBands]))
 ));
       if (LM==0) {
14
←
Assuming 'LM' is not equal to 0→
15
←
Taking false branch→
          /* For 2.5 ms frames, the first 8 bands have just one bin, so the
             energy is highly unreliable (high variance). For that reason,
             we take the max with the previous energy so that at least 2 bins
             are getting used. */
          for (i=0;i<IMIN(8,end)((8) < (end) ? (8) : (end));i++) bandLogE3[i] = MAXG(bandLogE2[c*nbEBands+i], oldBandE[c*nbEBands+i])((bandLogE2[c*nbEBands+i]) > (oldBandE[c*nbEBands+i]) ? (bandLogE2
[c*nbEBands+i]) : (oldBandE[c*nbEBands+i]));
       }
       f = &follower[c*nbEBands];
       f[0] = bandLogE3[0];
       for (i=1;i15.1
'i' is >= 'end'
<end;i++)
16
←
Loop condition is false. Execution continues on line 1091→
       {
          /* The last band to be at least 3 dB higher than the previous one
             is the last we'll consider. Otherwise, we run into problems on
             bandlimited signals. */
          if (bandLogE3[i] > bandLogE3[i-1]+GCONST(.5f)(.5f))
             last=i;
          f[i] = MING(f[i-1]+GCONST(1.5f), bandLogE3[i])((f[i-1]+(1.5f)) < (bandLogE3[i]) ? (f[i-1]+(1.5f)) : (bandLogE3
[i]));
       }
       for (i=last-1;i>=0;i--)
17
←
Loop condition is false. Execution continues on line 1097→
          f[i] = MING(f[i], MING(f[i+1]+GCONST(2.f), bandLogE3[i]))((f[i]) < (((f[i+1]+(2.f)) < (bandLogE3[i]) ? (f[i+1]+(
f)) : (bandLogE3[i]))) ? (f[i]) : (((f[i+1]+(2.f)) < (bandLogE3
[i]) ? (f[i+1]+(2.f)) : (bandLogE3[i]))));

       /* Combine with a median filter to avoid dynalloc triggering unnecessarily.
          The "offset" value controls how conservative we are -- a higher offset
          reduces the impact of the median filter and makes dynalloc use more bits. */
       offset = GCONST(1.f)(1.f);
       for (i=2;i<end-2;i++)
18
←
Loop condition is false. Execution continues on line 1100→
          f[i] = MAXG(f[i], median_of_5(&bandLogE3[i-2])-offset)((f[i]) > (median_of_5(&bandLogE3[i-2])-offset) ? (f[i
]) : (median_of_5(&bandLogE3[i-2])-offset));
       tmp = median_of_3(&bandLogE3[0])-offset;
       f[0] = MAXG(f[0], tmp)((f[0]) > (tmp) ? (f[0]) : (tmp));
19
←
Assuming the condition is false→
20
←
'?' condition is false→
       f[1] = MAXG(f[1], tmp)((f[1]) > (tmp) ? (f[1]) : (tmp));
21
←
The left operand of '>' is a garbage value
       tmp = median_of_3(&bandLogE3[end-3])-offset;
       f[end-2] = MAXG(f[end-2], tmp)((f[end-2]) > (tmp) ? (f[end-2]) : (tmp));
       f[end-1] = MAXG(f[end-1], tmp)((f[end-1]) > (tmp) ? (f[end-1]) : (tmp));

       for (i=0;i<end;i++)
          f[i] = MAXG(f[i], noise_floor[i])((f[i]) > (noise_floor[i]) ? (f[i]) : (noise_floor[i]));
    } while (++c<C);
    if (C==2)
    {
       for (i=start;i<end;i++)
       {
          /* Consider 24 dB "cross-talk" */
          follower[nbEBands+i] = MAXG(follower[nbEBands+i], follower[         i]-GCONST(4.f))((follower[nbEBands+i]) > (follower[ i]-(4.f)) ? (follower
[nbEBands+i]) : (follower[ i]-(4.f)));
          follower[         i] = MAXG(follower[         i], follower[nbEBands+i]-GCONST(4.f))((follower[ i]) > (follower[nbEBands+i]-(4.f)) ? (follower
[ i]) : (follower[nbEBands+i]-(4.f)));
          follower[i] = HALF32(MAXG(0, bandLogE[i]-follower[i]) + MAXG(0, bandLogE[nbEBands+i]-follower[nbEBands+i]))(.5f*(((0) > (bandLogE[i]-follower[i]) ? (0) : (bandLogE[i
]-follower[i])) + ((0) > (bandLogE[nbEBands+i]-follower[nbEBands
+i]) ? (0) : (bandLogE[nbEBands+i]-follower[nbEBands+i]))));
       }
    } else {
       for (i=start;i<end;i++)
       {
          follower[i] = MAXG(0, bandLogE[i]-follower[i])((0) > (bandLogE[i]-follower[i]) ? (0) : (bandLogE[i]-follower
[i]));
       }
    }
    for (i=start;i<end;i++)
       follower[i] = MAXG(follower[i], surround_dynalloc[i])((follower[i]) > (surround_dynalloc[i]) ? (follower[i]) : (
surround_dynalloc[i]));
    for (i=start;i<end;i++)
    {
1129#ifdef FIXED_POINT
       importance[i] = PSHR32(13*celt_exp2_db(MING(follower[i], GCONST(4.f))), 16)(13*((float)exp(0.6931471805599453094*(((follower[i]) < ((
f)) ? (follower[i]) : ((4.f)))))));
1131#else
       importance[i] = (int)floor(.5f+13*celt_exp2_db(MING(follower[i], GCONST(4.f)))((float)exp(0.6931471805599453094*(((follower[i]) < ((4.f)
) ? (follower[i]) : ((4.f)))))));
1133#endif
    }
    /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
    if ((!vbr || constrained_vbr)&&!isTransient)
    {
       for (i=start;i<end;i++)
          follower[i] = HALF32(follower[i])(.5f*(follower[i]));
    }
    for (i=start;i<end;i++)
    {
       if (i<8)
          follower[i] *= 2;
       if (i>=12)
          follower[i] = HALF32(follower[i])(.5f*(follower[i]));
    }
    /* Compensate for Opus' under-allocation on tones. */
    if (toneishness > QCONST32(.98f, 29)(.98f)) {
1150#ifdef FIXED_POINT
       int freq_bin = PSHR32(MULT16_16(tone_freq, QCONST16(120/M_PI, 9)), 13+9)(((opus_val32)(tone_freq)*(opus_val32)((120/3.14159265358979323846
))));
1152#else
       int freq_bin = (int)floor(.5 + tone_freq*120/M_PI3.14159265358979323846);
1154#endif
       for (i=start;i<end;i++) {
          if (freq_bin >= eBands[i] && freq_bin <= eBands[i+1]) follower[i] += GCONST(2.f)(2.f);
          if (freq_bin >= eBands[i]-1 && freq_bin <= eBands[i+1]+1) follower[i] += GCONST(1.f)(1.f);
          if (freq_bin >= eBands[i]-2 && freq_bin <= eBands[i+1]+2) follower[i] += GCONST(1.f)(1.f);
          if (freq_bin >= eBands[i]-3 && freq_bin <= eBands[i+1]+3) follower[i] += GCONST(.5f)(.5f);
       }
    }
1162#ifdef DISABLE_FLOAT_API
    (void)analysis;
1164#else
    if (analysis->valid)
    {
       for (i=start;i<IMIN(LEAK_BANDS, end)((19) < (end) ? (19) : (end));i++)
          follower[i] = follower[i] +  GCONST(1.f/64.f)(1.f/64.f)*analysis->leak_boost[i];
    }
1170#endif
    for (i=start;i<end;i++)
    {
       int width;
       int boost;
       int boost_bits;

       follower[i] = MING(follower[i], GCONST(4))((follower[i]) < ((4)) ? (follower[i]) : ((4)));

       follower[i] = SHR32(follower[i], 8)(follower[i]);
       width = C*(eBands[i+1]-eBands[i])<<LM;
       if (width<6)
       {
          boost = (int)SHR32(follower[i],DB_SHIFT-8)(follower[i]);
          boost_bits = boost*width<<BITRES3;
       } else if (width > 48) {
          boost = (int)SHR32(follower[i]*8,DB_SHIFT-8)(follower[i]*8);
          boost_bits = (boost*width<<BITRES3)/8;
       } else {
          boost = (int)SHR32(follower[i]*width/6,DB_SHIFT-8)(follower[i]*width/6);
          boost_bits = boost*6<<BITRES3;
       }
       /* For CBR and non-transient CVBR frames, limit dynalloc to 2/3 of the bits */
       if ((!vbr || (constrained_vbr&&!isTransient))
             && (tot_boost+boost_bits)>>BITRES3>>3 > 2*effectiveBytes/3)
       {
          opus_int32 cap = ((2*effectiveBytes/3)<<BITRES3<<3);
          offsets[i] = cap-tot_boost;
          tot_boost = cap;
          break;
       } else {
          offsets[i] = boost;
          tot_boost += boost_bits;
       }
    }
 } else {
    for (i=start;i<end;i++)
       importance[i] = 13;
 }
 *tot_boost_ = tot_boost;
 RESTORE_STACK;
 return maxDepth;
1212}

1214#ifdef FIXED_POINT
1215void normalize_tone_input(opus_val16 *x, int len) {
 opus_val32 ac0=len;
 int i;
 int shift;
 for (i=0;i<len;i++) {
    ac0 = ADD32(ac0, SHR32(MULT16_16(x[i], x[i]), 10))((ac0)+((((opus_val32)(x[i])*(opus_val32)(x[i])))));
 }
 shift = 5 - (28-celt_ilog2(ac0))/2;
 if (shift > 0) {
    for (i=0;i<len;i++) {
       x[i] = PSHR32(x[i], shift)(x[i]);
    }
 }
1228}
1229int acos_approx(opus_val32 x) {
 opus_val16 x14;
 opus_val32 tmp;
 int flip = x<0;
 x = abs(x);
 x14 = x>>15;
 tmp = (762*x14>>14)-3308;
 tmp = (tmp*x14>>14)+25726;
 tmp = tmp*celt_sqrt(IMAX(0, (1<<30) - (x<<1)))((float)sqrt(((0) > ((1<<30) - (x<<1)) ? (0) :
 ((1<<30) - (x<<1)))))>>16;
 if (flip) tmp = 25736 - tmp;
 return tmp;
1240}
1241#endif

1243/* Compute the LPC coefficients using a least-squares fit for both forward and backward prediction. */
1244static int tone_lpc(const opus_val16 *x, int len, int delay, opus_val32 *lpc) {
 int i;
 opus_val32 r00=0, r01=0, r11=0, r02=0, r12=0, r22=0;
 opus_val32 edges;
 opus_val32 num0, num1, den;
 celt_assert(len > 2*delay){if (!(len > 2*delay)) {celt_fatal("assertion failed: " "len > 2*delay"
, "/root/firefox-clang/media/libopus/celt/celt_encoder.c", 1249
);}};
 /* Compute correlations as if using the forward prediction covariance method. */
 for (i=0;i<len-2*delay;i++) {
    r00 += MULT16_16(x[i],x[i])((opus_val32)(x[i])*(opus_val32)(x[i]));
    r01 += MULT16_16(x[i],x[i+delay])((opus_val32)(x[i])*(opus_val32)(x[i+delay]));
    r02 += MULT16_16(x[i],x[i+2*delay])((opus_val32)(x[i])*(opus_val32)(x[i+2*delay]));
 }
 edges = 0;
 for (i=0;i<delay;i++) edges += MULT16_16(x[len+i-2*delay],x[len+i-2*delay])((opus_val32)(x[len+i-2*delay])*(opus_val32)(x[len+i-2*delay]
)) - MULT16_16(x[i],x[i])((opus_val32)(x[i])*(opus_val32)(x[i]));
 r11 = r00+edges;
 edges = 0;
 for (i=0;i<delay;i++) edges += MULT16_16(x[len+i-delay],x[len+i-delay])((opus_val32)(x[len+i-delay])*(opus_val32)(x[len+i-delay])) - MULT16_16(x[i+delay],x[i+delay])((opus_val32)(x[i+delay])*(opus_val32)(x[i+delay]));
 r22 = r11+edges;
 edges = 0;
 for (i=0;i<delay;i++) edges += MULT16_16(x[len+i-2*delay],x[len+i-delay])((opus_val32)(x[len+i-2*delay])*(opus_val32)(x[len+i-delay])) - MULT16_16(x[i],x[i+delay])((opus_val32)(x[i])*(opus_val32)(x[i+delay]));
 r12 = r01+edges;
 /* Reverse and sum to get the backward contribution. */
 {
    opus_val32 R00, R01, R11, R02, R12, R22;
    R00 = r00 + r22;
    R01 = r01 + r12;
    R11 = 2*r11;
    R02 = 2*r02;
    R12 = r12 + r01;
    R22 = r00 + r22;
    r00 = R00;
    r01 = R01;
    r11 = R11;
    r02 = R02;
    r12 = R12;
    r22 = R22;
 }
 /* Solve A*x=b, where A=[r00, r01; r01, r11] and b=[r02; r12]. */
 den = MULT32_32_Q31(r00,r11)((r00)*(r11)) - MULT32_32_Q31(r01,r01)((r01)*(r01));
1283#ifdef FIXED_POINT
 if (den <= SHR32(MULT32_32_Q31(r00,r11), 10)(((r00)*(r11)))) return 1;
1285#else
 if (den < .001f*MULT32_32_Q31(r00,r11)((r00)*(r11))) return 1;
1287#endif
 num1 = MULT32_32_Q31(r02,r11)((r02)*(r11)) - MULT32_32_Q31(r01,r12)((r01)*(r12));
 if (num1 >= den) lpc[1] = QCONST32(1.f, 29)(1.f);
 else if (num1 <= -den) lpc[1] = -QCONST32(1.f, 29)(1.f);
 else lpc[1] = frac_div32_q29(num1, den)((float)(num1)/(den));
 num0 = MULT32_32_Q31(r00,r12)((r00)*(r12)) - MULT32_32_Q31(r02,r01)((r02)*(r01));
 if (HALF32(num0)(.5f*(num0)) >= den) lpc[0] = QCONST32(1.999999f, 29)(1.999999f);
 else if (HALF32(num0)(.5f*(num0)) <= -den) lpc[0] = -QCONST32(1.999999f, 29)(1.999999f);
 else lpc[0] = frac_div32_q29(num0, den)((float)(num0)/(den));
 /*printf("%f %f\n", lpc[0], lpc[1]);*/
 return 0;
1298}

1300/* Detects pure of nearly pure tones so we can prevent them from causing problems with the encoder. */
1301static opus_val16 tone_detect(const celt_sig *in, int CC, int N, opus_val32 *toneishness, opus_int32 Fs) {
 int i;
 int delay = 1;
 int fail;
 opus_val32 lpc[2];
 opus_val16 freq;
 VARDECL(opus_val16, x)opus_val16 *x;
 ALLOC(x, N, opus_val16)x = ((opus_val16*)__builtin_alloca (sizeof(opus_val16)*(N)));
 /* Shift by SIG_SHIFT+1 (+2 for stereo) to account for HF gain of the preemphasis filter. */
 if (CC==2) {
    for (i=0;i<N;i++) x[i] = PSHR32(ADD32(in[i], in[i+N]), SIG_SHIFT+3)(((in[i])+(in[i+N])));
 } else {
    for (i=0;i<N;i++) x[i] = PSHR32(in[i], SIG_SHIFT+2)(in[i]);
 }
1315#ifdef FIXED_POINT
 normalize_tone_input(x, N);
1317#endif
 fail = tone_lpc(x, N, delay, lpc);
 /* If our LPC filter resonates too close to DC, retry the analysis with down-sampling. */
 while (delay <= Fs/3000 && (fail || (lpc[0] > QCONST32(1.f, 29)(1.f) && lpc[1] < 0))) {
    delay *= 2;
    fail = tone_lpc(x, N, delay, lpc);
 }
 /* Check that our filter has complex roots. */
 if (!fail && MULT32_32_Q31(lpc[0],lpc[0])((lpc[0])*(lpc[0])) + MULT32_32_Q31(QCONST32(3.999999, 29), lpc[1])(((3.999999))*(lpc[1])) < 0) {
    /* Squared radius of the poles. */
    *toneishness = -lpc[1];
1328#ifdef FIXED_POINT
    freq = acos_approx(lpc[0]>>1)/delay;
1330#else
    freq = acos(.5f*lpc[0])/delay;
1332#endif
 } else {
    freq = -1;
    *toneishness=0;
 }
 /*printf("%f %f %f %f\n", freq, lpc[0], lpc[1], *toneishness);*/
 return freq;
1339}

1341static int run_prefilter(CELTEncoderOpusCustomEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
    int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, opus_val16 tf_estimate, int nbAvailableBytes, AnalysisInfo *analysis, opus_val16 tone_freq, opus_val32 toneishness)
1343{
 int c;
 VARDECL(celt_sig, _pre)celt_sig *_pre;
 celt_sig *pre[2];
 const CELTModeOpusCustomMode *mode;
 int pitch_index;
 opus_val16 gain1;
 opus_val16 pf_threshold;
 int pf_on;
 int qg;
 int overlap;
 opus_val32 before[2]={0}, after[2]={0};
 int cancel_pitch=0;
 SAVE_STACK;

 mode = st->mode;
 overlap = mode->overlap;
 ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig)_pre = ((celt_sig*)__builtin_alloca (sizeof(celt_sig)*(CC*(N+
1024))));

 pre[0] = _pre;
 pre[1] = _pre + (N+COMBFILTER_MAXPERIOD1024);


 c=0; do {
    OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD)(memcpy((pre[c]), (prefilter_mem+c*1024), (1024)*sizeof(*(pre
[c])) + 0*((pre[c])-(prefilter_mem+c*1024)) ));
    OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+overlap)+overlap, N)(memcpy((pre[c]+1024), (in+c*(N+overlap)+overlap), (N)*sizeof
(*(pre[c]+1024)) + 0*((pre[c]+1024)-(in+c*(N+overlap)+overlap
)) ));
 } while (++c<CC);

 if (enabled)
 {
    VARDECL(opus_val16, pitch_buf)opus_val16 *pitch_buf;
    ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16)pitch_buf = ((opus_val16*)__builtin_alloca (sizeof(opus_val16
)*((1024 +N)>>1)));

    pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD1024+N, CC, st->arch);
    /* Don't search for the fir last 1.5 octave of the range because
       there's too many false-positives due to short-term correlation */
    pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD1024>>1), pitch_buf, N,
          COMBFILTER_MAXPERIOD1024-3*COMBFILTER_MINPERIOD15, &pitch_index,
          st->arch);
    pitch_index = COMBFILTER_MAXPERIOD1024-pitch_index;

    gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD1024, COMBFILTER_MINPERIOD15,
          N, &pitch_index, st->prefilter_period, st->prefilter_gain, st->arch);
    if (pitch_index > COMBFILTER_MAXPERIOD1024-2)
       pitch_index = COMBFILTER_MAXPERIOD1024-2;
    gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1)(((.7f))*(gain1));
    /* If we detect that the signal is dominated by a single tone, don't rely on the standard pitch
       estimator, as it can become unreliable. */
    if (toneishness > QCONST32(.99f, 29)(.99f)) {
       /* If the pitch is too high for our post-filter, apply pitch doubling until
          we can get something that fits (not ideal, but better than nothing). */
       while (tone_freq >= QCONST16(0.39f, 13)(0.39f)) tone_freq/=2;
       if (tone_freq > QCONST16(0.006148f, 13)(0.006148f)) {
1396#ifdef FIXED_POINT
          pitch_index = IMIN(51472/tone_freq, COMBFILTER_MAXPERIOD-2)((51472/tone_freq) < (1024 -2) ? (51472/tone_freq) : (1024
 -2));
1398#else
          pitch_index = IMIN((int)floor(.5+2.f*M_PI/tone_freq), COMBFILTER_MAXPERIOD-2)(((int)floor(.5+2.f*3.14159265358979323846/tone_freq)) < (
-2) ? ((int)floor(.5+2.f*3.14159265358979323846/tone_freq
)) : (1024 -2));
1400#endif
       } else {
          /* If the pitch is too low, using a very high pitch will actually give us an improvement
             due to the DC component of the filter that will be close to our tone. Again, not ideal,
             but if we only have a single tone, it's better than nothing. */
          pitch_index = COMBFILTER_MINPERIOD15;
       }
       gain1 = QCONST16(.75f, 15)(.75f);
    }
    /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
    if (st->loss_rate>2)
       gain1 = HALF32(gain1)(.5f*(gain1));
    if (st->loss_rate>4)
       gain1 = HALF32(gain1)(.5f*(gain1));
    if (st->loss_rate>8)
       gain1 = 0;
 } else {
    gain1 = 0;
    pitch_index = COMBFILTER_MINPERIOD15;
 }
1420#ifndef DISABLE_FLOAT_API
 if (analysis->valid)
    gain1 = (opus_val16)(gain1 * analysis->max_pitch_ratio);
1423#else
 (void)analysis;
1425#endif
 /* Gain threshold for enabling the prefilter/postfilter */
 pf_threshold = QCONST16(.2f,15)(.2f);

 /* Adjusting the threshold based on rate and continuity */
 if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
 {
    pf_threshold += QCONST16(.2f,15)(.2f);
    /* Completely disable the prefilter on strong transients without continuity. */
    if (tf_estimate > QCONST16(.98f, 14)(.98f))
       gain1 = 0;
 }
 if (nbAvailableBytes<25)
    pf_threshold += QCONST16(.1f,15)(.1f);
 if (nbAvailableBytes<35)
    pf_threshold += QCONST16(.1f,15)(.1f);
 if (st->prefilter_gain > QCONST16(.4f,15)(.4f))
    pf_threshold -= QCONST16(.1f,15)(.1f);
 if (st->prefilter_gain > QCONST16(.55f,15)(.55f))
    pf_threshold -= QCONST16(.1f,15)(.1f);

 /* Hard threshold at 0.2 */
 pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15))((pf_threshold) > ((.2f)) ? (pf_threshold) : ((.2f)));
 if (gain1<pf_threshold)
 {
    gain1 = 0;
    pf_on = 0;
    qg = 0;
 } else {
    /*This block is not gated by a total bits check only because
      of the nbAvailableBytes check above.*/
    if (ABS16(gain1-st->prefilter_gain)((float)fabs(gain1-st->prefilter_gain))<QCONST16(.1f,15)(.1f))
       gain1=st->prefilter_gain;

1459#ifdef FIXED_POINT
    qg = ((gain1+1536)>>10)/3-1;
1461#else
    qg = (int)floor(.5f+gain1*32/3)-1;
1463#endif
    qg = IMAX(0, IMIN(7, qg))((0) > (((7) < (qg) ? (7) : (qg))) ? (0) : (((7) < (
qg) ? (7) : (qg))));
    gain1 = QCONST16(0.09375f,15)(0.09375f)*(qg+1);
    pf_on = 1;
 }
 /*printf("%d %f\n", pitch_index, gain1);*/

 c=0; do {
    int i;
    int offset = mode->shortMdctSize-overlap;
    st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD)((st->prefilter_period) > (15) ? (st->prefilter_period
) : (15));
    OPUS_COPY(in+c*(N+overlap), st->in_mem+c*(overlap), overlap)(memcpy((in+c*(N+overlap)), (st->in_mem+c*(overlap)), (overlap
)*sizeof(*(in+c*(N+overlap))) + 0*((in+c*(N+overlap))-(st->
in_mem+c*(overlap))) ));
    for (i=0;i<N;i++) before[c] += ABS32(SHR32(in[c*(N+overlap)+overlap+i], 12))((float)fabs((in[c*(N+overlap)+overlap+i])));
    if (offset)
       comb_filter(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD1024,
             st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
             st->prefilter_tapset, st->prefilter_tapset, NULL((void*)0), 0, st->arch);

    comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD1024+offset,
          st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
          st->prefilter_tapset, prefilter_tapset, mode->window, overlap, st->arch);
    for (i=0;i<N;i++) after[c] += ABS32(SHR32(in[c*(N+overlap)+overlap+i], 12))((float)fabs((in[c*(N+overlap)+overlap+i])));
 } while (++c<CC);

 if (CC==2) {
    opus_val16 thresh[2];
    thresh[0] = MULT16_32_Q15(MULT16_16_Q15(QCONST16(.25f, 15), gain1), before[0])(((((.25f))*(gain1)))*(before[0])) + MULT16_32_Q15(QCONST16(.01f,15), before[1])(((.01f))*(before[1]));
    thresh[1] = MULT16_32_Q15(MULT16_16_Q15(QCONST16(.25f, 15), gain1), before[1])(((((.25f))*(gain1)))*(before[1])) + MULT16_32_Q15(QCONST16(.01f,15), before[0])(((.01f))*(before[0]));
    /* Don't use the filter if one channel gets significantly worse. */
    if (after[0]-before[0] > thresh[0] || after[1]-before[1] > thresh[1]) cancel_pitch = 1;
    /* Use the filter only if at least one channel gets significantly better. */
    if (before[0]-after[0] <  thresh[0] && before[1]-after[1] < thresh[1]) cancel_pitch = 1;
 } else {
    /* Check that the mono channel actually got better. */
    if (after[0] > before[0]) cancel_pitch = 1;
 }
 /* If needed, revert to a gain of zero. */
 if (cancel_pitch) {
    c=0; do {
       int offset = mode->shortMdctSize-overlap;
       OPUS_COPY(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD, N)(memcpy((in+c*(N+overlap)+overlap), (pre[c]+1024), (N)*sizeof
(*(in+c*(N+overlap)+overlap)) + 0*((in+c*(N+overlap)+overlap)
-(pre[c]+1024)) ));
       comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD1024+offset,
                   st->prefilter_period, pitch_index, overlap, -st->prefilter_gain, -0,
                   st->prefilter_tapset, prefilter_tapset, mode->window, overlap, st->arch);
    } while (++c<CC);
    gain1 = 0;
    pf_on = 0;
    qg = 0;
 }

 c=0; do {
    OPUS_COPY(st->in_mem+c*(overlap), in+c*(N+overlap)+N, overlap)(memcpy((st->in_mem+c*(overlap)), (in+c*(N+overlap)+N), (overlap
)*sizeof(*(st->in_mem+c*(overlap))) + 0*((st->in_mem+c*
(overlap))-(in+c*(N+overlap)+N)) ));

    if (N>COMBFILTER_MAXPERIOD1024)
    {
       OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD)(memcpy((prefilter_mem+c*1024), (pre[c]+N), (1024)*sizeof(*(prefilter_mem
+c*1024)) + 0*((prefilter_mem+c*1024)-(pre[c]+N)) ));
    } else {
       OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N)(memmove((prefilter_mem+c*1024), (prefilter_mem+c*1024 +N), (
-N)*sizeof(*(prefilter_mem+c*1024)) + 0*((prefilter_mem+
c*1024)-(prefilter_mem+c*1024 +N)) ));
       OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N)(memcpy((prefilter_mem+c*1024 +1024 -N), (pre[c]+1024), (N)*sizeof
(*(prefilter_mem+c*1024 +1024 -N)) + 0*((prefilter_mem+c*1024
 +1024 -N)-(pre[c]+1024)) ));
    }
 } while (++c<CC);

 RESTORE_STACK;
 *gain = gain1;
 *pitch = pitch_index;
 *qgain = qg;
 return pf_on;
1530}

1532static int compute_vbr(const CELTModeOpusCustomMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
    int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
    int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
    opus_val16 tf_estimate, int pitch_change, celt_glog maxDepth,
    int lfe, int has_surround_mask, celt_glog surround_masking,
    celt_glog temporal_vbr)
1538{
 /* The target rate in 8th bits per frame */
 opus_int32 target;
 int coded_bins;
 int coded_bands;
 opus_val16 tf_calibration;
 int nbEBands;
 const opus_int16 *eBands;

 nbEBands = mode->nbEBands;
 eBands = mode->eBands;

 coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
 coded_bins = eBands[coded_bands]<<LM;
 if (C==2)
    coded_bins += eBands[IMIN(intensity, coded_bands)((intensity) < (coded_bands) ? (intensity) : (coded_bands)
)]<<LM;

 target = base_target;

 /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1558#ifndef DISABLE_FLOAT_API
 if (analysis->valid && analysis->activity<.4)
    target -= (opus_int32)((coded_bins<<BITRES3)*(.4f-analysis->activity));
1561#endif
 /* Stereo savings */
 if (C==2)
 {
    int coded_stereo_bands;
    int coded_stereo_dof;
    opus_val16 max_frac;
    coded_stereo_bands = IMIN(intensity, coded_bands)((intensity) < (coded_bands) ? (intensity) : (coded_bands)
);
    coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
    /* Maximum fraction of the bits we can save if the signal is mono. */
    max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins)(((opus_val32)(((opus_val32)((0.8f))*(opus_val32)(coded_stereo_dof
))))/(opus_val16)(coded_bins));
    stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8))((stereo_saving) < ((1.f)) ? (stereo_saving) : ((1.f)));
    /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
    target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),((((max_frac)*(target))) < ((((opus_val32)(stereo_saving-(
1f))*(opus_val32)((coded_stereo_dof<<3))))) ? (((max_frac
)*(target))) : ((((opus_val32)(stereo_saving-(0.1f))*(opus_val32
)((coded_stereo_dof<<3))))))
                    SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8))((((max_frac)*(target))) < ((((opus_val32)(stereo_saving-(
1f))*(opus_val32)((coded_stereo_dof<<3))))) ? (((max_frac
)*(target))) : ((((opus_val32)(stereo_saving-(0.1f))*(opus_val32
)((coded_stereo_dof<<3))))));
 }
 /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
 target += tot_boost-(19<<LM);
 /* Apply transient boost, compensating for average boost. */
 tf_calibration = QCONST16(0.044f,14)(0.044f);
 target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1)(((tf_estimate-tf_calibration)*(target)));

1583#ifndef DISABLE_FLOAT_API
 /* Apply tonality boost */
 if (analysis->valid && !lfe)
 {
    opus_int32 tonal_target;
    float tonal;

    /* Tonality boost (compensating for the average). */
    tonal = MAX16(0.f,analysis->tonality-.15f)((0.f) > (analysis->tonality-.15f) ? (0.f) : (analysis->
tonality-.15f))-0.12f;
    tonal_target = target + (opus_int32)((coded_bins<<BITRES3)*1.2f*tonal);
    if (pitch_change)
       tonal_target +=  (opus_int32)((coded_bins<<BITRES3)*.8f);
    /*printf("%f %f ", analysis->tonality, tonal);*/
    target = tonal_target;
 }
1598#else
 (void)analysis;
 (void)pitch_change;
1601#endif

 if (has_surround_mask&&!lfe)
 {
    opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(SHR32(surround_masking,DB_SHIFT-10),coded_bins<<BITRES), 10)(((opus_val32)((surround_masking))*(opus_val32)(coded_bins<<
3)));
    /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
    target = IMAX(target/4, surround_target)((target/4) > (surround_target) ? (target/4) : (surround_target
));
 }

 {
    opus_int32 floor_depth;
    int bins;
    bins = eBands[nbEBands-2]<<LM;
    /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
    floor_depth = (opus_int32)SHR32(MULT16_32_Q15((C*bins<<BITRES),maxDepth), DB_SHIFT-15)((((C*bins<<3))*(maxDepth)));
    floor_depth = IMAX(floor_depth, target>>2)((floor_depth) > (target>>2) ? (floor_depth) : (target
>>2));
    target = IMIN(target, floor_depth)((target) < (floor_depth) ? (target) : (floor_depth));
    /*printf("%f %d\n", maxDepth, floor_depth);*/
 }

 /* Make VBR less aggressive for constrained VBR because we can't keep a higher bitrate
    for long. Needs tuning. */
 if ((!has_surround_mask||lfe) && constrained_vbr)
 {
    target = base_target + (opus_int32)MULT16_32_Q15(QCONST16(0.67f, 15), target-base_target)(((0.67f))*(target-base_target));
 }

 if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14)(.2f))
 {
    opus_val16 amount;
    opus_val16 tvbr_factor;
    amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)))(((.0000031f))*(((0) > (((32000) < (96000-bitrate) ? (32000
) : (96000-bitrate))) ? (0) : (((32000) < (96000-bitrate) ?
 (32000) : (96000-bitrate))))));
    tvbr_factor = SHR32(MULT16_16(SHR32(temporal_vbr, DB_SHIFT-10), amount), 10)(((opus_val32)((temporal_vbr))*(opus_val32)(amount)));
    target += (opus_int32)MULT16_32_Q15(tvbr_factor, target)((tvbr_factor)*(target));
 }

 /* Don't allow more than doubling the rate */
 target = IMIN(2*base_target, target)((2*base_target) < (target) ? (2*base_target) : (target));

 return target;
1641}

1643int celt_encode_with_ec(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const opus_res * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1644{
 int i, c, N;
 opus_int32 bits;
 ec_enc _enc;
 VARDECL(celt_sig, in)celt_sig *in;
 VARDECL(celt_sig, freq)celt_sig *freq;
 VARDECL(celt_norm, X)celt_norm *X;
 VARDECL(celt_ener, bandE)celt_ener *bandE;
 VARDECL(celt_glog, bandLogE)celt_glog *bandLogE;
 VARDECL(celt_glog, bandLogE2)celt_glog *bandLogE2;
 VARDECL(int, fine_quant)int *fine_quant;
 VARDECL(celt_glog, error)celt_glog *error;
 VARDECL(int, pulses)int *pulses;
 VARDECL(int, cap)int *cap;
 VARDECL(int, offsets)int *offsets;
 VARDECL(int, importance)int *importance;
 VARDECL(int, spread_weight)int *spread_weight;
 VARDECL(int, fine_priority)int *fine_priority;
 VARDECL(int, tf_res)int *tf_res;
 VARDECL(unsigned char, collapse_masks)unsigned char *collapse_masks;
 celt_sig *prefilter_mem;
 celt_glog *oldBandE, *oldLogE, *oldLogE2, *energyError;
 int shortBlocks=0;
 int isTransient=0;
 const int CC = st->channels;
 const int C = st->stream_channels;
 int LM, M;
 int tf_select;
 int nbFilledBytes, nbAvailableBytes;
 int start;
 int end;
 int effEnd;
 int codedBands;
 int alloc_trim;
 int pitch_index=COMBFILTER_MINPERIOD15;
 opus_val16 gain1 = 0;
 int dual_stereo=0;
 int effectiveBytes;
 int dynalloc_logp;
 opus_int32 vbr_rate;
 opus_int32 total_bits;
 opus_int32 total_boost;
 opus_int32 balance;
 opus_int32 tell;
 opus_int32 tell0_frac;
 int prefilter_tapset=0;
 int pf_on;
 int anti_collapse_rsv;
 int anti_collapse_on=0;
 int silence=0;
 int tf_chan = 0;
 opus_val16 tf_estimate;
 int pitch_change=0;
 opus_int32 tot_boost;
 opus_val32 sample_max;
 celt_glog maxDepth;
 const OpusCustomMode *mode;
 int nbEBands;
 int overlap;
 const opus_int16 *eBands;
 int secondMdct;
 int signalBandwidth;
 int transient_got_disabled=0;
 celt_glog surround_masking=0;
 celt_glog temporal_vbr=0;
 celt_glog surround_trim = 0;
 opus_int32 equiv_rate;
 int hybrid;
 int weak_transient = 0;
 int enable_tf_analysis;
 opus_val16 tone_freq=-1;
 opus_val32 toneishness=0;
 VARDECL(celt_glog, surround_dynalloc)celt_glog *surround_dynalloc;
 ALLOC_STACK;

 mode = st->mode;
 nbEBands = mode->nbEBands;
 overlap = mode->overlap;
 eBands = mode->eBands;
 start = st->start;
 end = st->end;
 hybrid = start != 0;
 tf_estimate = 0;
 if (nbCompressedBytes<2 || pcm==NULL((void*)0))
 {
    RESTORE_STACK;
    return OPUS_BAD_ARG-1;
 }

 frame_size *= st->upsample;
 for (LM=0;LM<=mode->maxLM;LM++)
    if (mode->shortMdctSize<<LM==frame_size)
       break;
 if (LM>mode->maxLM)
 {
    RESTORE_STACK;
    return OPUS_BAD_ARG-1;
 }
 M=1<<LM;
 N = M*mode->shortMdctSize;

 prefilter_mem = st->in_mem+CC*(overlap);
 oldBandE = (celt_glog*)(st->in_mem+CC*(overlap+COMBFILTER_MAXPERIOD1024));
 oldLogE = oldBandE + CC*nbEBands;
 oldLogE2 = oldLogE + CC*nbEBands;
 energyError = oldLogE2 + CC*nbEBands;

 if (enc==NULL((void*)0))
 {
    tell0_frac=tell=1;
    nbFilledBytes=0;
 } else {
    tell0_frac=ec_tell_frac(enc);
    tell=ec_tell(enc);
    nbFilledBytes=(tell+4)>>3;
 }

1761#ifdef CUSTOM_MODES
 if (st->signalling && enc==NULL((void*)0))
 {
    int tmp = (mode->effEBands-end)>>1;
    end = st->end = IMAX(1, mode->effEBands-tmp)((1) > (mode->effEBands-tmp) ? (1) : (mode->effEBands
-tmp));
    compressed[0] = tmp<<5;
    compressed[0] |= LM<<3;
    compressed[0] |= (C==2)<<2;
    /* Convert "standard mode" to Opus header */
    if (mode->Fs==48000 && mode->shortMdctSize==120)
    {
       int c0 = toOpus(compressed[0]);
       if (c0<0)
       {
          RESTORE_STACK;
          return OPUS_BAD_ARG-1;
       }
       compressed[0] = c0;
    }
    compressed++;
    nbCompressedBytes--;
 }
1783#else
 celt_assert(st->signalling==0){if (!(st->signalling==0)) {celt_fatal("assertion failed: "
 "st->signalling==0", "/root/firefox-clang/media/libopus/celt/celt_encoder.c"
, 1784);}};
1785#endif

 /* Can't produce more than 1275 output bytes */
 nbCompressedBytes = IMIN(nbCompressedBytes,1275)((nbCompressedBytes) < (1275) ? (nbCompressedBytes) : (1275
));

 if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX-1)
 {
    opus_int32 den=mode->Fs>>BITRES3;
    vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1794#ifdef CUSTOM_MODES
    if (st->signalling)
       vbr_rate -= 8<<BITRES3;
1797#endif
    effectiveBytes = vbr_rate>>(3+BITRES3);
 } else {
    opus_int32 tmp;
    vbr_rate = 0;
    tmp = st->bitrate*frame_size;
    if (tell>1)
       tmp += tell*mode->Fs;
    if (st->bitrate!=OPUS_BITRATE_MAX-1)
    {
       nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,((2) > (((nbCompressedBytes) < ((tmp+4*mode->Fs)/(8*
mode->Fs)-!!st->signalling) ? (nbCompressedBytes) : ((tmp
+4*mode->Fs)/(8*mode->Fs)-!!st->signalling))) ? (2) :
 (((nbCompressedBytes) < ((tmp+4*mode->Fs)/(8*mode->
Fs)-!!st->signalling) ? (nbCompressedBytes) : ((tmp+4*mode
->Fs)/(8*mode->Fs)-!!st->signalling))))
             (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling))((2) > (((nbCompressedBytes) < ((tmp+4*mode->Fs)/(8*
mode->Fs)-!!st->signalling) ? (nbCompressedBytes) : ((tmp
+4*mode->Fs)/(8*mode->Fs)-!!st->signalling))) ? (2) :
 (((nbCompressedBytes) < ((tmp+4*mode->Fs)/(8*mode->
Fs)-!!st->signalling) ? (nbCompressedBytes) : ((tmp+4*mode
->Fs)/(8*mode->Fs)-!!st->signalling))));
       if (enc != NULL((void*)0))
          ec_enc_shrink(enc, nbCompressedBytes);
    }
    effectiveBytes = nbCompressedBytes - nbFilledBytes;
 }
 nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
 equiv_rate = ((opus_int32)nbCompressedBytes*8*50 << (3-LM)) - (40*C+20)*((400>>LM) - 50);
 if (st->bitrate != OPUS_BITRATE_MAX-1)
    equiv_rate = IMIN(equiv_rate, st->bitrate - (40*C+20)*((400>>LM) - 50))((equiv_rate) < (st->bitrate - (40*C+20)*((400>>LM
) - 50)) ? (equiv_rate) : (st->bitrate - (40*C+20)*((400>>
LM) - 50)));

 if (enc==NULL((void*)0))
 {
    ec_enc_init(&_enc, compressed, nbCompressedBytes);
    enc = &_enc;
 }

 if (vbr_rate>0)
 {
    /* Computes the max bit-rate allowed in VBR mode to avoid violating the
        target rate and buffering.
       We must do this up front so that bust-prevention logic triggers
        correctly if we don't have enough bits. */
    if (st->constrained_vbr)
    {
       opus_int32 vbr_bound;
       opus_int32 max_allowed;
       /* We could use any multiple of vbr_rate as bound (depending on the
           delay).
          This is clamped to ensure we use at least two bytes if the encoder
           was entirely empty, but to allow 0 in hybrid mode. */
       vbr_bound = vbr_rate;
       max_allowed = IMIN(IMAX(tell==1?2:0,((((tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->
vbr_reservoir)>>(3 +3)))) < (nbAvailableBytes) ? (((
tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir)>>
(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)))) : (nbAvailableBytes))
             (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),((((tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->
vbr_reservoir)>>(3 +3)))) < (nbAvailableBytes) ? (((
tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir)>>
(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)))) : (nbAvailableBytes))
             nbAvailableBytes)((((tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->
vbr_reservoir)>>(3 +3)))) < (nbAvailableBytes) ? (((
tell==1?2:0) > ((vbr_rate+vbr_bound-st->vbr_reservoir)>>
(3 +3)) ? (tell==1?2:0) : ((vbr_rate+vbr_bound-st->vbr_reservoir
)>>(3 +3)))) : (nbAvailableBytes));
       if(max_allowed < nbAvailableBytes)
       {
          nbCompressedBytes = nbFilledBytes+max_allowed;
          nbAvailableBytes = max_allowed;
          ec_enc_shrink(enc, nbCompressedBytes);
       }
    }
 }
 total_bits = nbCompressedBytes*8;

 effEnd = end;
 if (effEnd > mode->effEBands)
    effEnd = mode->effEBands;

 ALLOC(in, CC*(N+overlap), celt_sig)in = ((celt_sig*)__builtin_alloca (sizeof(celt_sig)*(CC*(N+overlap
))));

 sample_max=MAX32(st->overlap_max, celt_maxabs_res(pcm, C*(N-overlap)/st->upsample))((st->overlap_max) > (celt_maxabs16(pcm, C*(N-overlap)/
st->upsample)) ? (st->overlap_max) : (celt_maxabs16(pcm
, C*(N-overlap)/st->upsample)));
 st->overlap_max=celt_maxabs_rescelt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
 sample_max=MAX32(sample_max, st->overlap_max)((sample_max) > (st->overlap_max) ? (sample_max) : (st->
overlap_max));
1862#ifdef FIXED_POINT
 silence = (sample_max==0);
1864#else
 silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1866#endif
1867#ifdef FUZZING
 if ((rand()&0x3F)==0)
    silence = 1;
1870#endif
 if (tell==1)
    ec_enc_bit_logp(enc, silence, 15);
 else
    silence=0;
 if (silence)
 {
    /*In VBR mode there is no need to send more than the minimum. */
    if (vbr_rate>0)
    {
       effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2)((nbCompressedBytes) < (nbFilledBytes+2) ? (nbCompressedBytes
) : (nbFilledBytes+2));
       total_bits=nbCompressedBytes*8;
       nbAvailableBytes=2;
       ec_enc_shrink(enc, nbCompressedBytes);
    }
    /* Pretend we've filled all the remaining bits with zeros
          (that's what the initialiser did anyway) */
    tell = nbCompressedBytes*8;
    enc->nbits_total+=tell-ec_tell(enc);
 }
 c=0; do {
    int need_clip=0;
1892#ifndef FIXED_POINT
    need_clip = st->clip && sample_max>65536.f;
1894#endif
    celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,
                mode->preemph, st->preemph_memE+c, need_clip);
    OPUS_COPY(in+c*(N+overlap), &prefilter_mem[(1+c)*COMBFILTER_MAXPERIOD-overlap], overlap)(memcpy((in+c*(N+overlap)), (&prefilter_mem[(1+c)*1024 -overlap
]), (overlap)*sizeof(*(in+c*(N+overlap))) + 0*((in+c*(N+overlap
))-(&prefilter_mem[(1+c)*1024 -overlap])) ));
 } while (++c<CC);


 tone_freq = tone_detect(in, CC, N+overlap, &toneishness, mode->Fs);
 isTransient = 0;
 shortBlocks = 0;
 if (st->complexity >= 1 && !st->lfe)
 {
    /* Reduces the likelihood of energy instability on fricatives at low bitrate
       in hybrid mode. It seems like we still want to have real transients on vowels
       though (small SILK quantization offset value). */
    int allow_weak_transients = hybrid && effectiveBytes<15 && st->silk_info.signalType != 2;
    isTransient = transient_analysis(in, N+overlap, CC,
          &tf_estimate, &tf_chan, allow_weak_transients, &weak_transient, tone_freq, toneishness);
 }
 /* Find pitch period and gain */
 {
    int enabled;
    int qg;
    enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && !hybrid && !silence && tell+16<=total_bits && !st->disable_pf
          && st->complexity >= 5;

    prefilter_tapset = st->tapset_decision;
    pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, tf_estimate, nbAvailableBytes, &st->analysis, tone_freq, toneishness);
    if ((gain1 > QCONST16(.4f,15)(.4f) || st->prefilter_gain > QCONST16(.4f,15)(.4f)) && (!st->analysis.valid || st->analysis.tonality > .3)
          && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
       pitch_change = 1;
    if (pf_on==0)
    {
       if(!hybrid && tell+16<=total_bits)
          ec_enc_bit_logp(enc, 0, 1);
    } else {
       /*This block is not gated by a total bits check only because
         of the nbAvailableBytes check above.*/
       int octave;
       ec_enc_bit_logp(enc, 1, 1);
       pitch_index += 1;
       octave = EC_ILOG(pitch_index)(((int)sizeof(unsigned)*8)-(__builtin_clz(pitch_index)))-5;
       ec_enc_uint(enc, octave, 6);
       ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
       pitch_index -= 1;
       ec_enc_bits(enc, qg, 3);
       ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
    }
 }
 if (LM>0 && ec_tell(enc)+3<=total_bits)
 {
    if (isTransient)
       shortBlocks = M;
 } else {
    isTransient = 0;
    transient_got_disabled=1;
 }

 ALLOC(freq, CC*N, celt_sig)freq = ((celt_sig*)__builtin_alloca (sizeof(celt_sig)*(CC*N))
); /**< Interleaved signal MDCTs */
 ALLOC(bandE,nbEBands*CC, celt_ener)bandE = ((celt_ener*)__builtin_alloca (sizeof(celt_ener)*(nbEBands
*CC)));
 ALLOC(bandLogE,nbEBands*CC, celt_glog)bandLogE = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*(
nbEBands*CC)));

 secondMdct = shortBlocks && st->complexity>=8;
 ALLOC(bandLogE2, C*nbEBands, celt_glog)bandLogE2 = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*
(C*nbEBands)));
 if (secondMdct)
 {
    compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample, st->arch);
    compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
    amp2Log2(mode, effEnd, end, bandE, bandLogE2, C);
    for (c=0;c<C;c++)
    {
       for (i=0;i<end;i++)
          bandLogE2[nbEBands*c+i] += HALF32(SHL32(LM, DB_SHIFT))(.5f*((LM)));
    }
 }

 compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
 /* This should catch any NaN in the CELT input. Since we're not supposed to see any (they're filtered
    at the Opus layer), just abort. */
 celt_assert(!celt_isnan(freq[0]) && (C==1 || !celt_isnan(freq[N]))){if (!(!((freq[0])!=(freq[0])) && (C==1 || !((freq[N]
)!=(freq[N]))))) {celt_fatal("assertion failed: " "!celt_isnan(freq[0]) && (C==1 || !celt_isnan(freq[N]))"
, "/root/firefox-clang/media/libopus/celt/celt_encoder.c", 1973
);}};
 if (CC==2&&C==1)
    tf_chan = 0;
 compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);

 if (st->lfe)
 {
    for (i=2;i<end;i++)
    {
       bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]))((bandE[i]) < ((((1e-4f))*(bandE[0]))) ? (bandE[i]) : ((((
1e-4f))*(bandE[0]))));
       bandE[i] = MAX32(bandE[i], EPSILON)((bandE[i]) > (1e-15f) ? (bandE[i]) : (1e-15f));
    }
 }
 amp2Log2(mode, effEnd, end, bandE, bandLogE, C);

 ALLOC(surround_dynalloc, C*nbEBands, celt_glog)surround_dynalloc = ((celt_glog*)__builtin_alloca (sizeof(celt_glog
)*(C*nbEBands)));
 OPUS_CLEAR(surround_dynalloc, end)(memset((surround_dynalloc), 0, (end)*sizeof(*(surround_dynalloc
))));
 /* This computes how much masking takes place between surround channels */
 if (!hybrid&&st->energy_mask&&!st->lfe)
 {
    int mask_end;
    int midband;
    int count_dynalloc;
    opus_val32 mask_avg=0;
    opus_val32 diff=0;
    int count=0;
    mask_end = IMAX(2,st->lastCodedBands)((2) > (st->lastCodedBands) ? (2) : (st->lastCodedBands
));
    for (c=0;c<C;c++)
    {
       for(i=0;i<mask_end;i++)
       {
          celt_glog mask;
          opus_val16 mask16;
          mask = MAXG(MING(st->energy_mask[nbEBands*c+i],((((st->energy_mask[nbEBands*c+i]) < ((.25f)) ? (st->
energy_mask[nbEBands*c+i]) : ((.25f)))) > (-(2.0f)) ? (((st
->energy_mask[nbEBands*c+i]) < ((.25f)) ? (st->energy_mask
[nbEBands*c+i]) : ((.25f)))) : (-(2.0f)))
                 GCONST(.25f)), -GCONST(2.0f))((((st->energy_mask[nbEBands*c+i]) < ((.25f)) ? (st->
energy_mask[nbEBands*c+i]) : ((.25f)))) > (-(2.0f)) ? (((st
->energy_mask[nbEBands*c+i]) < ((.25f)) ? (st->energy_mask
[nbEBands*c+i]) : ((.25f)))) : (-(2.0f)));
          if (mask > 0)
             mask = HALF32(mask)(.5f*(mask));
          mask16 = SHR32(mask, DB_SHIFT-10)(mask);
          mask_avg += MULT16_16(mask16, eBands[i+1]-eBands[i])((opus_val32)(mask16)*(opus_val32)(eBands[i+1]-eBands[i]));
          count += eBands[i+1]-eBands[i];
          diff += MULT16_16(mask16, 1+2*i-mask_end)((opus_val32)(mask16)*(opus_val32)(1+2*i-mask_end));
       }
    }
    celt_assert(count>0){if (!(count>0)) {celt_fatal("assertion failed: " "count>0"
, "/root/firefox-clang/media/libopus/celt/celt_encoder.c", 2016
);}};
    mask_avg = SHL32(DIV32_16(mask_avg,count), DB_SHIFT-10)((((opus_val32)(mask_avg))/(opus_val16)(count)));
    mask_avg += GCONST(.2f)(.2f);
    diff = SHL32(diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end), DB_SHIFT-10)(diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end));
    /* Again, being conservative */
    diff = HALF32(diff)(.5f*(diff));
    diff = MAX32(MIN32(diff, GCONST(.031f)), -GCONST(.031f))((((diff) < ((.031f)) ? (diff) : ((.031f)))) > (-(.031f
)) ? (((diff) < ((.031f)) ? (diff) : ((.031f)))) : (-(.031f
)));
    /* Find the band that's in the middle of the coded spectrum */
    for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++);
    count_dynalloc=0;
    for(i=0;i<mask_end;i++)
    {
       opus_val32 lin;
       celt_glog unmask;
       lin = mask_avg + diff*(i-midband);
       if (C==2)
          unmask = MAXG(st->energy_mask[i], st->energy_mask[nbEBands+i])((st->energy_mask[i]) > (st->energy_mask[nbEBands+i]
) ? (st->energy_mask[i]) : (st->energy_mask[nbEBands+i]
));
       else
          unmask = st->energy_mask[i];
       unmask = MING(unmask, GCONST(.0f))((unmask) < ((.0f)) ? (unmask) : ((.0f)));
       unmask -= lin;
       if (unmask > GCONST(.25f)(.25f))
       {
          surround_dynalloc[i] = unmask - GCONST(.25f)(.25f);
          count_dynalloc++;
       }
    }
    if (count_dynalloc>=3)
    {
       /* If we need dynalloc in many bands, it's probably because our
          initial masking rate was too low. */
       mask_avg += GCONST(.25f)(.25f);
       if (mask_avg>0)
       {
          /* Something went really wrong in the original calculations,
             disabling masking. */
          mask_avg = 0;
          diff = 0;
          OPUS_CLEAR(surround_dynalloc, mask_end)(memset((surround_dynalloc), 0, (mask_end)*sizeof(*(surround_dynalloc
))));
       } else {
          for(i=0;i<mask_end;i++)
             surround_dynalloc[i] = MAXG(0, surround_dynalloc[i]-GCONST(.25f))((0) > (surround_dynalloc[i]-(.25f)) ? (0) : (surround_dynalloc
[i]-(.25f)));
       }
    }
    mask_avg += GCONST(.2f)(.2f);
    /* Convert to 1/64th units used for the trim */
    surround_trim = 64*diff;
    /*printf("%d %d ", mask_avg, surround_trim);*/
    surround_masking = mask_avg;
 }
 /* Temporal VBR (but not for LFE) */
 if (!st->lfe)
 {
    celt_glog follow=-QCONST32(10.0f, DB_SHIFT-5)(10.0f);
    opus_val32 frame_avg=0;
    celt_glog offset = shortBlocks?HALF32(SHL32(LM, DB_SHIFT-5))(.5f*((LM))):0;
    for(i=start;i<end;i++)
    {
       follow = MAXG(follow-QCONST32(1.0f, DB_SHIFT-5), SHR32(bandLogE[i],5)-offset)((follow-(1.0f)) > ((bandLogE[i])-offset) ? (follow-(1.0f)
) : ((bandLogE[i])-offset));
       if (C==2)
          follow = MAXG(follow, SHR32(bandLogE[i+nbEBands],5)-offset)((follow) > ((bandLogE[i+nbEBands])-offset) ? (follow) : (
(bandLogE[i+nbEBands])-offset));
       frame_avg += follow;
    }
    frame_avg /= (end-start);
    temporal_vbr = SUB32(SHL32(frame_avg, 5),st->spec_avg)(((frame_avg))-(st->spec_avg));
    temporal_vbr = MING(GCONST(3.f), MAXG(-GCONST(1.5f), temporal_vbr))(((3.f)) < (((-(1.5f)) > (temporal_vbr) ? (-(1.5f)) : (
temporal_vbr))) ? ((3.f)) : (((-(1.5f)) > (temporal_vbr) ?
 (-(1.5f)) : (temporal_vbr))));
    st->spec_avg += MULT16_32_Q15(QCONST16(.02f, 15), temporal_vbr)(((.02f))*(temporal_vbr));
 }
 /*for (i=0;i<21;i++)
    printf("%f ", bandLogE[i]);
 printf("\n");*/

 if (!secondMdct)
 {
    OPUS_COPY(bandLogE2, bandLogE, C*nbEBands)(memcpy((bandLogE2), (bandLogE), (C*nbEBands)*sizeof(*(bandLogE2
)) + 0*((bandLogE2)-(bandLogE)) ));
 }

 /* Last chance to catch any transient we might have missed in the
    time-domain analysis */
 if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe && !hybrid)
 {
    if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C))
    {
       isTransient = 1;
       shortBlocks = M;
       compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
       compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
       amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
       /* Compensate for the scaling of short vs long mdcts */
       for (c=0;c<C;c++)
       {
          for (i=0;i<end;i++)
             bandLogE2[nbEBands*c+i] += HALF32(SHL32(LM, DB_SHIFT))(.5f*((LM)));
       }
       tf_estimate = QCONST16(.2f,14)(.2f);
    }
 }

 if (LM>0 && ec_tell(enc)+3<=total_bits)
    ec_enc_bit_logp(enc, isTransient, 3);

 ALLOC(X, C*N, celt_norm)X = ((celt_norm*)__builtin_alloca (sizeof(celt_norm)*(C*N)));         /**< Interleaved normalised MDCTs */

 /* Band normalisation */
 normalise_bands(mode, freq, X, bandE, effEnd, C, M);

 enable_tf_analysis = effectiveBytes>=15*C && !hybrid && st->complexity>=2 && !st->lfe && toneishness < QCONST32(.98f, 29)(.98f);

 ALLOC(offsets, nbEBands, int)offsets = ((int*)__builtin_alloca (sizeof(int)*(nbEBands)));
 ALLOC(importance, nbEBands, int)importance = ((int*)__builtin_alloca (sizeof(int)*(nbEBands))
);
 ALLOC(spread_weight, nbEBands, int)spread_weight = ((int*)__builtin_alloca (sizeof(int)*(nbEBands
)));

 maxDepth = dynalloc_analysis(bandLogE, bandLogE2, oldBandE, nbEBands, start, end, C, offsets,
       st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
       eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc, &st->analysis, importance, spread_weight, tone_freq, toneishness);

 ALLOC(tf_res, nbEBands, int)tf_res = ((int*)__builtin_alloca (sizeof(int)*(nbEBands)));
 /* Disable variable tf resolution for hybrid and at very low bitrate */
 if (enable_tf_analysis)
 {
    int lambda;
    lambda = IMAX(80, 20480/effectiveBytes + 2)((80) > (20480/effectiveBytes + 2) ? (80) : (20480/effectiveBytes
 + 2));
    tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, tf_estimate, tf_chan, importance);
    for (i=effEnd;i<end;i++)
       tf_res[i] = tf_res[effEnd-1];
 } else if (hybrid && weak_transient)
 {
    /* For weak transients, we rely on the fact that improving time resolution using
       TF on a long window is imperfect and will not result in an energy collapse at
       low bitrate. */
    for (i=0;i<end;i++)
       tf_res[i] = 1;
    tf_select=0;
 } else if (hybrid && effectiveBytes<15 && st->silk_info.signalType != 2)
 {
    /* For low bitrate hybrid, we force temporal resolution to 5 ms rather than 2.5 ms. */
    for (i=0;i<end;i++)
       tf_res[i] = 0;
    tf_select=isTransient;
 } else {
    for (i=0;i<end;i++)
       tf_res[i] = isTransient;
    tf_select=0;
 }

 ALLOC(error, C*nbEBands, celt_glog)error = ((celt_glog*)__builtin_alloca (sizeof(celt_glog)*(C*nbEBands
)));
 c=0;
 do {
    for (i=start;i<end;i++)
    {
       /* When the energy is stable, slightly bias energy quantization towards
          the previous error to make the gain more stable (a constant offset is
          better than fluctuations). */
       if (ABS32(SUB32(bandLogE[i+c*nbEBands], oldBandE[i+c*nbEBands]))((float)fabs(((bandLogE[i+c*nbEBands])-(oldBandE[i+c*nbEBands
])))) < GCONST(2.f)(2.f))
       {
          bandLogE[i+c*nbEBands] -= MULT16_32_Q15(QCONST16(0.25f, 15), energyError[i+c*nbEBands])(((0.25f))*(energyError[i+c*nbEBands]));
       }
    }
 } while (++c < C);
 quant_coarse_energy(mode, start, end, effEnd, bandLogE,
       oldBandE, total_bits, error, enc,
       C, LM, nbAvailableBytes, st->force_intra,
       &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);

 tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc);

 if (ec_tell(enc)+4<=total_bits)
 {
    if (st->lfe)
    {
       st->tapset_decision = 0;
       st->spread_decision = SPREAD_NORMAL(2);
    } else if (hybrid)
    {
       if (st->complexity == 0)
          st->spread_decision = SPREAD_NONE(0);
       else if (isTransient)
          st->spread_decision = SPREAD_NORMAL(2);
       else
          st->spread_decision = SPREAD_AGGRESSIVE(3);
    } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
    {
       if (st->complexity == 0)
          st->spread_decision = SPREAD_NONE(0);
       else
          st->spread_decision = SPREAD_NORMAL(2);
    } else {
       /* Disable new spreading+tapset estimator until we can show it works
          better than the old one. So far it seems like spreading_decision()
          works best. */
2206#if 0
       if (st->analysis.valid)
       {
          static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15)(.6f), -QCONST16(.2f, 15)(.2f), -QCONST16(.07f, 15)(.07f)};
          static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15)(.15f), QCONST16(.07f, 15)(.07f), QCONST16(.02f, 15)(.02f)};
          static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15)(.0f), QCONST16(.15f, 15)(.15f)};
          static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15)(.1f), QCONST16(.05f, 15)(.05f)};
          st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
          st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
       } else
2216#endif
       {
          st->spread_decision = spreading_decision(mode, X,
                &st->tonal_average, st->spread_decision, &st->hf_average,
                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M, spread_weight);
       }
       /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
       /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
    }
    ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
 } else {
    st->spread_decision = SPREAD_NORMAL(2);
 }

 /* For LFE, everything interesting is in the first band */
 if (st->lfe)
    offsets[0] = IMIN(8, effectiveBytes/3)((8) < (effectiveBytes/3) ? (8) : (effectiveBytes/3));
 ALLOC(cap, nbEBands, int)cap = ((int*)__builtin_alloca (sizeof(int)*(nbEBands)));
 init_caps(mode,cap,LM,C);

 dynalloc_logp = 6;
 total_bits<<=BITRES3;
 total_boost = 0;
 tell = ec_tell_frac(enc);
 for (i=start;i<end;i++)
 {
    int width, quanta;
    int dynalloc_loop_logp;
    int boost;
    int j;
    width = C*(eBands[i+1]-eBands[i])<<LM;
    /* quanta is 6 bits, but no more than 1 bit/sample
       and no less than 1/8 bit/sample */
    quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width))((width<<3) < (((6<<3) > (width) ? (6<<
3) : (width))) ? (width<<3) : (((6<<3) > (width
) ? (6<<3) : (width))));
    dynalloc_loop_logp = dynalloc_logp;
    boost = 0;
    for (j = 0; tell+(dynalloc_loop_logp<<BITRES3) < total_bits-total_boost
          && boost < cap[i]; j++)
    {
       int flag;
       flag = j<offsets[i];
       ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
       tell = ec_tell_frac(enc);
       if (!flag)
          break;
       boost += quanta;
       total_boost += quanta;
       dynalloc_loop_logp = 1;
    }
    /* Making dynalloc more likely */
    if (j)
       dynalloc_logp = IMAX(2, dynalloc_logp-1)((2) > (dynalloc_logp-1) ? (2) : (dynalloc_logp-1));
    offsets[i] = boost;
 }

 if (C==2)
 {
    static const opus_val16 intensity_thresholds[21]=
    /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
      {  1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134};
    static const opus_val16 intensity_histeresis[21]=
      {  1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6,  8, 8};

    /* Always use MS for 2.5 ms frames until we can do a better analysis */
    if (LM!=0)
       dual_stereo = stereo_analysis(mode, X, LM, N);

    st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000),
          intensity_thresholds, intensity_histeresis, 21, st->intensity);
    st->intensity = IMIN(end,IMAX(start, st->intensity))((end) < (((start) > (st->intensity) ? (start) : (st
->intensity))) ? (end) : (((start) > (st->intensity)
 ? (start) : (st->intensity))));
 }

 alloc_trim = 5;
 if (tell+(6<<BITRES3) <= total_bits - total_boost)
 {
    if (start > 0 || st->lfe)
    {
       st->stereo_saving = 0;
       alloc_trim = 5;
    } else {
       alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
          end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate,
          st->intensity, surround_trim, equiv_rate, st->arch);
    }
    ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
    tell = ec_tell_frac(enc);
 }

 /* Variable bitrate */
 if (vbr_rate>0)
 {
   opus_val16 alpha;
   opus_int32 delta;
   /* The target rate in 8th bits per frame */
   opus_int32 target, base_target;
   opus_int32 min_allowed;
   int lm_diff = mode->maxLM - LM;

   /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
      The CELT allocator will just not be able to use more than that anyway. */
   nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM))((nbCompressedBytes) < (1275>>(3-LM)) ? (nbCompressedBytes
) : (1275>>(3-LM)));
   if (!hybrid)
   {
      base_target = vbr_rate - ((40*C+20)<<BITRES3);
   } else {
      base_target = IMAX(0, vbr_rate - ((9*C+4)<<BITRES))((0) > (vbr_rate - ((9*C+4)<<3)) ? (0) : (vbr_rate -
 ((9*C+4)<<3)));
   }

   if (st->constrained_vbr)
      base_target += (st->vbr_offset>>lm_diff);

   if (!hybrid)
   {
      target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate,
         st->lastCodedBands, C, st->intensity, st->constrained_vbr,
         st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
         st->lfe, st->energy_mask!=NULL((void*)0), surround_masking,
         temporal_vbr);
   } else {
      target = base_target;
      /* Tonal frames (offset<100) need more bits than noisy (offset>100) ones. */
      if (st->silk_info.offset < 100) target += 12 << BITRES3 >> (3-LM);
      if (st->silk_info.offset > 100) target -= 18 << BITRES3 >> (3-LM);
      /* Boosting bitrate on transients and vowels with significant temporal
         spikes. */
      target += (opus_int32)MULT16_16_Q14(tf_estimate-QCONST16(.25f,14), (50<<BITRES))((tf_estimate-(.25f))*((50<<3)));
      /* If we have a strong transient, let's make sure it has enough bits to code
         the first two bands, so that it can use folding rather than noise. */
      if (tf_estimate > QCONST16(.7f,14)(.7f))
         target = IMAX(target, 50<<BITRES)((target) > (50<<3) ? (target) : (50<<3));
   }
   /* The current offset is removed from the target and the space used
      so far is added*/
   target=target+tell;
   /* In VBR mode the frame size must not be reduced so much that it would
       result in the encoder running out of bits.
      The margin of 2 bytes ensures that none of the bust-prevention logic
       in the decoder will have triggered so far. */
   min_allowed = ((tell+total_boost+(1<<(BITRES3+3))-1)>>(BITRES3+3)) + 2;
   /* Take into account the 37 bits we need to have left in the packet to
      signal a redundant frame in hybrid mode. Creating a shorter packet would
      create an entropy coder desync. */
   if (hybrid)
      min_allowed = IMAX(min_allowed, (tell0_frac+(37<<BITRES)+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3))((min_allowed) > ((tell0_frac+(37<<3)+total_boost+(1
<<(3 +3))-1)>>(3 +3)) ? (min_allowed) : ((tell0_frac
+(37<<3)+total_boost+(1<<(3 +3))-1)>>(3 +3)
));

   nbAvailableBytes = (target+(1<<(BITRES3+2)))>>(BITRES3+3);
   nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes)((min_allowed) > (nbAvailableBytes) ? (min_allowed) : (nbAvailableBytes
));
   nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes)((nbCompressedBytes) < (nbAvailableBytes) ? (nbCompressedBytes
) : (nbAvailableBytes));

   /* By how much did we "miss" the target on that frame */
   delta = target - vbr_rate;

   target=nbAvailableBytes<<(BITRES3+3);

   /*If the frame is silent we don't adjust our drift, otherwise
     the encoder will shoot to very high rates after hitting a
     span of silence, but we do allow the bitres to refill.
     This means that we'll undershoot our target in CVBR/VBR modes
     on files with lots of silence. */
   if(silence)
   {
     nbAvailableBytes = 2;
     target = 2*8<<BITRES3;
     delta = 0;
   }

   if (st->vbr_count < 970)
   {
      st->vbr_count++;
      alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16))(1.f/(((st->vbr_count+20))));
   } else
      alpha = QCONST16(.001f,15)(.001f);
   /* How many bits have we used in excess of what we're allowed */
   if (st->constrained_vbr)
      st->vbr_reservoir += target - vbr_rate;
   /*printf ("%d\n", st->vbr_reservoir);*/

   /* Compute the offset we need to apply in order to reach the target */
   if (st->constrained_vbr)
   {
      st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift)((alpha)*((delta*(1<<lm_diff))-st->vbr_offset-st->
vbr_drift));
      st->vbr_offset = -st->vbr_drift;
   }
   /*printf ("%d\n", st->vbr_drift);*/

   if (st->constrained_vbr && st->vbr_reservoir < 0)
   {
      /* We're under the min value -- increase rate */
      int adjust = (-st->vbr_reservoir)/(8<<BITRES3);
      /* Unless we're just coding silence */
      nbAvailableBytes += silence?0:adjust;
      st->vbr_reservoir = 0;
      /*printf ("+%d\n", adjust);*/
   }
   nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes)((nbCompressedBytes) < (nbAvailableBytes) ? (nbCompressedBytes
) : (nbAvailableBytes));
   /*printf("%d\n", nbCompressedBytes*50*8);*/
   /* This moves the raw bits to take into account the new compressed size */
   ec_enc_shrink(enc, nbCompressedBytes);
 }

 /* Bit allocation */
 ALLOC(fine_quant, nbEBands, int)fine_quant = ((int*)__builtin_alloca (sizeof(int)*(nbEBands))
);
 ALLOC(pulses, nbEBands, int)pulses = ((int*)__builtin_alloca (sizeof(int)*(nbEBands)));
 ALLOC(fine_priority, nbEBands, int)fine_priority = ((int*)__builtin_alloca (sizeof(int)*(nbEBands
)));

 /* bits =           packet size                    - where we are - safety*/
 bits = (((opus_int32)nbCompressedBytes*8)<<BITRES3) - (opus_int32)ec_tell_frac(enc) - 1;
 anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES3) ? (1<<BITRES3) : 0;
 bits -= anti_collapse_rsv;
 signalBandwidth = end-1;
2426#ifndef DISABLE_FLOAT_API
 if (st->analysis.valid)
 {
    int min_bandwidth;
    if (equiv_rate < (opus_int32)32000*C)
       min_bandwidth = 13;
    else if (equiv_rate < (opus_int32)48000*C)
       min_bandwidth = 16;
    else if (equiv_rate < (opus_int32)60000*C)
       min_bandwidth = 18;
    else  if (equiv_rate < (opus_int32)80000*C)
       min_bandwidth = 19;
    else
       min_bandwidth = 20;
    signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth)((st->analysis.bandwidth) > (min_bandwidth) ? (st->analysis
.bandwidth) : (min_bandwidth));
 }
2442#endif
 if (st->lfe)
    signalBandwidth = 1;
 codedBands = clt_compute_allocation(mode, start, end, offsets, cap,
       alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
       fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
 if (st->lastCodedBands)
    st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands))((st->lastCodedBands+1) < (((st->lastCodedBands-1) >
 (codedBands) ? (st->lastCodedBands-1) : (codedBands))) ? (
st->lastCodedBands+1) : (((st->lastCodedBands-1) > (
codedBands) ? (st->lastCodedBands-1) : (codedBands))));
 else
    st->lastCodedBands = codedBands;

 quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C);

 /* Residual quantisation */
 ALLOC(collapse_masks, C*nbEBands, unsigned char)collapse_masks = ((unsigned char*)__builtin_alloca (sizeof(unsigned
 char)*(C*nbEBands)));
 quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL((void*)0), collapse_masks,
       bandE, pulses, shortBlocks, st->spread_decision,
       dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES3)-anti_collapse_rsv,
       balance, enc, LM, codedBands, &st->rng, st->complexity, st->arch, st->disable_inv);

 if (anti_collapse_rsv > 0)
 {
    anti_collapse_on = st->consec_transient<2;
2465#ifdef FUZZING
    anti_collapse_on = rand()&0x1;
2467#endif
    ec_enc_bits(enc, anti_collapse_on, 1);
 }
 quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
 OPUS_CLEAR(energyError, nbEBands*CC)(memset((energyError), 0, (nbEBands*CC)*sizeof(*(energyError)
)));
 c=0;
 do {
    for (i=start;i<end;i++)
    {
       energyError[i+c*nbEBands] = MAXG(-GCONST(0.5f), MING(GCONST(0.5f), error[i+c*nbEBands]))((-(0.5f)) > ((((0.5f)) < (error[i+c*nbEBands]) ? ((0.5f
)) : (error[i+c*nbEBands]))) ? (-(0.5f)) : ((((0.5f)) < (error
[i+c*nbEBands]) ? ((0.5f)) : (error[i+c*nbEBands]))));
    }
 } while (++c < C);

 if (silence)
 {
    for (i=0;i<C*nbEBands;i++)
       oldBandE[i] = -GCONST(28.f)(28.f);
 }

2486#ifdef RESYNTH
 /* Re-synthesis of the coded audio if required */
 {
    celt_sig *out_mem[2];

    if (anti_collapse_on)
    {
       anti_collapse(mode, X, collapse_masks, LM, C, N,
             start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng, 1, st->arch);
    }

    c=0; do {
       OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2)(memmove((st->syn_mem[c]), (st->syn_mem[c]+N), (2*1024 -
N+overlap/2)*sizeof(*(st->syn_mem[c])) + 0*((st->syn_mem
[c])-(st->syn_mem[c]+N)) ));
    } while (++c<CC);

    c=0; do {
       out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD1024-N;
    } while (++c<CC);

    celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd,
                   C, CC, isTransient, LM, st->upsample, silence, st->arch);

    c=0; do {
       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD)((st->prefilter_period) > (15) ? (st->prefilter_period
) : (15));
       st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD)((st->prefilter_period_old) > (15) ? (st->prefilter_period_old
) : (15));
       comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
             st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
             mode->window, overlap, st->arch);
       if (LM!=0)
          comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
                st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
                mode->window, overlap, st->arch);
    } while (++c<CC);

    /* We reuse freq[] as scratch space for the de-emphasis */
    deemphasis(out_mem, (opus_res*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD, 0);
    st->prefilter_period_old = st->prefilter_period;
    st->prefilter_gain_old = st->prefilter_gain;
    st->prefilter_tapset_old = st->prefilter_tapset;
 }
2526#endif

 st->prefilter_period = pitch_index;
 st->prefilter_gain = gain1;
 st->prefilter_tapset = prefilter_tapset;
2531#ifdef RESYNTH
 if (LM!=0)
 {
    st->prefilter_period_old = st->prefilter_period;
    st->prefilter_gain_old = st->prefilter_gain;
    st->prefilter_tapset_old = st->prefilter_tapset;
 }
2538#endif

 if (CC==2&&C==1) {
    OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands)(memcpy((&oldBandE[nbEBands]), (oldBandE), (nbEBands)*sizeof
(*(&oldBandE[nbEBands])) + 0*((&oldBandE[nbEBands])-(
oldBandE)) ));
 }

 if (!isTransient)
 {
    OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands)(memcpy((oldLogE2), (oldLogE), (CC*nbEBands)*sizeof(*(oldLogE2
)) + 0*((oldLogE2)-(oldLogE)) ));
    OPUS_COPY(oldLogE, oldBandE, CC*nbEBands)(memcpy((oldLogE), (oldBandE), (CC*nbEBands)*sizeof(*(oldLogE
)) + 0*((oldLogE)-(oldBandE)) ));
 } else {
    for (i=0;i<CC*nbEBands;i++)
       oldLogE[i] = MING(oldLogE[i], oldBandE[i])((oldLogE[i]) < (oldBandE[i]) ? (oldLogE[i]) : (oldBandE[i
]));
 }
 /* In case start or end were to change */
 c=0; do
 {
    for (i=0;i<start;i++)
    {
       oldBandE[c*nbEBands+i]=0;
       oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-GCONST(28.f)(28.f);
    }
    for (i=end;i<nbEBands;i++)
    {
       oldBandE[c*nbEBands+i]=0;
       oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-GCONST(28.f)(28.f);
    }
 } while (++c<CC);

 if (isTransient || transient_got_disabled)
    st->consec_transient++;
 else
    st->consec_transient=0;
 st->rng = enc->rng;

 /* If there's any room left (can only happen for very high rates),
    it's already filled with zeros */
 ec_enc_done(enc);

2577#ifdef CUSTOM_MODES
 if (st->signalling)
    nbCompressedBytes++;
2580#endif

 RESTORE_STACK;
 if (ec_get_error(enc))
    return OPUS_INTERNAL_ERROR-3;
 else
    return nbCompressedBytes;
2587}


2590#ifdef CUSTOM_MODES

2592#if defined(FIXED_POINT) && !defined(ENABLE_RES24)
2593int opus_custom_encode(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2594{
 return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL((void*)0));
2596}
2597#else
2598int opus_custom_encode(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2599{
 int j, ret, C, N;
 VARDECL(opus_res, in)opus_res *in;
 ALLOC_STACK;

 if (pcm==NULL((void*)0))
    return OPUS_BAD_ARG-1;

 C = st->channels;
 N = frame_size;
 ALLOC(in, C*N, opus_res)in = ((opus_res*)__builtin_alloca (sizeof(opus_res)*(C*N)));

 for (j=0;j<C*N;j++)
   in[j] = INT16TORES(pcm[j])((pcm[j])*(1/32768.f));

 ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL((void*)0));
2615#ifdef RESYNTH
 for (j=0;j<C*N;j++)
    ((opus_int16*)pcm)[j]=RES2INT16(in[j])FLOAT2INT16(in[j]);
2618#endif
 RESTORE_STACK;
 return ret;
2621}
2622#endif


2625#if defined(FIXED_POINT) && defined(ENABLE_RES24)
2626int opus_custom_encode24(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const opus_int32 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2627{
 return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL((void*)0));
2629}
2630#else
2631int opus_custom_encode24(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const opus_int32 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2632{
 int j, ret, C, N;
 VARDECL(opus_res, in)opus_res *in;
 ALLOC_STACK;

 if (pcm==NULL((void*)0))
    return OPUS_BAD_ARG-1;

 C = st->channels;
 N = frame_size;
 ALLOC(in, C*N, opus_res)in = ((opus_res*)__builtin_alloca (sizeof(opus_res)*(C*N)));

 for (j=0;j<C*N;j++)
   in[j] = INT24TORES(pcm[j])((1.f/32768.f/256.)*(pcm[j]));

 ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL((void*)0));
2648#ifdef RESYNTH
 for (j=0;j<C*N;j++)
    ((opus_int32*)pcm)[j]=RES2INT24(in[j])float2int(32768.f*256.f*(in[j]));
2651#endif
 RESTORE_STACK;
 return ret;
2654}
2655#endif


2658#ifndef DISABLE_FLOAT_API

2660# if !defined(FIXED_POINT)
2661int opus_custom_encode_float(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2662{
 return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL((void*)0));
2664}
2665# else
2666int opus_custom_encode_float(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2667{
 int j, ret, C, N;
 VARDECL(opus_res, in)opus_res *in;
 ALLOC_STACK;

 if (pcm==NULL((void*)0))
    return OPUS_BAD_ARG-1;

 C = st->channels;
 N = frame_size;
 ALLOC(in, C*N, opus_res)in = ((opus_res*)__builtin_alloca (sizeof(opus_res)*(C*N)));

 for (j=0;j<C*N;j++)
   in[j] = FLOAT2RES(pcm[j])(pcm[j]);

 ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL((void*)0));
2683#ifdef RESYNTH
 for (j=0;j<C*N;j++)
    ((float*)pcm)[j]=RES2FLOAT(in[j])(in[j]);
2686#endif
 RESTORE_STACK;
 return ret;
2689}
2690# endif

2692#endif

2694#endif /* CUSTOM_MODES */

2696int opus_custom_encoder_ctl(CELTEncoderOpusCustomEncoder * OPUS_RESTRICTrestrict st, int request, ...)
2697{
 va_list ap;

 va_start(ap, request)__builtin_va_start(ap, request);
 switch (request)
 {
    case OPUS_SET_COMPLEXITY_REQUEST4010:
    {
       int value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<0 || value>10)
          goto bad_arg;
       st->complexity = value;
    }
    break;
    case CELT_SET_START_BAND_REQUEST10010:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<0 || value>=st->mode->nbEBands)
          goto bad_arg;
       st->start = value;
    }
    break;
    case CELT_SET_END_BAND_REQUEST10012:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<1 || value>st->mode->nbEBands)
          goto bad_arg;
       st->end = value;
    }
    break;
    case CELT_SET_PREDICTION_REQUEST10002:
    {
       int value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<0 || value>2)
          goto bad_arg;
       st->disable_pf = value<=1;
       st->force_intra = value==0;
    }
    break;
    case OPUS_SET_PACKET_LOSS_PERC_REQUEST4014:
    {
       int value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<0 || value>100)
          goto bad_arg;
       st->loss_rate = value;
    }
    break;
    case OPUS_SET_VBR_CONSTRAINT_REQUEST4020:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       st->constrained_vbr = value;
    }
    break;
    case OPUS_SET_VBR_REQUEST4006:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       st->vbr = value;
    }
    break;
    case OPUS_SET_BITRATE_REQUEST4002:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<=500 && value!=OPUS_BITRATE_MAX-1)
          goto bad_arg;
       value = IMIN(value, 260000*st->channels)((value) < (260000*st->channels) ? (value) : (260000*st
->channels));
       st->bitrate = value;
    }
    break;
    case CELT_SET_CHANNELS_REQUEST10008:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       if (value<1 || value>2)
          goto bad_arg;
       st->stream_channels = value;
    }
    break;
    case OPUS_SET_LSB_DEPTH_REQUEST4036:
    {
        opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
        if (value<8 || value>24)
           goto bad_arg;
        st->lsb_depth=value;
    }
    break;
    case OPUS_GET_LSB_DEPTH_REQUEST4037:
    {
        opus_int32 *value = va_arg(ap, opus_int32*)__builtin_va_arg(ap, opus_int32*);
        *value=st->lsb_depth;
    }
    break;
    case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST4046:
    {
        opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
        if(value<0 || value>1)
        {
           goto bad_arg;
        }
        st->disable_inv = value;
    }
    break;
    case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST4047:
    {
        opus_int32 *value = va_arg(ap, opus_int32*)__builtin_va_arg(ap, opus_int32*);
        if (!value)
        {
           goto bad_arg;
        }
        *value = st->disable_inv;
    }
    break;
    case OPUS_RESET_STATE4028:
    {
       int i;
       celt_glog *oldBandE, *oldLogE, *oldLogE2;
       oldBandE = (celt_glog*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD1024));
       oldLogE = oldBandE + st->channels*st->mode->nbEBands;
       oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
       OPUS_CLEAR((char*)&st->ENCODER_RESET_START,(memset(((char*)&st->rng), 0, (opus_custom_encoder_get_size
(st->mode, st->channels)- ((char*)&st->rng - (char
*)st))*sizeof(*((char*)&st->rng))))
             opus_custom_encoder_get_size(st->mode, st->channels)-(memset(((char*)&st->rng), 0, (opus_custom_encoder_get_size
(st->mode, st->channels)- ((char*)&st->rng - (char
*)st))*sizeof(*((char*)&st->rng))))
             ((char*)&st->ENCODER_RESET_START - (char*)st))(memset(((char*)&st->rng), 0, (opus_custom_encoder_get_size
(st->mode, st->channels)- ((char*)&st->rng - (char
*)st))*sizeof(*((char*)&st->rng))));
       for (i=0;i<st->channels*st->mode->nbEBands;i++)
          oldLogE[i]=oldLogE2[i]=-GCONST(28.f)(28.f);
       st->vbr_offset = 0;
       st->delayedIntra = 1;
       st->spread_decision = SPREAD_NORMAL(2);
       st->tonal_average = 256;
       st->hf_average = 0;
       st->tapset_decision = 0;
    }
    break;
2827#ifdef CUSTOM_MODES
    case CELT_SET_INPUT_CLIPPING_REQUEST10004:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       st->clip = value;
    }
    break;
2834#endif
    case CELT_SET_SIGNALLING_REQUEST10016:
    {
       opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
       st->signalling = value;
    }
    break;
    case CELT_SET_ANALYSIS_REQUEST10022:
    {
       AnalysisInfo *info = va_arg(ap, AnalysisInfo *)__builtin_va_arg(ap, AnalysisInfo *);
       if (info)
          OPUS_COPY(&st->analysis, info, 1)(memcpy((&st->analysis), (info), (1)*sizeof(*(&st->
analysis)) + 0*((&st->analysis)-(info)) ));
    }
    break;
    case CELT_SET_SILK_INFO_REQUEST10028:
    {
       SILKInfo *info = va_arg(ap, SILKInfo *)__builtin_va_arg(ap, SILKInfo *);
       if (info)
          OPUS_COPY(&st->silk_info, info, 1)(memcpy((&st->silk_info), (info), (1)*sizeof(*(&st
->silk_info)) + 0*((&st->silk_info)-(info)) ));
    }
    break;
    case CELT_GET_MODE_REQUEST10015:
    {
       const CELTModeOpusCustomMode ** value = va_arg(ap, const CELTMode**)__builtin_va_arg(ap, const OpusCustomMode**);
       if (value==0)
          goto bad_arg;
       *value=st->mode;
    }
    break;
    case OPUS_GET_FINAL_RANGE_REQUEST4031:
    {
       opus_uint32 * value = va_arg(ap, opus_uint32 *)__builtin_va_arg(ap, opus_uint32 *);
       if (value==0)
          goto bad_arg;
       *value=st->rng;
    }
    break;
    case OPUS_SET_LFE_REQUEST10024:
    {
        opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
        st->lfe = value;
    }
    break;
    case OPUS_SET_ENERGY_MASK_REQUEST10026:
    {
       celt_glog *value = va_arg(ap, celt_glog*)__builtin_va_arg(ap, celt_glog*);
        st->energy_mask = value;
    }
    break;
    default:
       goto bad_request;
 }
 va_end(ap)__builtin_va_end(ap);
 return OPUS_OK0;
2888bad_arg:
 va_end(ap)__builtin_va_end(ap);
 return OPUS_BAD_ARG-1;
2891bad_request:
 va_end(ap)__builtin_va_end(ap);
 return OPUS_UNIMPLEMENTED-5;
2894}