Since NetEq4 is ready to handle 48 kHz codec, it is good to remove the 48-to-32kHz downsampling of Opus output. This facilitates webrtc to make full use of Opus's bandwidth and eliminates unneeded computation in resampling.

TEST=passed_all_trybots
R=henrik.lundin@webrtc.org, tina.legrand@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/16619005

git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@6458 4adac7df-926f-26a2-2b94-8c16560cd09d

12 files changed, 247 insertions, 431 deletions

diff --git a/modules/audio_coding/codecs/opus/opus_fec_test.cc b/modules/audio_coding/codecs/opus/opus_fec_test.cc
index fb4cb04f..ee027e80 100644
--- a/modules/audio_coding/codecs/opus/opus_fec_test.cc
+++ b/modules/audio_coding/codecs/opus/opus_fec_test.cc
@@ -32,8 +32,7 @@ struct mode {
 };
 
 const int kOpusBlockDurationMs = 20;
-const int kOpusInputSamplingKhz = 48;
-const int kOpusOutputSamplingKhz = 32;
+const int kOpusSamplingKhz = 48;
 
 class OpusFecTest : public TestWithParam<coding_param> {
  protected:
@@ -47,14 +46,8 @@ class OpusFecTest : public TestWithParam<coding_param> {
   virtual void DecodeABlock(bool lost_previous, bool lost_current);
 
   int block_duration_ms_;
-  int input_sampling_khz_;
-  int output_sampling_khz_;
-
-  // Number of samples-per-channel in a frame.
-  int input_length_sample_;
-
-  // Expected output number of samples-per-channel in a frame.
-  int output_length_sample_;
+  int sampling_khz_;
+  int block_length_sample_;
 
   int channels_;
   int bit_rate_;
@@ -91,7 +84,7 @@ void OpusFecTest::SetUp() {
 
   // Allocate memory to contain the whole file.
   in_data_.reset(new int16_t[loop_length_samples_ +
-      input_length_sample_ * channels_]);
+      block_length_sample_ * channels_]);
 
   // Copy the file into the buffer.
   ASSERT_EQ(fread(&in_data_[0], sizeof(int16_t), loop_length_samples_, fp),
@@ -104,12 +97,12 @@ void OpusFecTest::SetUp() {
   // beginning of the array. Audio frames cross the end of the excerpt always
   // appear as a continuum of memory.
   memcpy(&in_data_[loop_length_samples_], &in_data_[0],
-         input_length_sample_ * channels_ * sizeof(int16_t));
+         block_length_sample_ * channels_ * sizeof(int16_t));
 
   // Maximum number of bytes in output bitstream.
-  max_bytes_ = input_length_sample_ * channels_ * sizeof(int16_t);
+  max_bytes_ = block_length_sample_ * channels_ * sizeof(int16_t);
 
-  out_data_.reset(new int16_t[2 * output_length_sample_ * channels_]);
+  out_data_.reset(new int16_t[2 * block_length_sample_ * channels_]);
   bit_stream_.reset(new uint8_t[max_bytes_]);
 
   // Create encoder memory.
@@ -127,10 +120,8 @@ void OpusFecTest::TearDown() {
 
 OpusFecTest::OpusFecTest()
     : block_duration_ms_(kOpusBlockDurationMs),
-      input_sampling_khz_(kOpusInputSamplingKhz),
-      output_sampling_khz_(kOpusOutputSamplingKhz),
-      input_length_sample_(block_duration_ms_ * input_sampling_khz_),
-      output_length_sample_(block_duration_ms_ * output_sampling_khz_),
+      sampling_khz_(kOpusSamplingKhz),
+      block_length_sample_(block_duration_ms_ * sampling_khz_),
       data_pointer_(0),
       max_bytes_(0),
       encoded_bytes_(0),
@@ -141,7 +132,7 @@ OpusFecTest::OpusFecTest()
 void OpusFecTest::EncodeABlock() {
   int16_t value = WebRtcOpus_Encode(opus_encoder_,
                                     &in_data_[data_pointer_],
-                                    input_length_sample_,
+                                    block_length_sample_,
                                     max_bytes_, &bit_stream_[0]);
   EXPECT_GT(value, 0);
 
@@ -162,7 +153,7 @@ void OpusFecTest::DecodeABlock(bool lost_previous, bool lost_current) {
     } else {
       value_1 = WebRtcOpus_DecodePlc(opus_decoder_, &out_data_[0], 1);
     }
-    EXPECT_EQ(output_length_sample_, value_1);
+    EXPECT_EQ(block_length_sample_, value_1);
   }
 
   if (!lost_current) {
@@ -171,7 +162,7 @@ void OpusFecTest::DecodeABlock(bool lost_previous, bool lost_current) {
                                    encoded_bytes_,
                                    &out_data_[value_1 * channels_],
                                    &audio_type);
-    EXPECT_EQ(output_length_sample_, value_2);
+    EXPECT_EQ(block_length_sample_, value_2);
   }
 }
 
@@ -224,7 +215,7 @@ TEST_P(OpusFecTest, RandomPacketLossTest) {
 
       // |data_pointer_| is incremented and wrapped across
       // |loop_length_samples_|.
-      data_pointer_ = (data_pointer_ + input_length_sample_ * channels_) %
+      data_pointer_ = (data_pointer_ + block_length_sample_ * channels_) %
         loop_length_samples_;
     }
     if (mode_set[i].fec) {
diff --git a/modules/audio_coding/codecs/opus/opus_interface.c b/modules/audio_coding/codecs/opus/opus_interface.c
index 24fc4fc4..ea535ea9 100644
--- a/modules/audio_coding/codecs/opus/opus_interface.c
+++ b/modules/audio_coding/codecs/opus/opus_interface.c
@@ -15,9 +15,6 @@
 
 #include "opus.h"
 
-#include "webrtc/common_audio/signal_processing/resample_by_2_internal.h"
-#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
-
 enum {
   /* Maximum supported frame size in WebRTC is 60 ms. */
   kWebRtcOpusMaxEncodeFrameSizeMs = 60,
@@ -31,17 +28,6 @@ enum {
    * milliseconds. */
   kWebRtcOpusMaxFrameSizePerChannel = 48 * kWebRtcOpusMaxDecodeFrameSizeMs,
 
-  /* Maximum sample count per frame is 48 kHz * maximum frame size in
-   * milliseconds * maximum number of channels. */
-  kWebRtcOpusMaxFrameSize = kWebRtcOpusMaxFrameSizePerChannel * 2,
-
-  /* Maximum sample count per channel for output resampled to 32 kHz,
-   * 32 kHz * maximum frame size in milliseconds. */
-  kWebRtcOpusMaxFrameSizePerChannel32kHz = 32 * kWebRtcOpusMaxDecodeFrameSizeMs,
-
-  /* Number of samples in resampler state. */
-  kWebRtcOpusStateSize = 7,
-
   /* Default frame size, 20 ms @ 48 kHz, in samples (for one channel). */
   kWebRtcOpusDefaultFrameSize = 960,
 };
@@ -143,8 +129,6 @@ int16_t WebRtcOpus_SetComplexity(OpusEncInst* inst, int32_t complexity) {
 }
 
 struct WebRtcOpusDecInst {
-  int16_t state_48_32_left[8];
-  int16_t state_48_32_right[8];
   OpusDecoder* decoder_left;
   OpusDecoder* decoder_right;
   int prev_decoded_samples;
@@ -205,8 +189,6 @@ int WebRtcOpus_DecoderChannels(OpusDecInst* inst) {
 int16_t WebRtcOpus_DecoderInitNew(OpusDecInst* inst) {
   int error = opus_decoder_ctl(inst->decoder_left, OPUS_RESET_STATE);
   if (error == OPUS_OK) {
-    memset(inst->state_48_32_left, 0, sizeof(inst->state_48_32_left));
-    memset(inst->state_48_32_right, 0, sizeof(inst->state_48_32_right));
     return 0;
   }
   return -1;
@@ -215,7 +197,6 @@ int16_t WebRtcOpus_DecoderInitNew(OpusDecInst* inst) {
 int16_t WebRtcOpus_DecoderInit(OpusDecInst* inst) {
   int error = opus_decoder_ctl(inst->decoder_left, OPUS_RESET_STATE);
   if (error == OPUS_OK) {
-    memset(inst->state_48_32_left, 0, sizeof(inst->state_48_32_left));
     return 0;
   }
   return -1;
@@ -224,7 +205,6 @@ int16_t WebRtcOpus_DecoderInit(OpusDecInst* inst) {
 int16_t WebRtcOpus_DecoderInitSlave(OpusDecInst* inst) {
   int error = opus_decoder_ctl(inst->decoder_right, OPUS_RESET_STATE);
   if (error == OPUS_OK) {
-    memset(inst->state_48_32_right, 0, sizeof(inst->state_48_32_right));
     return 0;
   }
   return -1;
@@ -267,124 +247,29 @@ static int DecodeFec(OpusDecoder* inst, const int16_t* encoded,
   return -1;
 }
 
-/* Resample from 48 to 32 kHz. Length of state is assumed to be
- * kWebRtcOpusStateSize (7).
- */
-static int WebRtcOpus_Resample48to32(const int16_t* samples_in, int length,
-                                     int16_t* state, int16_t* samples_out) {
-  int i;
-  int blocks;
-  int16_t output_samples;
-  int32_t buffer32[kWebRtcOpusMaxFrameSizePerChannel + kWebRtcOpusStateSize];
-
-  /* Resample from 48 kHz to 32 kHz. */
-  for (i = 0; i < kWebRtcOpusStateSize; i++) {
-    buffer32[i] = state[i];
-    state[i] = samples_in[length - kWebRtcOpusStateSize + i];
-  }
-  for (i = 0; i < length; i++) {
-    buffer32[kWebRtcOpusStateSize + i] = samples_in[i];
-  }
-  /* Resampling 3 samples to 2. Function divides the input in |blocks| number
-   * of 3-sample groups, and output is |blocks| number of 2-sample groups.
-   * When this is removed, the compensation in WebRtcOpus_DurationEst should be
-   * removed too. */
-  blocks = length / 3;
-  WebRtcSpl_Resample48khzTo32khz(buffer32, buffer32, blocks);
-  output_samples = (int16_t) (blocks * 2);
-  WebRtcSpl_VectorBitShiftW32ToW16(samples_out, output_samples, buffer32, 15);
-
-  return output_samples;
-}
-
-static int WebRtcOpus_DeInterleaveResample(OpusDecInst* inst, int16_t* input,
-                                           int sample_pairs, int16_t* output) {
-  int i;
-  int16_t buffer_left[kWebRtcOpusMaxFrameSizePerChannel];
-  int16_t buffer_right[kWebRtcOpusMaxFrameSizePerChannel];
-  int16_t buffer_out[kWebRtcOpusMaxFrameSizePerChannel32kHz];
-  int resampled_samples;
-
-  /* De-interleave the signal in left and right channel. */
-  for (i = 0; i < sample_pairs; i++) {
-    /* Take every second sample, starting at the first sample. */
-    buffer_left[i] = input[i * 2];
-    buffer_right[i] = input[i * 2 + 1];
-  }
-
-  /* Resample from 48 kHz to 32 kHz for left channel. */
-  resampled_samples = WebRtcOpus_Resample48to32(
-      buffer_left, sample_pairs, inst->state_48_32_left, buffer_out);
-
-  /* Add samples interleaved to output vector. */
-  for (i = 0; i < resampled_samples; i++) {
-    output[i * 2] = buffer_out[i];
-  }
-
-  /* Resample from 48 kHz to 32 kHz for right channel. */
-  resampled_samples = WebRtcOpus_Resample48to32(
-      buffer_right, sample_pairs, inst->state_48_32_right, buffer_out);
-
-  /* Add samples interleaved to output vector. */
-  for (i = 0; i < resampled_samples; i++) {
-    output[i * 2 + 1] = buffer_out[i];
-  }
-
-  return resampled_samples;
-}
-
 int16_t WebRtcOpus_DecodeNew(OpusDecInst* inst, const uint8_t* encoded,
                              int16_t encoded_bytes, int16_t* decoded,
                              int16_t* audio_type) {
-  /* |buffer| is big enough for 120 ms (the largest Opus packet size) of stereo
-   * audio at 48 kHz. */
-  int16_t buffer[kWebRtcOpusMaxFrameSize];
   int16_t* coded = (int16_t*)encoded;
   int decoded_samples;
-  int resampled_samples;
-
-  /* If mono case, just do a regular call to the decoder.
-   * If stereo, we need to de-interleave the stereo output into blocks with
-   * left and right channel. Each block is resampled to 32 kHz, and then
-   * interleaved again. */
 
-  /* Decode to a temporary buffer. */
   decoded_samples = DecodeNative(inst->decoder_left, coded, encoded_bytes,
                                  kWebRtcOpusMaxFrameSizePerChannel,
-                                 buffer, audio_type);
+                                 decoded, audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
 
-  if (inst->channels == 2) {
-    /* De-interleave and resample. */
-    resampled_samples = WebRtcOpus_DeInterleaveResample(inst,
-                                                        buffer,
-                                                        decoded_samples,
-                                                        decoded);
-  } else {
-    /* Resample from 48 kHz to 32 kHz. Filter state memory for left channel is
-     * used for mono signals. */
-    resampled_samples = WebRtcOpus_Resample48to32(buffer,
-                                                  decoded_samples,
-                                                  inst->state_48_32_left,
-                                                  decoded);
-  }
-
   /* Update decoded sample memory, to be used by the PLC in case of losses. */
   inst->prev_decoded_samples = decoded_samples;
 
-  return resampled_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_Decode(OpusDecInst* inst, const int16_t* encoded,
                           int16_t encoded_bytes, int16_t* decoded,
                           int16_t* audio_type) {
-  /* |buffer16| is big enough for 120 ms (the largestOpus packet size) of
-   * stereo audio at 48 kHz. */
-  int16_t buffer16[kWebRtcOpusMaxFrameSize];
   int decoded_samples;
-  int16_t output_samples;
   int i;
 
   /* If mono case, just do a regular call to the decoder.
@@ -393,120 +278,82 @@ int16_t WebRtcOpus_Decode(OpusDecInst* inst, const int16_t* encoded,
    * This is to make stereo work with the current setup of NetEQ, which
    * requires two calls to the decoder to produce stereo. */
 
-  /* Decode to a temporary buffer. */
   decoded_samples = DecodeNative(inst->decoder_left, encoded, encoded_bytes,
-                                 kWebRtcOpusMaxFrameSizePerChannel, buffer16,
+                                 kWebRtcOpusMaxFrameSizePerChannel, decoded,
                                  audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
   if (inst->channels == 2) {
     /* The parameter |decoded_samples| holds the number of samples pairs, in
-     * case of stereo. Number of samples in |buffer16| equals |decoded_samples|
+     * case of stereo. Number of samples in |decoded| equals |decoded_samples|
      * times 2. */
     for (i = 0; i < decoded_samples; i++) {
       /* Take every second sample, starting at the first sample. This gives
        * the left channel. */
-      buffer16[i] = buffer16[i * 2];
+      decoded[i] = decoded[i * 2];
     }
   }
 
-  /* Resample from 48 kHz to 32 kHz. */
-  output_samples = WebRtcOpus_Resample48to32(buffer16, decoded_samples,
-                                             inst->state_48_32_left, decoded);
-
   /* Update decoded sample memory, to be used by the PLC in case of losses. */
   inst->prev_decoded_samples = decoded_samples;
 
-  return output_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_DecodeSlave(OpusDecInst* inst, const int16_t* encoded,
                                int16_t encoded_bytes, int16_t* decoded,
                                int16_t* audio_type) {
-  /* |buffer16| is big enough for 120 ms (the largestOpus packet size) of
-   * stereo audio at 48 kHz. */
-  int16_t buffer16[kWebRtcOpusMaxFrameSize];
   int decoded_samples;
-  int16_t output_samples;
   int i;
 
-  /* Decode to a temporary buffer. */
   decoded_samples = DecodeNative(inst->decoder_right, encoded, encoded_bytes,
-                                 kWebRtcOpusMaxFrameSizePerChannel, buffer16,
+                                 kWebRtcOpusMaxFrameSizePerChannel, decoded,
                                  audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
   if (inst->channels == 2) {
     /* The parameter |decoded_samples| holds the number of samples pairs, in
-     * case of stereo. Number of samples in |buffer16| equals |decoded_samples|
+     * case of stereo. Number of samples in |decoded| equals |decoded_samples|
      * times 2. */
     for (i = 0; i < decoded_samples; i++) {
       /* Take every second sample, starting at the second sample. This gives
        * the right channel. */
-      buffer16[i] = buffer16[i * 2 + 1];
+      decoded[i] = decoded[i * 2 + 1];
     }
   } else {
     /* Decode slave should never be called for mono packets. */
     return -1;
   }
-  /* Resample from 48 kHz to 32 kHz. */
-  output_samples = WebRtcOpus_Resample48to32(buffer16, decoded_samples,
-                                             inst->state_48_32_right, decoded);
 
-  return output_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_DecodePlc(OpusDecInst* inst, int16_t* decoded,
                              int16_t number_of_lost_frames) {
-  int16_t buffer[kWebRtcOpusMaxFrameSize];
   int16_t audio_type = 0;
   int decoded_samples;
-  int resampled_samples;
   int plc_samples;
 
-  /* If mono case, just do a regular call to the plc function, before
-   * resampling.
-   * If stereo, we need to de-interleave the stereo output into blocks with
-   * left and right channel. Each block is resampled to 32 kHz, and then
-   * interleaved again. */
-
-  /* Decode to a temporary buffer. The number of samples we ask for is
-   * |number_of_lost_frames| times |prev_decoded_samples_|. Limit the number
-   * of samples to maximum |kWebRtcOpusMaxFrameSizePerChannel|. */
+  /* The number of samples we ask for is |number_of_lost_frames| times
+   * |prev_decoded_samples_|. Limit the number of samples to maximum
+   * |kWebRtcOpusMaxFrameSizePerChannel|. */
   plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
   plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel) ?
       plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
   decoded_samples = DecodeNative(inst->decoder_left, NULL, 0, plc_samples,
-                                 buffer, &audio_type);
+                                 decoded, &audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
 
-  if (inst->channels == 2) {
-     /* De-interleave and resample. */
-     resampled_samples = WebRtcOpus_DeInterleaveResample(inst,
-                                                         buffer,
-                                                         decoded_samples,
-                                                         decoded);
-   } else {
-     /* Resample from 48 kHz to 32 kHz. Filter state memory for left channel is
-      * used for mono signals. */
-     resampled_samples = WebRtcOpus_Resample48to32(buffer,
-                                                   decoded_samples,
-                                                   inst->state_48_32_left,
-                                                   decoded);
-   }
-
-  return resampled_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_DecodePlcMaster(OpusDecInst* inst, int16_t* decoded,
                                    int16_t number_of_lost_frames) {
-  int16_t buffer[kWebRtcOpusMaxFrameSize];
   int decoded_samples;
-  int resampled_samples;
   int16_t audio_type = 0;
   int plc_samples;
   int i;
@@ -517,42 +364,35 @@ int16_t WebRtcOpus_DecodePlcMaster(OpusDecInst* inst, int16_t* decoded,
    * output. This is to make stereo work with the current setup of NetEQ, which
    * requires two calls to the decoder to produce stereo. */
 
-  /* Decode to a temporary buffer. The number of samples we ask for is
-   * |number_of_lost_frames| times |prev_decoded_samples_|. Limit the number
-   * of samples to maximum |kWebRtcOpusMaxFrameSizePerChannel|. */
+  /* The number of samples we ask for is |number_of_lost_frames| times
+   * |prev_decoded_samples_|. Limit the number of samples to maximum
+   * |kWebRtcOpusMaxFrameSizePerChannel|. */
   plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
   plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel) ?
       plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
   decoded_samples = DecodeNative(inst->decoder_left, NULL, 0, plc_samples,
-                                 buffer, &audio_type);
+                                 decoded, &audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
 
   if (inst->channels == 2) {
     /* The parameter |decoded_samples| holds the number of sample pairs, in
-     * case of stereo. The original number of samples in |buffer| equals
+     * case of stereo. The original number of samples in |decoded| equals
      * |decoded_samples| times 2. */
     for (i = 0; i < decoded_samples; i++) {
       /* Take every second sample, starting at the first sample. This gives
        * the left channel. */
-      buffer[i] = buffer[i * 2];
+      decoded[i] = decoded[i * 2];
     }
   }
 
-  /* Resample from 48 kHz to 32 kHz for left channel. */
-  resampled_samples = WebRtcOpus_Resample48to32(buffer,
-                                                decoded_samples,
-                                                inst->state_48_32_left,
-                                                decoded);
-  return resampled_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_DecodePlcSlave(OpusDecInst* inst, int16_t* decoded,
                                   int16_t number_of_lost_frames) {
-  int16_t buffer[kWebRtcOpusMaxFrameSize];
   int decoded_samples;
-  int resampled_samples;
   int16_t audio_type = 0;
   int plc_samples;
   int i;
@@ -563,44 +403,35 @@ int16_t WebRtcOpus_DecodePlcSlave(OpusDecInst* inst, int16_t* decoded,
     return -1;
   }
 
-  /* Decode to a temporary buffer. The number of samples we ask for is
-   * |number_of_lost_frames| times |prev_decoded_samples_|. Limit the number
-   * of samples to maximum |kWebRtcOpusMaxFrameSizePerChannel|. */
+  /* The number of samples we ask for is |number_of_lost_frames| times
+   *  |prev_decoded_samples_|. Limit the number of samples to maximum
+   *  |kWebRtcOpusMaxFrameSizePerChannel|. */
   plc_samples = number_of_lost_frames * inst->prev_decoded_samples;
   plc_samples = (plc_samples <= kWebRtcOpusMaxFrameSizePerChannel)
       ? plc_samples : kWebRtcOpusMaxFrameSizePerChannel;
   decoded_samples = DecodeNative(inst->decoder_right, NULL, 0, plc_samples,
-                                 buffer, &audio_type);
+                                 decoded, &audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
 
   /* The parameter |decoded_samples| holds the number of sample pairs,
-   * The original number of samples in |buffer| equals |decoded_samples|
+   * The original number of samples in |decoded| equals |decoded_samples|
    * times 2. */
   for (i = 0; i < decoded_samples; i++) {
     /* Take every second sample, starting at the second sample. This gives
      * the right channel. */
-    buffer[i] = buffer[i * 2 + 1];
+    decoded[i] = decoded[i * 2 + 1];
   }
 
-  /* Resample from 48 kHz to 32 kHz for left channel. */
-  resampled_samples = WebRtcOpus_Resample48to32(buffer,
-                                                decoded_samples,
-                                                inst->state_48_32_right,
-                                                decoded);
-  return resampled_samples;
+  return decoded_samples;
 }
 
 int16_t WebRtcOpus_DecodeFec(OpusDecInst* inst, const uint8_t* encoded,
                              int16_t encoded_bytes, int16_t* decoded,
                              int16_t* audio_type) {
-  /* |buffer| is big enough for 120 ms (the largest Opus packet size) of stereo
-   * audio at 48 kHz. */
-  int16_t buffer[kWebRtcOpusMaxFrameSize];
   int16_t* coded = (int16_t*)encoded;
   int decoded_samples;
-  int resampled_samples;
   int fec_samples;
 
   if (WebRtcOpus_PacketHasFec(encoded, encoded_bytes) != 1) {
@@ -609,33 +440,13 @@ int16_t WebRtcOpus_DecodeFec(OpusDecInst* inst, const uint8_t* encoded,
 
   fec_samples = opus_packet_get_samples_per_frame(encoded, 48000);
 
-  /* Decode to a temporary buffer. */
   decoded_samples = DecodeFec(inst->decoder_left, coded, encoded_bytes,
-                              fec_samples, buffer, audio_type);
+                              fec_samples, decoded, audio_type);
   if (decoded_samples < 0) {
     return -1;
   }
 
-  /* If mono case, just do a regular call to the decoder.
-   * If stereo, we need to de-interleave the stereo output into blocks with
-   * left and right channel. Each block is resampled to 32 kHz, and then
-   * interleaved again. */
-  if (inst->channels == 2) {
-    /* De-interleave and resample. */
-    resampled_samples = WebRtcOpus_DeInterleaveResample(inst,
-                                                        buffer,
-                                                        decoded_samples,
-                                                        decoded);
-  } else {
-    /* Resample from 48 kHz to 32 kHz. Filter state memory for left channel is
-     * used for mono signals. */
-    resampled_samples = WebRtcOpus_Resample48to32(buffer,
-                                                  decoded_samples,
-                                                  inst->state_48_32_left,
-                                                  decoded);
-  }
-
-  return resampled_samples;
+  return decoded_samples;
 }
 
 int WebRtcOpus_DurationEst(OpusDecInst* inst,
@@ -652,10 +463,6 @@ int WebRtcOpus_DurationEst(OpusDecInst* inst,
     /* Invalid payload duration. */
     return 0;
   }
-  /* Compensate for the down-sampling from 48 kHz to 32 kHz.
-   * This should be removed when the resampling in WebRtcOpus_Decode is
-   * removed. */
-  samples = samples * 2 / 3;
   return samples;
 }
 
@@ -671,10 +478,6 @@ int WebRtcOpus_FecDurationEst(const uint8_t* payload,
     /* Invalid payload duration. */
     return 0;
   }
-  /* Compensate for the down-sampling from 48 kHz to 32 kHz.
-   * This should be removed when the resampling in WebRtcOpus_Decode is
-   * removed. */
-  samples = samples * 2 / 3;
   return samples;
 }
 
diff --git a/modules/audio_coding/codecs/opus/opus_speed_test.cc b/modules/audio_coding/codecs/opus/opus_speed_test.cc
index 16099c6d..e2439cf5 100644
--- a/modules/audio_coding/codecs/opus/opus_speed_test.cc
+++ b/modules/audio_coding/codecs/opus/opus_speed_test.cc
@@ -18,8 +18,7 @@ using ::testing::ValuesIn;
 namespace webrtc {
 
 static const int kOpusBlockDurationMs = 20;
-static const int kOpusInputSamplingKhz = 48;
-static const int kOpustOutputSamplingKhz = 32;
+static const int kOpusSamplingKhz = 48;
 
 class OpusSpeedTest : public AudioCodecSpeedTest {
  protected:
@@ -36,8 +35,8 @@ class OpusSpeedTest : public AudioCodecSpeedTest {
 
 OpusSpeedTest::OpusSpeedTest()
     : AudioCodecSpeedTest(kOpusBlockDurationMs,
-                          kOpusInputSamplingKhz,
-                          kOpustOutputSamplingKhz),
+                          kOpusSamplingKhz,
+                          kOpusSamplingKhz),
       opus_encoder_(NULL),
       opus_decoder_(NULL) {
 }
diff --git a/modules/audio_coding/codecs/opus/opus_unittest.cc b/modules/audio_coding/codecs/opus/opus_unittest.cc
index ed876cd1..2ec77a53 100644
--- a/modules/audio_coding/codecs/opus/opus_unittest.cc
+++ b/modules/audio_coding/codecs/opus/opus_unittest.cc
@@ -19,9 +19,13 @@ struct WebRtcOpusDecInst;
 namespace webrtc {
 
 // Number of samples in a 60 ms stereo frame, sampled at 48 kHz.
-const int kOpusNumberOfSamples = 480 * 6 * 2;
+const int kOpusMaxFrameSamples = 48 * 60 * 2;
 // Maximum number of bytes in output bitstream.
 const size_t kMaxBytes = 1000;
+// Number of samples-per-channel in a 20 ms frame, sampled at 48 kHz.
+const int kOpus20msFrameSamples = 48 * 20;
+// Number of samples-per-channel in a 10 ms frame, sampled at 48 kHz.
+const int kOpus10msFrameSamples = 48 * 10;
 
 class OpusTest : public ::testing::Test {
  protected:
@@ -35,8 +39,8 @@ class OpusTest : public ::testing::Test {
   WebRtcOpusDecInst* opus_stereo_decoder_;
   WebRtcOpusDecInst* opus_stereo_decoder_new_;
 
-  int16_t speech_data_[kOpusNumberOfSamples];
-  int16_t output_data_[kOpusNumberOfSamples];
+  int16_t speech_data_[kOpusMaxFrameSamples];
+  int16_t output_data_[kOpusMaxFrameSamples];
   uint8_t bitstream_[kMaxBytes];
 };
 
@@ -50,17 +54,14 @@ OpusTest::OpusTest()
 }
 
 void OpusTest::SetUp() {
-  // Read some samples from a speech file, to be used in the encode test.
-  // In this test we do not care that the sampling frequency of the file is
-  // really 32000 Hz. We pretend that it is 48000 Hz.
   FILE* input_file;
   const std::string file_name =
-        webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm");
+        webrtc::test::ResourcePath("audio_coding/speech_mono_32_48kHz", "pcm");
   input_file = fopen(file_name.c_str(), "rb");
   ASSERT_TRUE(input_file != NULL);
-  ASSERT_EQ(kOpusNumberOfSamples,
+  ASSERT_EQ(kOpusMaxFrameSamples,
             static_cast<int32_t>(fread(speech_data_, sizeof(int16_t),
-                                       kOpusNumberOfSamples, input_file)));
+                                       kOpusMaxFrameSamples, input_file)));
   fclose(input_file);
   input_file = NULL;
 }
@@ -114,21 +115,24 @@ TEST_F(OpusTest, OpusEncodeDecodeMono) {
   // Encode & decode.
   int16_t encoded_bytes;
   int16_t audio_type;
-  int16_t output_data_decode_new[kOpusNumberOfSamples];
-  int16_t output_data_decode[kOpusNumberOfSamples];
+  int16_t output_data_decode_new[kOpusMaxFrameSamples];
+  int16_t output_data_decode[kOpusMaxFrameSamples];
   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
-  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_, 960,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_mono_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
-                                   &audio_type));
+  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_mono_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
 
   // Data in |output_data_decode_new| should be the same as in
   // |output_data_decode|.
-  for (int i = 0; i < 640; i++) {
+  for (int i = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(output_data_decode_new[i], output_data_decode[i]);
   }
 
@@ -154,26 +158,30 @@ TEST_F(OpusTest, OpusEncodeDecodeStereo) {
   // Encode & decode.
   int16_t encoded_bytes;
   int16_t audio_type;
-  int16_t output_data_decode_new[kOpusNumberOfSamples];
-  int16_t output_data_decode[kOpusNumberOfSamples];
-  int16_t output_data_decode_slave[kOpusNumberOfSamples];
+  int16_t output_data_decode_new[kOpusMaxFrameSamples];
+  int16_t output_data_decode[kOpusMaxFrameSamples];
+  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
-  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_, 960,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_stereo_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
+  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
+                                   encoded_bytes, output_data_decode_slave,
                                    &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
-                                        encoded_bytes, output_data_decode_slave,
-                                        &audio_type));
 
   // Data in |output_data_decode_new| should be the same as in
   // |output_data_decode| and |output_data_decode_slave| interleaved to a
   // stereo signal.
-  for (int i = 0; i < 640; i++) {
+  for (int i = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
   }
@@ -234,26 +242,30 @@ TEST_F(OpusTest, OpusDecodeInit) {
   // Encode & decode.
   int16_t encoded_bytes;
   int16_t audio_type;
-  int16_t output_data_decode_new[kOpusNumberOfSamples];
-  int16_t output_data_decode[kOpusNumberOfSamples];
-  int16_t output_data_decode_slave[kOpusNumberOfSamples];
+  int16_t output_data_decode_new[kOpusMaxFrameSamples];
+  int16_t output_data_decode[kOpusMaxFrameSamples];
+  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
-  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_, 960,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_stereo_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
+  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
+                                   encoded_bytes, output_data_decode_slave,
                                    &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
-                                        encoded_bytes, output_data_decode_slave,
-                                        &audio_type));
 
   // Data in |output_data_decode_new| should be the same as in
   // |output_data_decode| and |output_data_decode_slave| interleaved to a
   // stereo signal.
-  for (int i = 0; i < 640; i++) {
+  for (int i = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
   }
@@ -262,20 +274,23 @@ TEST_F(OpusTest, OpusDecodeInit) {
   EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_stereo_decoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderInitSlave(opus_stereo_decoder_));
 
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_stereo_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
+                                   encoded_bytes, output_data_decode_slave,
                                    &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
-                                        encoded_bytes, output_data_decode_slave,
-                                        &audio_type));
 
   // Data in |output_data_decode_new| should be the same as in
   // |output_data_decode| and |output_data_decode_slave| interleaved to a
   // stereo signal.
-  for (int i = 0; i < 640; i++) {
+  for (int i = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
   }
@@ -344,27 +359,31 @@ TEST_F(OpusTest, OpusDecodePlcMono) {
   // Encode & decode.
   int16_t encoded_bytes;
   int16_t audio_type;
-  int16_t output_data_decode_new[kOpusNumberOfSamples];
-  int16_t output_data_decode[kOpusNumberOfSamples];
+  int16_t output_data_decode_new[kOpusMaxFrameSamples];
+  int16_t output_data_decode[kOpusMaxFrameSamples];
   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
-  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_, 960,
-                                     kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_mono_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
-                                   &audio_type));
+  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_mono_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
 
   // Call decoder PLC for both versions of the decoder.
-  int16_t plc_buffer[kOpusNumberOfSamples];
-  int16_t plc_buffer_new[kOpusNumberOfSamples];
-  EXPECT_EQ(640, WebRtcOpus_DecodePlcMaster(opus_mono_decoder_, plc_buffer, 1));
-  EXPECT_EQ(640, WebRtcOpus_DecodePlc(opus_mono_decoder_new_,
-                                      plc_buffer_new, 1));
+  int16_t plc_buffer[kOpusMaxFrameSamples];
+  int16_t plc_buffer_new[kOpusMaxFrameSamples];
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodePlcMaster(opus_mono_decoder_, plc_buffer, 1));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodePlc(opus_mono_decoder_new_, plc_buffer_new, 1));
 
   // Data in |plc_buffer| should be the same as in |plc_buffer_new|.
-  for (int i = 0; i < 640; i++) {
+  for (int i = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(plc_buffer[i], plc_buffer_new[i]);
   }
 
@@ -391,36 +410,42 @@ TEST_F(OpusTest, OpusDecodePlcStereo) {
   // Encode & decode.
   int16_t encoded_bytes;
   int16_t audio_type;
-  int16_t output_data_decode_new[kOpusNumberOfSamples];
-  int16_t output_data_decode[kOpusNumberOfSamples];
-  int16_t output_data_decode_slave[kOpusNumberOfSamples];
+  int16_t output_data_decode_new[kOpusMaxFrameSamples];
+  int16_t output_data_decode[kOpusMaxFrameSamples];
+  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
-  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_, 960,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
-                                      encoded_bytes, output_data_decode_new,
-                                      &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_Decode(opus_stereo_decoder_, coded,
-                                   encoded_bytes, output_data_decode,
+  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
+                                 encoded_bytes, output_data_decode_new,
+                                 &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
+                              encoded_bytes, output_data_decode,
+                              &audio_type));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
+                                   encoded_bytes,
+                                   output_data_decode_slave,
                                    &audio_type));
-  EXPECT_EQ(640, WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
-                                        encoded_bytes,
-                                        output_data_decode_slave,
-                                        &audio_type));
 
   // Call decoder PLC for both versions of the decoder.
-  int16_t plc_buffer_left[kOpusNumberOfSamples];
-  int16_t plc_buffer_right[kOpusNumberOfSamples];
-  int16_t plc_buffer_new[kOpusNumberOfSamples];
-  EXPECT_EQ(640, WebRtcOpus_DecodePlcMaster(opus_stereo_decoder_,
-                                            plc_buffer_left, 1));
-  EXPECT_EQ(640, WebRtcOpus_DecodePlcSlave(opus_stereo_decoder_,
-                                           plc_buffer_right, 1));
-  EXPECT_EQ(640, WebRtcOpus_DecodePlc(opus_stereo_decoder_new_, plc_buffer_new,
-                                      1));
+  int16_t plc_buffer_left[kOpusMaxFrameSamples];
+  int16_t plc_buffer_right[kOpusMaxFrameSamples];
+  int16_t plc_buffer_new[kOpusMaxFrameSamples];
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodePlcMaster(opus_stereo_decoder_,
+                                       plc_buffer_left, 1));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodePlcSlave(opus_stereo_decoder_,
+                                      plc_buffer_right, 1));
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DecodePlc(opus_stereo_decoder_new_, plc_buffer_new, 1));
   // Data in |plc_buffer_left| and |plc_buffer_right|should be the same as the
   // interleaved samples in |plc_buffer_new|.
-  for (int i = 0, j = 0; i < 640; i++) {
+  for (int i = 0, j = 0; i < kOpus20msFrameSamples; i++) {
     EXPECT_EQ(plc_buffer_left[i], plc_buffer_new[j++]);
     EXPECT_EQ(plc_buffer_right[i], plc_buffer_new[j++]);
   }
@@ -437,21 +462,23 @@ TEST_F(OpusTest, OpusDurationEstimation) {
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
 
-  // Encode with different packet sizes (input 48 kHz, output in 32 kHz).
   int16_t encoded_bytes;
 
   // 10 ms.
-  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_, 480,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(320, WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
-                                        encoded_bytes));
+  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
+                                    kOpus10msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus10msFrameSamples,
+            WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
+                                   encoded_bytes));
 
   // 20 ms
-  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_, 960,
-                                    kMaxBytes, bitstream_);
-  EXPECT_EQ(640, WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
-                                        encoded_bytes));
-
+  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
+                                    kOpus20msFrameSamples, kMaxBytes,
+                                    bitstream_);
+  EXPECT_EQ(kOpus20msFrameSamples,
+            WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
+                                   encoded_bytes));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
diff --git a/modules/audio_coding/main/acm2/audio_coding_module_impl.cc b/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
index a07e8543..5ee211e8 100644
--- a/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
+++ b/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
@@ -1616,14 +1616,8 @@ int AudioCodingModuleImpl::ReceiveFrequency() const {
 
   int codec_id = receiver_.last_audio_codec_id();
 
-  int sample_rate_hz;
-  if (codec_id < 0)
-    sample_rate_hz = receiver_.current_sample_rate_hz();
-  else
-    sample_rate_hz = ACMCodecDB::database_[codec_id].plfreq;
-
-  // TODO(tlegrand): Remove this option when we have full 48 kHz support.
-  return (sample_rate_hz > 32000) ? 32000 : sample_rate_hz;
+  return codec_id < 0 ? receiver_.current_sample_rate_hz() :
+                        ACMCodecDB::database_[codec_id].plfreq;
 }
 
 // Get current playout frequency.
diff --git a/modules/audio_coding/main/test/opus_test.cc b/modules/audio_coding/main/test/opus_test.cc
index 261eb613..398d59da 100644
--- a/modules/audio_coding/main/test/opus_test.cc
+++ b/modules/audio_coding/main/test/opus_test.cc
@@ -218,6 +218,8 @@ void OpusTest::Run(TestPackStereo* channel, int channels, int bitrate,
   int written_samples = 0;
   int read_samples = 0;
   int decoded_samples = 0;
+  bool first_packet = true;
+  uint32_t start_time_stamp = 0;
 
   channel->reset_payload_size();
   counter_ = 0;
@@ -324,6 +326,10 @@ void OpusTest::Run(TestPackStereo* channel, int channels, int bitrate,
         // Send data to the channel. "channel" will handle the loss simulation.
         channel->SendData(kAudioFrameSpeech, payload_type_, rtp_timestamp_,
                           bitstream, bitstream_len_byte, NULL);
+        if (first_packet) {
+          first_packet = false;
+          start_time_stamp = rtp_timestamp_;
+        }
         rtp_timestamp_ += frame_length;
         read_samples += frame_length * channels;
       }
@@ -344,9 +350,11 @@ void OpusTest::Run(TestPackStereo* channel, int channels, int bitrate,
     // Write stand-alone speech to file.
     out_file_standalone_.Write10MsData(out_audio, decoded_samples * channels);
 
-    // Number of channels should be the same for both stand-alone and
-    // ACM-decoding.
-    EXPECT_EQ(audio_frame.num_channels_, channels);
+    if (audio_frame.timestamp_ > start_time_stamp) {
+      // Number of channels should be the same for both stand-alone and
+      // ACM-decoding.
+      EXPECT_EQ(audio_frame.num_channels_, channels);
+    }
 
     decoded_samples = 0;
   }
@@ -367,13 +375,13 @@ void OpusTest::OpenOutFile(int test_number) {
   file_stream << webrtc::test::OutputPath() << "opustest_out_"
       << test_number << ".pcm";
   file_name = file_stream.str();
-  out_file_.Open(file_name, 32000, "wb");
+  out_file_.Open(file_name, 48000, "wb");
   file_stream.str("");
   file_name = file_stream.str();
   file_stream << webrtc::test::OutputPath() << "opusstandalone_out_"
       << test_number << ".pcm";
   file_name = file_stream.str();
-  out_file_standalone_.Open(file_name, 32000, "wb");
+  out_file_standalone_.Open(file_name, 48000, "wb");
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/neteq/audio_decoder.cc b/modules/audio_coding/neteq/audio_decoder.cc
index f539bb2e..0fdaa44b 100644
--- a/modules/audio_coding/neteq/audio_decoder.cc
+++ b/modules/audio_coding/neteq/audio_decoder.cc
@@ -162,7 +162,7 @@ int AudioDecoder::CodecSampleRateHz(NetEqDecoder codec_type) {
 #ifdef WEBRTC_CODEC_OPUS
     case kDecoderOpus:
     case kDecoderOpus_2ch: {
-      return 32000;
+      return 48000;
     }
 #endif
     case kDecoderCNGswb48kHz: {
diff --git a/modules/audio_coding/neteq/audio_decoder_unittest.cc b/modules/audio_coding/neteq/audio_decoder_unittest.cc
index f82644cb..7eb31423 100644
--- a/modules/audio_coding/neteq/audio_decoder_unittest.cc
+++ b/modules/audio_coding/neteq/audio_decoder_unittest.cc
@@ -607,7 +607,7 @@ class AudioDecoderCeltStereoTest : public AudioDecoderTest {
 class AudioDecoderOpusTest : public AudioDecoderTest {
  protected:
   AudioDecoderOpusTest() : AudioDecoderTest() {
-    frame_size_ = 320;
+    frame_size_ = 480;
     data_length_ = 10 * frame_size_;
     decoder_ = new AudioDecoderOpus(kDecoderOpus);
     assert(decoder_);
@@ -618,75 +618,69 @@ class AudioDecoderOpusTest : public AudioDecoderTest {
     WebRtcOpus_EncoderFree(encoder_);
   }
 
-  virtual void InitEncoder() {}
-
-  virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
-                          uint8_t* output) {
+  virtual void SetUp() OVERRIDE {
+    AudioDecoderTest::SetUp();
     // Upsample from 32 to 48 kHz.
+    // Because Opus is 48 kHz codec but the input file is 32 kHz, so the data
+    // read in |AudioDecoderTest::SetUp| has to be upsampled.
+    // |AudioDecoderTest::SetUp| has read |data_length_| samples, which is more
+    // than necessary after upsampling, so the end of audio that has been read
+    // is unused and the end of the buffer is overwritten by the resampled data.
     Resampler rs;
     rs.Reset(32000, 48000, kResamplerSynchronous);
-    const int max_resamp_len_samples = static_cast<int>(input_len_samples) *
-        3 / 2;
-    int16_t* resamp_input = new int16_t[max_resamp_len_samples];
+    const int before_resamp_len_samples = static_cast<int>(data_length_) * 2
+        / 3;
+    int16_t* before_resamp_input = new int16_t[before_resamp_len_samples];
+    memcpy(before_resamp_input, input_,
+           sizeof(int16_t) * before_resamp_len_samples);
     int resamp_len_samples;
-    EXPECT_EQ(0, rs.Push(input, static_cast<int>(input_len_samples),
-                         resamp_input, max_resamp_len_samples,
+    EXPECT_EQ(0, rs.Push(before_resamp_input, before_resamp_len_samples,
+                         input_, static_cast<int>(data_length_),
                          resamp_len_samples));
-    EXPECT_EQ(max_resamp_len_samples, resamp_len_samples);
-    int enc_len_bytes =
-        WebRtcOpus_Encode(encoder_, resamp_input, resamp_len_samples,
-                          static_cast<int>(data_length_), output);
+    EXPECT_EQ(static_cast<int>(data_length_), resamp_len_samples);
+    delete[] before_resamp_input;
+  }
+
+  virtual void InitEncoder() {}
+
+  virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
+                          uint8_t* output) OVERRIDE {
+    int enc_len_bytes = WebRtcOpus_Encode(encoder_, const_cast<int16_t*>(input),
+        static_cast<int16_t>(input_len_samples),
+        static_cast<int16_t>(data_length_), output);
     EXPECT_GT(enc_len_bytes, 0);
-    delete [] resamp_input;
     return enc_len_bytes;
   }
 
   OpusEncInst* encoder_;
 };
 
-class AudioDecoderOpusStereoTest : public AudioDecoderTest {
+class AudioDecoderOpusStereoTest : public AudioDecoderOpusTest {
  protected:
-  AudioDecoderOpusStereoTest() : AudioDecoderTest() {
+  AudioDecoderOpusStereoTest() : AudioDecoderOpusTest() {
     channels_ = 2;
-    frame_size_ = 320;
-    data_length_ = 10 * frame_size_;
+    WebRtcOpus_EncoderFree(encoder_);
+    delete decoder_;
     decoder_ = new AudioDecoderOpus(kDecoderOpus_2ch);
     assert(decoder_);
     WebRtcOpus_EncoderCreate(&encoder_, 2);
   }
 
-  ~AudioDecoderOpusStereoTest() {
-    WebRtcOpus_EncoderFree(encoder_);
-  }
-
-  virtual void InitEncoder() {}
-
   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
-                          uint8_t* output) {
+                          uint8_t* output) OVERRIDE {
     // Create stereo by duplicating each sample in |input|.
     const int input_stereo_samples = static_cast<int>(input_len_samples) * 2;
     int16_t* input_stereo = new int16_t[input_stereo_samples];
     for (size_t i = 0; i < input_len_samples; i++)
       input_stereo[i * 2] = input_stereo[i * 2 + 1] = input[i];
-    // Upsample from 32 to 48 kHz.
-    Resampler rs;
-    rs.Reset(32000, 48000, kResamplerSynchronousStereo);
-    const int max_resamp_len_samples = input_stereo_samples * 3 / 2;
-    int16_t* resamp_input = new int16_t[max_resamp_len_samples];
-    int resamp_len_samples;
-    EXPECT_EQ(0, rs.Push(input_stereo, input_stereo_samples, resamp_input,
-                         max_resamp_len_samples, resamp_len_samples));
-    EXPECT_EQ(max_resamp_len_samples, resamp_len_samples);
-    int enc_len_bytes =
-        WebRtcOpus_Encode(encoder_, resamp_input, resamp_len_samples / 2,
-                          static_cast<int16_t>(data_length_), output);
+
+    int enc_len_bytes = WebRtcOpus_Encode(
+        encoder_, input_stereo, static_cast<int16_t>(input_len_samples),
+        static_cast<int16_t>(data_length_), output);
     EXPECT_GT(enc_len_bytes, 0);
-    delete [] resamp_input;
-    delete [] input_stereo;
+    delete[] input_stereo;
     return enc_len_bytes;
   }
-
-  OpusEncInst* encoder_;
 };
 
 TEST_F(AudioDecoderPcmUTest, EncodeDecode) {
@@ -876,11 +870,11 @@ TEST(AudioDecoder, CodecSampleRateHz) {
   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderCNGnb));
   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderCNGwb));
   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb32kHz));
+  EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus));
+  EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus_2ch));
   // TODO(tlegrand): Change 32000 to 48000 below once ACM has 48 kHz support.
   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb48kHz));
   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderArbitrary));
-  EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderOpus));
-  EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderOpus_2ch));
 #ifdef WEBRTC_CODEC_CELT
   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32));
   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32_2ch));
diff --git a/modules/audio_coding/neteq/payload_splitter_unittest.cc b/modules/audio_coding/neteq/payload_splitter_unittest.cc
index 5cde1bda..9d0aaa1d 100644
--- a/modules/audio_coding/neteq/payload_splitter_unittest.cc
+++ b/modules/audio_coding/neteq/payload_splitter_unittest.cc
@@ -743,7 +743,7 @@ TEST(FecPayloadSplitter, MixedPayload) {
   // Check first packet.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
-  EXPECT_EQ(kBaseTimestamp - 20 * 32, packet->header.timestamp);
+  EXPECT_EQ(kBaseTimestamp - 20 * 48, packet->header.timestamp);
   EXPECT_EQ(10, packet->payload_length);
   EXPECT_FALSE(packet->primary);
   delete [] packet->payload;
diff --git a/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc b/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
index ad6d8ece..66a448a1 100644
--- a/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
+++ b/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
@@ -22,8 +22,7 @@ namespace webrtc {
 namespace test {
 
 static const int kOpusBlockDurationMs = 20;
-static const int kOpusInputSamplingKhz = 48;
-static const int kOpusOutputSamplingKhz = 32;
+static const int kOpusSamplingKhz = 48;
 
 static bool ValidateInFilename(const char* flagname, const string& value) {
   FILE* fid = fopen(value.c_str(), "rb");
@@ -117,8 +116,8 @@ class NetEqOpusFecQualityTest : public NetEqQualityTest {
 };
 
 NetEqOpusFecQualityTest::NetEqOpusFecQualityTest()
-    : NetEqQualityTest(kOpusBlockDurationMs, kOpusInputSamplingKhz,
-                       kOpusOutputSamplingKhz,
+    : NetEqQualityTest(kOpusBlockDurationMs, kOpusSamplingKhz,
+                       kOpusSamplingKhz,
                        (FLAGS_channels == 1) ? kDecoderOpus : kDecoderOpus_2ch,
                        FLAGS_channels, 0.0f, FLAGS_in_filename,
                        FLAGS_out_filename),
diff --git a/modules/audio_coding/neteq/timestamp_scaler.cc b/modules/audio_coding/neteq/timestamp_scaler.cc
index 01890136..1809324b 100644
--- a/modules/audio_coding/neteq/timestamp_scaler.cc
+++ b/modules/audio_coding/neteq/timestamp_scaler.cc
@@ -48,8 +48,6 @@ uint32_t TimestampScaler::ToInternal(uint32_t external_timestamp,
       denominator_ = 1;
       break;
     }
-    case kDecoderOpus:
-    case kDecoderOpus_2ch:
     case kDecoderISACfb:
     case kDecoderCNGswb48kHz: {
       // Use timestamp scaling with factor 2/3 (32 kHz sample rate, but RTP
diff --git a/modules/audio_coding/neteq/timestamp_scaler_unittest.cc b/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
index 8cbbfa39..1cbbf7f3 100644
--- a/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
+++ b/modules/audio_coding/neteq/timestamp_scaler_unittest.cc
@@ -252,10 +252,14 @@ TEST(TimestampScaler, TestG722Reset) {
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
 }
 
+// TODO(minyue): This test becomes trivial since Opus does not need a timestamp
+// scaler. Therefore, this test may be removed in future. There is no harm to
+// keep it, since it can be taken as a test case for the situation of a trivial
+// timestamp scaler.
 TEST(TimestampScaler, TestOpusLargeStep) {
   MockDecoderDatabase db;
   DecoderDatabase::DecoderInfo info;
-  info.codec_type = kDecoderOpus;  // Uses a factor 2/3 scaling.
+  info.codec_type = kDecoderOpus;
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -273,8 +277,7 @@ TEST(TimestampScaler, TestOpusLargeStep) {
               scaler.ToInternal(external_timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(external_timestamp, scaler.ToExternal(internal_timestamp));
-    // Internal timestamp should be incremented with twice the step.
-    internal_timestamp += 2 * kStep / 3;
+    internal_timestamp += kStep;
   }
 
   EXPECT_CALL(db, Die());  // Called when database object is deleted.
@@ -283,7 +286,7 @@ TEST(TimestampScaler, TestOpusLargeStep) {
 TEST(TimestampScaler, TestIsacFbLargeStep) {
   MockDecoderDatabase db;
   DecoderDatabase::DecoderInfo info;
-  info.codec_type = kDecoderISACfb;  // Uses a factor 2/3 scaling.
+  info.codec_type = kDecoderISACfb;
   static const uint8_t kRtpPayloadType = 17;
   EXPECT_CALL(db, GetDecoderInfo(kRtpPayloadType))
       .WillRepeatedly(Return(&info));
@@ -301,7 +304,7 @@ TEST(TimestampScaler, TestIsacFbLargeStep) {
               scaler.ToInternal(external_timestamp, kRtpPayloadType));
     // Scale back.
     EXPECT_EQ(external_timestamp, scaler.ToExternal(internal_timestamp));
-    // Internal timestamp should be incremented with twice the step.
+    // Internal timestamp should be incremented with two-thirds the step.
     internal_timestamp += 2 * kStep / 3;
   }