Update Opus to 1.0.2.

celt/rate.c

 /* Copyright (c) 2007-2008 CSIRO
    Copyright (c) 2007-2009 Xiph.Org Foundation
    Written by Jean-Marc Valin */
 /*
    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.
@@ skipping 66 matching lines @@
    int j;
    int curr=0;
    int nbEntries=0;
    int entryN[100], entryK[100], entryI[100];
    const opus_int16 *eBands = m->eBands;
    PulseCache *cache = &m->cache;
    opus_int16 *cindex;
    unsigned char *bits;
    unsigned char *cap;
 
-   cindex = opus_alloc(sizeof(cache->index[0])*m->nbEBands*(LM+2));
+   cindex = (opus_int16 *)opus_alloc(sizeof(cache->index[0])*m->nbEBands*(LM+2));
    cache->index = cindex;
 
    /* Scan for all unique band sizes */
    for (i=0;i<=LM+1;i++)
    {
       for (j=0;j<m->nbEBands;j++)
       {
          int k;
          int N = (eBands[j+1]-eBands[j])<<i>>1;
          cindex[i*m->nbEBands+j] = -1;
@@ skipping 19 matching lines @@
                K++;
             entryK[nbEntries] = K;
             cindex[i*m->nbEBands+j] = curr;
             entryI[nbEntries] = curr;
 
             curr += K+1;
             nbEntries++;
          }
       }
    }
-   bits = opus_alloc(sizeof(unsigned char)*curr);
+   bits = (unsigned char *)opus_alloc(sizeof(unsigned char)*curr);
    cache->bits = bits;
    cache->size = curr;
    /* Compute the cache for all unique sizes */
    for (i=0;i<nbEntries;i++)
    {
       unsigned char *ptr = bits+entryI[i];
       opus_int16 tmp[MAX_PULSES+1];
       get_required_bits(tmp, entryN[i], get_pulses(entryK[i]), BITRES);
       for (j=1;j<=entryK[i];j++)
          ptr[j] = tmp[get_pulses(j)]-1;
       ptr[0] = entryK[i];
    }
 
    /* Compute the maximum rate for each band at which we'll reliably use as
        many bits as we ask for. */
-   cache->caps = cap = opus_alloc(sizeof(cache->caps[0])*(LM+1)*2*m->nbEBands);
+   cache->caps = cap = (unsigned char *)opus_alloc(sizeof(cache->caps[0])*(LM+1)*2*m->nbEBands);
    for (i=0;i<=LM;i++)
    {
       for (C=1;C<=2;C++)
       {
          for (j=0;j<m->nbEBands;j++)
          {
             int N0;
             int max_bits;
             N0 = m->eBands[j+1]-m->eBands[j];
             /* N=1 bands only have a sign bit and fine bits. */
@@ skipping 98 matching lines @@
 {
    opus_int32 psum;
    int lo, hi;
    int i, j;
    int logM;
    int stereo;
    int codedBands=-1;
    int alloc_floor;
    opus_int32 left, percoeff;
    int done;
-   int balance;
+   opus_int32 balance;
    SAVE_STACK;
 
    alloc_floor = C<<BITRES;
    stereo = C>1;
 
    logM = LM<<BITRES;
    lo = 0;
    hi = 1<<ALLOC_STEPS;
    for (i=0;i<ALLOC_STEPS;i++)
    {
@@ skipping 73 matching lines @@
          if (encode)
          {
             /*This if() block is the only part of the allocation function that
                is not a mandatory part of the bitstream: any bands we choose to
                skip here must be explicitly signaled.*/
             /*Choose a threshold with some hysteresis to keep bands from
                fluctuating in and out.*/
 #ifdef FUZZING
             if ((rand()&0x1) == 0)
 #else
-            if (band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4)
+            if (codedBands<=start+2 || band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4)
 #endif
             {
                ec_enc_bit_logp(ec, 1, 1);
                break;
             }
             ec_enc_bit_logp(ec, 0, 1);
          } else if (ec_dec_bit_logp(ec, 1)) {
             break;
          }
          /*We used a bit to skip this band.*/
@@ skipping 58 matching lines @@
       left -= tmp;
    }
    /*for (j=0;j<end;j++)printf("%d ", bits[j]);printf("\n");*/
 
    balance = 0;
    for (j=start;j<codedBands;j++)
    {
       int N0, N, den;
       int offset;
       int NClogN;
-      int excess;
+      opus_int32 excess, bit;
 
       celt_assert(bits[j] >= 0);
       N0 = m->eBands[j+1]-m->eBands[j];
       N=N0<<LM;
-      bits[j] += balance;
+      bit = (opus_int32)bits[j]+balance;
 
       if (N>1)
       {
-         excess = IMAX(bits[j]-cap[j],0);
-         bits[j] -= excess;
+         excess = MAX32(bit-cap[j],0);
+         bits[j] = bit-excess;
 
          /* Compensate for the extra DoF in stereo */
          den=(C*N+ ((C==2 && N>2 && !*dual_stereo && j<*intensity) ? 1 : 0));
 
          NClogN = den*(m->logN[j] + logM);
 
          /* Offset for the number of fine bits by log2(N)/2 + FINE_OFFSET
             compared to their "fair share" of total/N */
          offset = (NClogN>>1)-den*FINE_OFFSET;
 
@@ skipping 20 matching lines @@
 
          /* If we rounded down or capped this band, make it a candidate for the
              final fine energy pass */
          fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset;
 
          /* Remove the allocated fine bits; the rest are assigned to PVQ */
          bits[j] -= C*ebits[j]<<BITRES;
 
       } else {
          /* For N=1, all bits go to fine energy except for a single sign bit */
-         excess = IMAX(0,bits[j]-(C<<BITRES));
-         bits[j] -= excess;
+         excess = MAX32(0,bit-(C<<BITRES));
+         bits[j] = bit-excess;
          ebits[j] = 0;
          fine_priority[j] = 1;
       }
 
       /* Fine energy can't take advantage of the re-balancing in
           quant_all_bands().
          Instead, do the re-balancing here.*/
       if(excess > 0)
       {
          int extra_fine;
@@ skipping 131 matching lines @@
       bits1[j] = bits1j;
       bits2[j] = bits2j;
    }
    codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
          total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
          pulses, ebits, fine_priority, C, LM, ec, encode, prev);
    RESTORE_STACK;
    return codedBands;
 }