Update Opus to 1.0.2.

src/opus_encoder.c

 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
    Written by Jean-Marc Valin and Koen Vos */
 /*
    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 273 matching lines @@
    {
        toc = 0x60;
        toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4;
        toc |= (period-2)<<3;
    }
    toc |= (channels==2)<<2;
    return toc;
 }
 
 #ifndef FIXED_POINT
-void silk_biquad_float(
+static void silk_biquad_float(
     const opus_val16      *in,            /* I:    Input signal                   */
     const opus_int32      *B_Q28,         /* I:    MA coefficients [3]            */
     const opus_int32      *A_Q28,         /* I:    AR coefficients [2]            */
     opus_val32            *S,             /* I/O:  State vector [2]               */
     opus_val16            *out,           /* O:    Output signal                  */
     const opus_int32      len,            /* I:    Signal length (must be even)   */
     int stride
 )
 {
     /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
@@ skipping 146 matching lines @@
     void *silk_enc;
     CELTEncoder *celt_enc;
     int i;
     int ret=0;
     opus_int32 nBytes;
     ec_enc enc;
     int bytes_target;
     int prefill=0;
     int start_band = 0;
     int redundancy = 0;
-    int redundancy_bytes = 0;
+    int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
     int celt_to_silk = 0;
     VARDECL(opus_val16, pcm_buf);
     int nb_compr_bytes;
     int to_celt = 0;
     opus_uint32 redundant_rng = 0;
     int cutoff_Hz, hp_freq_smth1;
-    int voice_est;
+    int voice_est; /* Probability of voice in Q7 */
     opus_int32 equiv_rate;
     int delay_compensation;
     int frame_rate;
-    opus_int32 max_rate;
+    opus_int32 max_rate; /* Max bitrate we're allowed to use */
     int curr_bandwidth;
-    opus_int32 max_data_bytes;
+    opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
     VARDECL(opus_val16, tmp_prefill);
 
     ALLOC_STACK;
 
     max_data_bytes = IMIN(1276, out_data_bytes);
 
     st->rangeFinal = 0;
     if (400*frame_size != st->Fs && 200*frame_size != st->Fs && 100*frame_size != st->Fs &&
          50*frame_size != st->Fs &&  25*frame_size != st->Fs &&  50*frame_size != 3*st->Fs)
     {
@@ skipping 160 matching lines @@
             /* Switch to SILK/hybrid if frame size is 10 ms or more*/
             if (frame_size >= st->Fs/100)
             {
                 st->mode = st->prev_mode;
                 to_celt = 1;
             } else {
                 redundancy=0;
             }
         }
     }
+    /* For the first frame at a new SILK bandwidth */
     if (st->silk_bw_switch)
     {
        redundancy = 1;
        celt_to_silk = 1;
        st->silk_bw_switch = 0;
     }
 
+    if (redundancy)
+    {
+       /* Fair share of the max size allowed */
+       redundancy_bytes = IMIN(257, max_data_bytes*(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200));
+       /* For VBR, target the actual bitrate (subject to the limit above) */
+       if (st->use_vbr)
+          redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600);
+    }
+
     if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY)
     {
         silk_EncControlStruct dummy;
         silk_InitEncoder( silk_enc, &dummy);
         prefill=1;
     }
 
     /* Automatic (rate-dependent) bandwidth selection */
     if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch)
     {
@@ skipping 144 matching lines @@
     curr_bandwidth = st->bandwidth;
 
     /* Chooses the appropriate mode for speech
        *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */
     if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND)
         st->mode = MODE_HYBRID;
     if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND)
         st->mode = MODE_SILK_ONLY;
 
     /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
-    bytes_target = IMIN(max_data_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
+    bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1;
 
     data += 1;
 
     ec_enc_init(&enc, data, max_data_bytes-1);
 
     ALLOC(pcm_buf, (delay_compensation+frame_size)*st->channels, opus_val16);
     for (i=0;i<delay_compensation*st->channels;i++)
        pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-delay_compensation)*st->channels+i];
 
     if (st->mode == MODE_CELT_ONLY)
@@ skipping 85 matching lines @@
               st->silk_mode.maxInternalSampleRate = 8000;
               st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate);
            }
         } else {
            st->silk_mode.maxInternalSampleRate = 16000;
         }
 
         st->silk_mode.useCBR = !st->use_vbr;
 
         /* Call SILK encoder for the low band */
-        nBytes = IMIN(1275, max_data_bytes-1);
+        nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes);
 
         st->silk_mode.maxBits = nBytes*8;
         /* Only allow up to 90% of the bits for hybrid mode*/
         if (st->mode == MODE_HYBRID)
            st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
         if (st->silk_mode.useCBR)
         {
            st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
            /* Reduce the initial target to make it easier to reach the CBR rate */
            st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000);
         }
-        if (redundancy)
-           st->silk_mode.maxBits -= st->silk_mode.maxBits/(1 + frame_size/(st->Fs/200));
 
         if (prefill)
         {
             opus_int32 zero=0;
 #ifdef FIXED_POINT
             pcm_silk = st->delay_buffer;
 #else
             for (i=0;i<st->encoder_buffer*st->channels;i++)
                 pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
 #endif
@@ skipping 27 matching lines @@
             } else if( st->silk_mode.internalSampleRate == 12000 ) {
                curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND;
             } else if( st->silk_mode.internalSampleRate == 16000 ) {
                curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND;
             }
         } else {
             silk_assert( st->silk_mode.internalSampleRate == 16000 );
         }
 
         st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
+        /* FIXME: How do we allocate the redundancy for CBR? */
         if (st->silk_mode.opusCanSwitch)
         {
            redundancy = 1;
            celt_to_silk = 0;
            st->silk_bw_switch = 1;
         }
     }
 
     /* CELT processing */
     {
@@ skipping 37 matching lines @@
             } else {
                 /* check if SILK used up too much */
                 nb_compr_bytes = len > bytes_target ? len : bytes_target;
             }
         } else {
             if (st->use_vbr)
             {
                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1));
                 celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint));
                 celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps));
-                nb_compr_bytes = max_data_bytes-1;
+                nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
             } else {
                 nb_compr_bytes = bytes_target;
             }
         }
 
     } else {
         nb_compr_bytes = 0;
     }
 
     ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16);
@@ skipping 51 matching lines @@
             redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600);
             redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes));
             if (st->mode == MODE_HYBRID)
                 ec_enc_uint(&enc, redundancy_bytes-2, 256);
         }
     } else {
         redundancy = 0;
     }
 
     if (!redundancy)
+    {
        st->silk_bw_switch = 0;
-
+       redundancy_bytes = 0;
+    }
     if (st->mode != MODE_CELT_ONLY)start_band=17;
 
     if (st->mode == MODE_SILK_ONLY)
     {
         ret = (ec_tell(&enc)+7)>>3;
         ec_enc_done(&enc);
         nb_compr_bytes = ret;
     } else {
        nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes);
        ec_enc_shrink(&enc, nb_compr_bytes);
@@ skipping 463 matching lines @@
     return ret;
 bad_arg:
     va_end(ap);
     return OPUS_BAD_ARG;
 }
 
 void opus_encoder_destroy(OpusEncoder *st)
 {
     opus_free(st);
 }