@scrypted/libav 1.0.169 → 1.0.171

package/opus/celt/ecintrin.h

@@ -1,91 +0,0 @@
-/* Copyright (c) 2003-2008 Timothy B. Terriberry
-   Copyright (c) 2008 Xiph.Org Foundation */
-/*
-   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.
-*/
-
-/*Some common macros for potential platform-specific optimization.*/
-#include "opus_types.h"
-#include <math.h>
-#include <limits.h>
-#include "arch.h"
-#if !defined(_ecintrin_H)
-# define _ecintrin_H (1)
-
-/*Some specific platforms may have optimized intrinsic or OPUS_INLINE assembly
-   versions of these functions which can substantially improve performance.
-  We define macros for them to allow easy incorporation of these non-ANSI
-   features.*/
-
-/*Modern gcc (4.x) can compile the naive versions of min and max with cmov if
-   given an appropriate architecture, but the branchless bit-twiddling versions
-   are just as fast, and do not require any special target architecture.
-  Earlier gcc versions (3.x) compiled both code to the same assembly
-   instructions, because of the way they represented ((_b)>(_a)) internally.*/
-# define EC_MINI(_a,_b)      ((_a)+(((_b)-(_a))&-((_b)<(_a))))
-
-/*Count leading zeros.
-  This macro should only be used for implementing ec_ilog(), if it is defined.
-  All other code should use EC_ILOG() instead.*/
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-#if defined(_MSC_VER) && (_MSC_VER >= 1910)
-# include <intrin0.h> /* Improve compiler throughput. */
-#else
-# include <intrin.h>
-#endif
-/*In _DEBUG mode this is not an intrinsic by default.*/
-# pragma intrinsic(_BitScanReverse)
-
-static __inline int ec_bsr(unsigned long _x){
-  unsigned long ret;
-  _BitScanReverse(&ret,_x);
-  return (int)ret;
-}
-# define EC_CLZ0    (1)
-# define EC_CLZ(_x) (-ec_bsr(_x))
-#elif defined(ENABLE_TI_DSPLIB)
-# include "dsplib.h"
-# define EC_CLZ0    (31)
-# define EC_CLZ(_x) (_lnorm(_x))
-#elif __GNUC_PREREQ(3,4)
-# if INT_MAX>=2147483647
-#  define EC_CLZ0    ((int)sizeof(unsigned)*CHAR_BIT)
-#  define EC_CLZ(_x) (__builtin_clz(_x))
-# elif LONG_MAX>=2147483647L
-#  define EC_CLZ0    ((int)sizeof(unsigned long)*CHAR_BIT)
-#  define EC_CLZ(_x) (__builtin_clzl(_x))
-# endif
-#endif
-
-#if defined(EC_CLZ)
-/*Note that __builtin_clz is not defined when _x==0, according to the gcc
-   documentation (and that of the BSR instruction that implements it on x86).
-  The majority of the time we can never pass it zero.
-  When we need to, it can be special cased.*/
-# define EC_ILOG(_x) (EC_CLZ0-EC_CLZ(_x))
-#else
-int ec_ilog(opus_uint32 _v);
-# define EC_ILOG(_x) (ec_ilog(_x))
-#endif
-#endif

package/opus/celt/entcode.c

@@ -1,153 +0,0 @@
-/* Copyright (c) 2001-2011 Timothy B. Terriberry
-*/
-/*
-   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.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "entcode.h"
-#include "arch.h"
-
-#if !defined(EC_CLZ)
-/*This is a fallback for systems where we don't know how to access
-   a BSR or CLZ instruction (see ecintrin.h).
-  If you are optimizing Opus on a new platform and it has a native CLZ or
-   BZR (e.g. cell, MIPS, x86, etc) then making it available to Opus will be
-   an easy performance win.*/
-int ec_ilog(opus_uint32 _v){
-  /*On a Pentium M, this branchless version tested as the fastest on
-     1,000,000,000 random 32-bit integers, edging out a similar version with
-     branches, and a 256-entry LUT version.*/
-  int ret;
-  int m;
-  ret=!!_v;
-  m=!!(_v&0xFFFF0000)<<4;
-  _v>>=m;
-  ret|=m;
-  m=!!(_v&0xFF00)<<3;
-  _v>>=m;
-  ret|=m;
-  m=!!(_v&0xF0)<<2;
-  _v>>=m;
-  ret|=m;
-  m=!!(_v&0xC)<<1;
-  _v>>=m;
-  ret|=m;
-  ret+=!!(_v&0x2);
-  return ret;
-}
-#endif
-
-#if 1
-/* This is a faster version of ec_tell_frac() that takes advantage
-   of the low (1/8 bit) resolution to use just a linear function
-   followed by a lookup to determine the exact transition thresholds. */
-opus_uint32 ec_tell_frac(ec_ctx *_this){
-  static const unsigned correction[8] =
-    {35733, 38967, 42495, 46340,
-     50535, 55109, 60097, 65535};
-  opus_uint32 nbits;
-  opus_uint32 r;
-  int         l;
-  unsigned    b;
-  nbits=_this->nbits_total<<BITRES;
-  l=EC_ILOG(_this->rng);
-  r=_this->rng>>(l-16);
-  b = (r>>12)-8;
-  b += r>correction[b];
-  l = (l<<3)+b;
-  return nbits-l;
-}
-#else
-opus_uint32 ec_tell_frac(ec_ctx *_this){
-  opus_uint32 nbits;
-  opus_uint32 r;
-  int         l;
-  int         i;
-  /*To handle the non-integral number of bits still left in the encoder/decoder
-     state, we compute the worst-case number of bits of val that must be
-     encoded to ensure that the value is inside the range for any possible
-     subsequent bits.
-    The computation here is independent of val itself (the decoder does not
-     even track that value), even though the real number of bits used after
-     ec_enc_done() may be 1 smaller if rng is a power of two and the
-     corresponding trailing bits of val are all zeros.
-    If we did try to track that special case, then coding a value with a
-     probability of 1/(1<<n) might sometimes appear to use more than n bits.
-    This may help explain the surprising result that a newly initialized
-     encoder or decoder claims to have used 1 bit.*/
-  nbits=_this->nbits_total<<BITRES;
-  l=EC_ILOG(_this->rng);
-  r=_this->rng>>(l-16);
-  for(i=BITRES;i-->0;){
-    int b;
-    r=r*r>>15;
-    b=(int)(r>>16);
-    l=l<<1|b;
-    r>>=b;
-  }
-  return nbits-l;
-}
-#endif
-
-#ifdef USE_SMALL_DIV_TABLE
-/* Result of 2^32/(2*i+1), except for i=0. */
-const opus_uint32 SMALL_DIV_TABLE[129] = {
-   0xFFFFFFFF, 0x55555555, 0x33333333, 0x24924924,
-   0x1C71C71C, 0x1745D174, 0x13B13B13, 0x11111111,
-   0x0F0F0F0F, 0x0D79435E, 0x0C30C30C, 0x0B21642C,
-   0x0A3D70A3, 0x097B425E, 0x08D3DCB0, 0x08421084,
-   0x07C1F07C, 0x07507507, 0x06EB3E45, 0x06906906,
-   0x063E7063, 0x05F417D0, 0x05B05B05, 0x0572620A,
-   0x05397829, 0x05050505, 0x04D4873E, 0x04A7904A,
-   0x047DC11F, 0x0456C797, 0x04325C53, 0x04104104,
-   0x03F03F03, 0x03D22635, 0x03B5CC0E, 0x039B0AD1,
-   0x0381C0E0, 0x0369D036, 0x03531DEC, 0x033D91D2,
-   0x0329161F, 0x03159721, 0x03030303, 0x02F14990,
-   0x02E05C0B, 0x02D02D02, 0x02C0B02C, 0x02B1DA46,
-   0x02A3A0FD, 0x0295FAD4, 0x0288DF0C, 0x027C4597,
-   0x02702702, 0x02647C69, 0x02593F69, 0x024E6A17,
-   0x0243F6F0, 0x0239E0D5, 0x02302302, 0x0226B902,
-   0x021D9EAD, 0x0214D021, 0x020C49BA, 0x02040810,
-   0x01FC07F0, 0x01F44659, 0x01ECC07B, 0x01E573AC,
-   0x01DE5D6E, 0x01D77B65, 0x01D0CB58, 0x01CA4B30,
-   0x01C3F8F0, 0x01BDD2B8, 0x01B7D6C3, 0x01B20364,
-   0x01AC5701, 0x01A6D01A, 0x01A16D3F, 0x019C2D14,
-   0x01970E4F, 0x01920FB4, 0x018D3018, 0x01886E5F,
-   0x0183C977, 0x017F405F, 0x017AD220, 0x01767DCE,
-   0x01724287, 0x016E1F76, 0x016A13CD, 0x01661EC6,
-   0x01623FA7, 0x015E75BB, 0x015AC056, 0x01571ED3,
-   0x01539094, 0x01501501, 0x014CAB88, 0x0149539E,
-   0x01460CBC, 0x0142D662, 0x013FB013, 0x013C995A,
-   0x013991C2, 0x013698DF, 0x0133AE45, 0x0130D190,
-   0x012E025C, 0x012B404A, 0x01288B01, 0x0125E227,
-   0x01234567, 0x0120B470, 0x011E2EF3, 0x011BB4A4,
-   0x01194538, 0x0116E068, 0x011485F0, 0x0112358E,
-   0x010FEF01, 0x010DB20A, 0x010B7E6E, 0x010953F3,
-   0x01073260, 0x0105197F, 0x0103091B, 0x01010101
-};
-#endif

package/opus/celt/entcode.h

@@ -1,152 +0,0 @@
-/* Copyright (c) 2001-2011 Timothy B. Terriberry
-   Copyright (c) 2008-2009 Xiph.Org Foundation */
-/*
-   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.
-*/
-
-#include "opus_types.h"
-#include "opus_defines.h"
-
-#if !defined(_entcode_H)
-# define _entcode_H (1)
-# include <limits.h>
-# include <stddef.h>
-# include "ecintrin.h"
-
-extern const opus_uint32 SMALL_DIV_TABLE[129];
-
-#ifdef OPUS_ARM_ASM
-#define USE_SMALL_DIV_TABLE
-#endif
-
-/*OPT: ec_window must be at least 32 bits, but if you have fast arithmetic on a
-   larger type, you can speed up the decoder by using it here.*/
-typedef opus_uint32           ec_window;
-typedef struct ec_ctx         ec_ctx;
-typedef struct ec_ctx         ec_enc;
-typedef struct ec_ctx         ec_dec;
-
-# define EC_WINDOW_SIZE ((int)sizeof(ec_window)*CHAR_BIT)
-
-/*The number of bits to use for the range-coded part of unsigned integers.*/
-# define EC_UINT_BITS   (8)
-
-/*The resolution of fractional-precision bit usage measurements, i.e.,
-   3 => 1/8th bits.*/
-# define BITRES 3
-
-/*The entropy encoder/decoder context.
-  We use the same structure for both, so that common functions like ec_tell()
-   can be used on either one.*/
-struct ec_ctx{
-   /*Buffered input/output.*/
-   unsigned char *buf;
-   /*The size of the buffer.*/
-   opus_uint32    storage;
-   /*The offset at which the last byte containing raw bits was read/written.*/
-   opus_uint32    end_offs;
-   /*Bits that will be read from/written at the end.*/
-   ec_window      end_window;
-   /*Number of valid bits in end_window.*/
-   int            nend_bits;
-   /*The total number of whole bits read/written.
-     This does not include partial bits currently in the range coder.*/
-   int            nbits_total;
-   /*The offset at which the next range coder byte will be read/written.*/
-   opus_uint32    offs;
-   /*The number of values in the current range.*/
-   opus_uint32    rng;
-   /*In the decoder: the difference between the top of the current range and
-      the input value, minus one.
-     In the encoder: the low end of the current range.*/
-   opus_uint32    val;
-   /*In the decoder: the saved normalization factor from ec_decode().
-     In the encoder: the number of oustanding carry propagating symbols.*/
-   opus_uint32    ext;
-   /*A buffered input/output symbol, awaiting carry propagation.*/
-   int            rem;
-   /*Nonzero if an error occurred.*/
-   int            error;
-};
-
-static OPUS_INLINE opus_uint32 ec_range_bytes(ec_ctx *_this){
-  return _this->offs;
-}
-
-static OPUS_INLINE unsigned char *ec_get_buffer(ec_ctx *_this){
-  return _this->buf;
-}
-
-static OPUS_INLINE int ec_get_error(ec_ctx *_this){
-  return _this->error;
-}
-
-/*Returns the number of bits "used" by the encoded or decoded symbols so far.
-  This same number can be computed in either the encoder or the decoder, and is
-   suitable for making coding decisions.
-  Return: The number of bits.
-          This will always be slightly larger than the exact value (e.g., all
-           rounding error is in the positive direction).*/
-static OPUS_INLINE int ec_tell(ec_ctx *_this){
-  return _this->nbits_total-EC_ILOG(_this->rng);
-}
-
-/*Returns the number of bits "used" by the encoded or decoded symbols so far.
-  This same number can be computed in either the encoder or the decoder, and is
-   suitable for making coding decisions.
-  Return: The number of bits scaled by 2**BITRES.
-          This will always be slightly larger than the exact value (e.g., all
-           rounding error is in the positive direction).*/
-opus_uint32 ec_tell_frac(ec_ctx *_this);
-
-/* Tested exhaustively for all n and for 1<=d<=256 */
-static OPUS_INLINE opus_uint32 celt_udiv(opus_uint32 n, opus_uint32 d) {
-   celt_sig_assert(d>0);
-#ifdef USE_SMALL_DIV_TABLE
-   if (d>256)
-      return n/d;
-   else {
-      opus_uint32 t, q;
-      t = EC_ILOG(d&-d);
-      q = (opus_uint64)SMALL_DIV_TABLE[d>>t]*(n>>(t-1))>>32;
-      return q+(n-q*d >= d);
-   }
-#else
-   return n/d;
-#endif
-}
-
-static OPUS_INLINE opus_int32 celt_sudiv(opus_int32 n, opus_int32 d) {
-   celt_sig_assert(d>0);
-#ifdef USE_SMALL_DIV_TABLE
-   if (n<0)
-      return -(opus_int32)celt_udiv(-n, d);
-   else
-      return celt_udiv(n, d);
-#else
-   return n/d;
-#endif
-}
-
-#endif

package/opus/celt/entdec.c

@@ -1,266 +0,0 @@
-/* Copyright (c) 2001-2011 Timothy B. Terriberry
-   Copyright (c) 2008-2009 Xiph.Org Foundation */
-/*
-   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.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stddef.h>
-#include "os_support.h"
-#include "arch.h"
-#include "entdec.h"
-#include "mfrngcod.h"
-
-/*A range decoder.
-  This is an entropy decoder based upon \cite{Mar79}, which is itself a
-   rediscovery of the FIFO arithmetic code introduced by \cite{Pas76}.
-  It is very similar to arithmetic encoding, except that encoding is done with
-   digits in any base, instead of with bits, and so it is faster when using
-   larger bases (i.e.: a byte).
-  The author claims an average waste of $\frac{1}{2}\log_b(2b)$ bits, where $b$
-   is the base, longer than the theoretical optimum, but to my knowledge there
-   is no published justification for this claim.
-  This only seems true when using near-infinite precision arithmetic so that
-   the process is carried out with no rounding errors.
-
-  An excellent description of implementation details is available at
-   http://www.arturocampos.com/ac_range.html
-  A recent work \cite{MNW98} which proposes several changes to arithmetic
-   encoding for efficiency actually re-discovers many of the principles
-   behind range encoding, and presents a good theoretical analysis of them.
-
-  End of stream is handled by writing out the smallest number of bits that
-   ensures that the stream will be correctly decoded regardless of the value of
-   any subsequent bits.
-  ec_tell() can be used to determine how many bits were needed to decode
-   all the symbols thus far; other data can be packed in the remaining bits of
-   the input buffer.
-  @PHDTHESIS{Pas76,
-    author="Richard Clark Pasco",
-    title="Source coding algorithms for fast data compression",
-    school="Dept. of Electrical Engineering, Stanford University",
-    address="Stanford, CA",
-    month=May,
-    year=1976
-  }
-  @INPROCEEDINGS{Mar79,
-   author="Martin, G.N.N.",
-   title="Range encoding: an algorithm for removing redundancy from a digitised
-    message",
-   booktitle="Video & Data Recording Conference",
-   year=1979,
-   address="Southampton",
-   month=Jul
-  }
-  @ARTICLE{MNW98,
-   author="Alistair Moffat and Radford Neal and Ian H. Witten",
-   title="Arithmetic Coding Revisited",
-   journal="{ACM} Transactions on Information Systems",
-   year=1998,
-   volume=16,
-   number=3,
-   pages="256--294",
-   month=Jul,
-   URL="http://www.stanford.edu/class/ee398a/handouts/papers/Moffat98ArithmCoding.pdf"
-  }*/
-
-static int ec_read_byte(ec_dec *_this){
-  return _this->offs<_this->storage?_this->buf[_this->offs++]:0;
-}
-
-static int ec_read_byte_from_end(ec_dec *_this){
-  return _this->end_offs<_this->storage?
-   _this->buf[_this->storage-++(_this->end_offs)]:0;
-}
-
-/*Normalizes the contents of val and rng so that rng lies entirely in the
-   high-order symbol.*/
-static void ec_dec_normalize(ec_dec *_this){
-  /*If the range is too small, rescale it and input some bits.*/
-  while(_this->rng<=EC_CODE_BOT){
-    int sym;
-    _this->nbits_total+=EC_SYM_BITS;
-    _this->rng<<=EC_SYM_BITS;
-    /*Use up the remaining bits from our last symbol.*/
-    sym=_this->rem;
-    /*Read the next value from the input.*/
-    _this->rem=ec_read_byte(_this);
-    /*Take the rest of the bits we need from this new symbol.*/
-    sym=(sym<<EC_SYM_BITS|_this->rem)>>(EC_SYM_BITS-EC_CODE_EXTRA);
-    /*And subtract them from val, capped to be less than EC_CODE_TOP.*/
-    _this->val=((_this->val<<EC_SYM_BITS)+(EC_SYM_MAX&~sym))&(EC_CODE_TOP-1);
-  }
-}
-
-void ec_dec_init(ec_dec *_this,unsigned char *_buf,opus_uint32 _storage){
-  _this->buf=_buf;
-  _this->storage=_storage;
-  _this->end_offs=0;
-  _this->end_window=0;
-  _this->nend_bits=0;
-  /*This is the offset from which ec_tell() will subtract partial bits.
-    The final value after the ec_dec_normalize() call will be the same as in
-     the encoder, but we have to compensate for the bits that are added there.*/
-  _this->nbits_total=EC_CODE_BITS+1
-   -((EC_CODE_BITS-EC_CODE_EXTRA)/EC_SYM_BITS)*EC_SYM_BITS;
-  _this->offs=0;
-  _this->rng=1U<<EC_CODE_EXTRA;
-  _this->rem=ec_read_byte(_this);
-  _this->val=_this->rng-1-(_this->rem>>(EC_SYM_BITS-EC_CODE_EXTRA));
-  _this->error=0;
-  /*Normalize the interval.*/
-  ec_dec_normalize(_this);
-}
-
-unsigned ec_decode(ec_dec *_this,unsigned _ft){
-  unsigned s;
-  _this->ext=celt_udiv(_this->rng,_ft);
-  s=(unsigned)(_this->val/_this->ext);
-  return _ft-EC_MINI(s+1,_ft);
-}
-
-unsigned ec_decode_bin(ec_dec *_this,unsigned _bits){
-   unsigned s;
-   _this->ext=_this->rng>>_bits;
-   s=(unsigned)(_this->val/_this->ext);
-   return (1U<<_bits)-EC_MINI(s+1U,1U<<_bits);
-}
-
-void ec_dec_update(ec_dec *_this,unsigned _fl,unsigned _fh,unsigned _ft){
-  opus_uint32 s;
-  s=IMUL32(_this->ext,_ft-_fh);
-  _this->val-=s;
-  _this->rng=_fl>0?IMUL32(_this->ext,_fh-_fl):_this->rng-s;
-  ec_dec_normalize(_this);
-}
-
-/*The probability of having a "one" is 1/(1<<_logp).*/
-int ec_dec_bit_logp(ec_dec *_this,unsigned _logp){
-  opus_uint32 r;
-  opus_uint32 d;
-  opus_uint32 s;
-  int         ret;
-  r=_this->rng;
-  d=_this->val;
-  s=r>>_logp;
-  ret=d<s;
-  if(!ret)_this->val=d-s;
-  _this->rng=ret?s:r-s;
-  ec_dec_normalize(_this);
-  return ret;
-}
-
-int ec_dec_icdf(ec_dec *_this,const unsigned char *_icdf,unsigned _ftb){
-  opus_uint32 r;
-  opus_uint32 d;
-  opus_uint32 s;
-  opus_uint32 t;
-  int         ret;
-  s=_this->rng;
-  d=_this->val;
-  r=s>>_ftb;
-  ret=-1;
-  do{
-    t=s;
-    s=IMUL32(r,_icdf[++ret]);
-  }
-  while(d<s);
-  _this->val=d-s;
-  _this->rng=t-s;
-  ec_dec_normalize(_this);
-  return ret;
-}
-
-int ec_dec_icdf16(ec_dec *_this,const opus_uint16 *_icdf,unsigned _ftb){
-  opus_uint32 r;
-  opus_uint32 d;
-  opus_uint32 s;
-  opus_uint32 t;
-  int         ret;
-  s=_this->rng;
-  d=_this->val;
-  r=s>>_ftb;
-  ret=-1;
-  do{
-    t=s;
-    s=IMUL32(r,_icdf[++ret]);
-  }
-  while(d<s);
-  _this->val=d-s;
-  _this->rng=t-s;
-  ec_dec_normalize(_this);
-  return ret;
-}
-
-opus_uint32 ec_dec_uint(ec_dec *_this,opus_uint32 _ft){
-  unsigned ft;
-  unsigned s;
-  int      ftb;
-  /*In order to optimize EC_ILOG(), it is undefined for the value 0.*/
-  celt_assert(_ft>1);
-  _ft--;
-  ftb=EC_ILOG(_ft);
-  if(ftb>EC_UINT_BITS){
-    opus_uint32 t;
-    ftb-=EC_UINT_BITS;
-    ft=(unsigned)(_ft>>ftb)+1;
-    s=ec_decode(_this,ft);
-    ec_dec_update(_this,s,s+1,ft);
-    t=(opus_uint32)s<<ftb|ec_dec_bits(_this,ftb);
-    if(t<=_ft)return t;
-    _this->error=1;
-    return _ft;
-  }
-  else{
-    _ft++;
-    s=ec_decode(_this,(unsigned)_ft);
-    ec_dec_update(_this,s,s+1,(unsigned)_ft);
-    return s;
-  }
-}
-
-opus_uint32 ec_dec_bits(ec_dec *_this,unsigned _bits){
-  ec_window   window;
-  int         available;
-  opus_uint32 ret;
-  window=_this->end_window;
-  available=_this->nend_bits;
-  if((unsigned)available<_bits){
-    do{
-      window|=(ec_window)ec_read_byte_from_end(_this)<<available;
-      available+=EC_SYM_BITS;
-    }
-    while(available<=EC_WINDOW_SIZE-EC_SYM_BITS);
-  }
-  ret=(opus_uint32)window&(((opus_uint32)1<<_bits)-1U);
-  window>>=_bits;
-  available-=_bits;
-  _this->end_window=window;
-  _this->nend_bits=available;
-  _this->nbits_total+=_bits;
-  return ret;
-}