Updating Opus to a pre-release of 1.1

celt/quant_bands.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 22 matching lines @@
 #include "quant_bands.h"
 #include "laplace.h"
 #include <math.h>
 #include "os_support.h"
 #include "arch.h"
 #include "mathops.h"
 #include "stack_alloc.h"
 #include "rate.h"
 
 #ifdef FIXED_POINT
-/* Mean energy in each band quantized in Q6 */
-static const signed char eMeans[25] = {
+/* Mean energy in each band quantized in Q4 */
+const signed char eMeans[25] = {
       103,100, 92, 85, 81,
        77, 72, 70, 78, 75,
        73, 71, 78, 74, 69,
        72, 70, 74, 76, 71,
        60, 60, 60, 60, 60
 };
 #else
-/* Mean energy in each band quantized in Q6 and converted back to float */
-static const opus_val16 eMeans[25] = {
+/* Mean energy in each band quantized in Q4 and converted back to float */
+const opus_val16 eMeans[25] = {
       6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f,
       4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f,
       4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f,
       4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f,
       3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f
 };
 #endif
 /* prediction coefficients: 0.9, 0.8, 0.65, 0.5 */
 #ifdef FIXED_POINT
 static const opus_val16 pred_coef[4] = {29440, 26112, 21248, 16384};
@@ skipping 86 matching lines @@
          dist = MAC16_16(dist, d,d);
       }
    } while (++c<C);
    return MIN32(200,SHR32(dist,2*DB_SHIFT-6));
 }
 
 static int quant_coarse_energy_impl(const CELTMode *m, int start, int end,
       const opus_val16 *eBands, opus_val16 *oldEBands,
       opus_int32 budget, opus_int32 tell,
       const unsigned char *prob_model, opus_val16 *error, ec_enc *enc,
-      int C, int LM, int intra, opus_val16 max_decay)
+      int C, int LM, int intra, opus_val16 max_decay, int lfe)
 {
    int i, c;
    int badness = 0;
    opus_val32 prev[2] = {0,0};
    opus_val16 coef;
    opus_val16 beta;
 
    if (tell+3 <= budget)
       ec_enc_bit_logp(enc, intra, 3);
    if (intra)
@@ skipping 44 matching lines @@
              something safe. */
          tell = ec_tell(enc);
          bits_left = budget-tell-3*C*(end-i);
          if (i!=start && bits_left < 30)
          {
             if (bits_left < 24)
                qi = IMIN(1, qi);
             if (bits_left < 16)
                qi = IMAX(-1, qi);
          }
+         if (lfe && i>=2)
+            qi = IMIN(qi, 0);
          if (budget-tell >= 15)
          {
             int pi;
             pi = 2*IMIN(i,20);
             ec_laplace_encode(enc, &qi,
                   prob_model[pi]<<7, prob_model[pi+1]<<6);
          }
          else if(budget-tell >= 2)
          {
             qi = IMAX(-1, IMIN(qi, 1));
@@ skipping 11 matching lines @@
          q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT);
 
          tmp = PSHR32(MULT16_16(coef,oldE),8) + prev[c] + SHL32(q,7);
 #ifdef FIXED_POINT
          tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp);
 #endif
          oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7);
          prev[c] = prev[c] + SHL32(q,7) - MULT16_16(beta,PSHR32(q,8));
       } while (++c < C);
    }
-   return badness;
+   return lfe ? 0 : badness;
 }
 
 void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
       const opus_val16 *eBands, opus_val16 *oldEBands, opus_uint32 budget,
       opus_val16 *error, ec_enc *enc, int C, int LM, int nbAvailableBytes,
-      int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate)
+      int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate, int lfe)
 {
    int intra;
    opus_val16 max_decay;
    VARDECL(opus_val16, oldEBands_intra);
    VARDECL(opus_val16, error_intra);
    ec_enc enc_start_state;
    opus_uint32 tell;
    int badness1=0;
    opus_int32 intra_bias;
    opus_val32 new_distortion;
    SAVE_STACK;
 
    intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C);
    intra_bias = (opus_int32)((budget**delayedIntra*loss_rate)/(C*512));
    new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C);
 
    tell = ec_tell(enc);
    if (tell+3 > budget)
       two_pass = intra = 0;
 
-   /* Encode the global flags using a simple probability model
-      (first symbols in the stream) */
-
    max_decay = QCONST16(16.f,DB_SHIFT);
    if (end-start>10)
    {
 #ifdef FIXED_POINT
       max_decay = MIN32(max_decay, SHL32(EXTEND32(nbAvailableBytes),DB_SHIFT-3));
 #else
       max_decay = MIN32(max_decay, .125f*nbAvailableBytes);
 #endif
    }
+   if (lfe)
+      max_decay=3;
    enc_start_state = *enc;
 
    ALLOC(oldEBands_intra, C*m->nbEBands, opus_val16);
    ALLOC(error_intra, C*m->nbEBands, opus_val16);
    OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands);
 
    if (two_pass || intra)
    {
       badness1 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget,
-            tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay);
+            tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay, lfe);
    }
 
    if (!intra)
    {
       unsigned char *intra_buf;
       ec_enc enc_intra_state;
       opus_int32 tell_intra;
       opus_uint32 nstart_bytes;
       opus_uint32 nintra_bytes;
       int badness2;
       VARDECL(unsigned char, intra_bits);
 
       tell_intra = ec_tell_frac(enc);
 
       enc_intra_state = *enc;
 
       nstart_bytes = ec_range_bytes(&enc_start_state);
       nintra_bytes = ec_range_bytes(&enc_intra_state);
       intra_buf = ec_get_buffer(&enc_intra_state) + nstart_bytes;
       ALLOC(intra_bits, nintra_bytes-nstart_bytes, unsigned char);
       /* Copy bits from intra bit-stream */
       OPUS_COPY(intra_bits, intra_buf, nintra_bytes - nstart_bytes);
 
       *enc = enc_start_state;
 
       badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget,
-            tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay);
+            tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay, lfe);
 
       if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ((opus_int32)ec_tell_frac(enc))+intra_bias > tell_intra)))
       {
          *enc = enc_intra_state;
          /* Copy intra bits to bit-stream */
          OPUS_COPY(intra_buf, intra_bits, nintra_bytes - nstart_bytes);
          OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
          OPUS_COPY(error, error_intra, C*m->nbEBands);
          intra = 1;
       }
@@ skipping 186 matching lines @@
 #else
             offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
 #endif
             oldEBands[i+c*m->nbEBands] += offset;
             bits_left--;
          } while (++c < C);
       }
    }
 }
 
-void log2Amp(const CELTMode *m, int start, int end,
-      celt_ener *eBands, const opus_val16 *oldEBands, int C)
-{
-   int c, i;
-   c=0;
-   do {
-      for (i=0;i<start;i++)
-         eBands[i+c*m->nbEBands] = 0;
-      for (;i<end;i++)
-      {
-         opus_val16 lg = ADD16(oldEBands[i+c*m->nbEBands],
-                         SHL16((opus_val16)eMeans[i],6));
-         eBands[i+c*m->nbEBands] = PSHR32(celt_exp2(lg),4);
-      }
-      for (;i<m->nbEBands;i++)
-         eBands[i+c*m->nbEBands] = 0;
-   } while (++c < C);
-}
-
 void amp2Log2(const CELTMode *m, int effEnd, int end,
       celt_ener *bandE, opus_val16 *bandLogE, int C)
 {
    int c, i;
    c=0;
    do {
       for (i=0;i<effEnd;i++)
          bandLogE[i+c*m->nbEBands] =
                celt_log2(SHL32(bandE[i+c*m->nbEBands],2))
                - SHL16((opus_val16)eMeans[i],6);
       for (i=effEnd;i<end;i++)
          bandLogE[c*m->nbEBands+i] = -QCONST16(14.f,DB_SHIFT);
    } while (++c < C);
 }