Remove workaround for Opus DTX noise pumping issue.

webrtc/modules/audio_coding/codecs/opus/opus_interface.c

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 12 matching lines @@
    * side, we must allow for packets of that size. NetEq is currently limited
    * to 60 ms on the receive side. */
   kWebRtcOpusMaxDecodeFrameSizeMs = 120,
 
   /* Maximum sample count per channel is 48 kHz * maximum frame size in
    * milliseconds. */
   kWebRtcOpusMaxFrameSizePerChannel = 48 * kWebRtcOpusMaxDecodeFrameSizeMs,
 
   /* Default frame size, 20 ms @ 48 kHz, in samples (for one channel). */
   kWebRtcOpusDefaultFrameSize = 960,
-
-  // Maximum number of consecutive zeros, beyond or equal to which DTX can fail.
-  kZeroBreakCount = 157,
-
-#if defined(OPUS_FIXED_POINT)
-  kZeroBreakValue = 10,
-#else
-  kZeroBreakValue = 1,
-#endif
 };
 
 int16_t WebRtcOpus_EncoderCreate(OpusEncInst** inst,
                                  size_t channels,
                                  int32_t application) {
   int opus_app;
   if (!inst)
     return -1;
 
   switch (application) {
     case 0:
       opus_app = OPUS_APPLICATION_VOIP;
       break;
     case 1:
       opus_app = OPUS_APPLICATION_AUDIO;
       break;
     default:
       return -1;
   }
 
   OpusEncInst* state = calloc(1, sizeof(OpusEncInst));
   assert(state);
 
-  // Allocate zero counters.
-  state->zero_counts = calloc(channels, sizeof(size_t));
-  assert(state->zero_counts);
-
   int error;
   state->encoder = opus_encoder_create(48000, (int)channels, opus_app,
                                        &error);
   if (error != OPUS_OK || !state->encoder) {
     WebRtcOpus_EncoderFree(state);
     return -1;
   }
 
   state->in_dtx_mode = 0;
   state->channels = channels;
 
   *inst = state;
   return 0;
 }
 
 int16_t WebRtcOpus_EncoderFree(OpusEncInst* inst) {
   if (inst) {
     opus_encoder_destroy(inst->encoder);
-    free(inst->zero_counts);
     free(inst);
     return 0;
   } else {
     return -1;
   }
 }
 
 int WebRtcOpus_Encode(OpusEncInst* inst,
                       const int16_t* audio_in,
                       size_t samples,
                       size_t length_encoded_buffer,
                       uint8_t* encoded) {
   int res;
-  size_t i;
-  size_t c;
-
-  int16_t buffer[2 * 48 * kWebRtcOpusMaxEncodeFrameSizeMs];
 
   if (samples > 48 * kWebRtcOpusMaxEncodeFrameSizeMs) {
     return -1;
   }
 
-  const size_t channels = inst->channels;
-  int use_buffer = 0;
-
-  // Break long consecutive zeros by forcing a "1" every |kZeroBreakCount|
-  // samples.
-  if (inst->in_dtx_mode) {
-    for (i = 0; i < samples; ++i) {
-      for (c = 0; c < channels; ++c) {
-        if (audio_in[i * channels + c] == 0) {
-          ++inst->zero_counts[c];
-          if (inst->zero_counts[c] == kZeroBreakCount) {
-            if (!use_buffer) {
-              memcpy(buffer, audio_in, samples * channels * sizeof(int16_t));
-              use_buffer = 1;
-            }
-            buffer[i * channels + c] = kZeroBreakValue;
-            inst->zero_counts[c] = 0;
-          }
-        } else {
-          inst->zero_counts[c] = 0;
-        }
-      }
-    }
-  }
-
   res = opus_encode(inst->encoder,
-                    use_buffer ? buffer : audio_in,
+                    (const opus_int16*)audio_in,
                     (int)samples,
                     encoded,
                     (opus_int32)length_encoded_buffer);
 
   if (res == 1) {
     // Indicates DTX since the packet has nothing but a header. In principle,
     // there is no need to send this packet. However, we do transmit the first
     // occurrence to let the decoder know that the encoder enters DTX mode.
     if (inst->in_dtx_mode) {
       return 0;
@@ skipping 348 matching lines @@
     return 0;
   }
 
   for (n = 0; n < channels; n++) {
     if (frame_data[0][0] & (0x80 >> ((n + 1) * (frames + 1) - 1)))
       return 1;
   }
 
   return 0;
 }