resampler.cc

#include <stdlib.h>
#include <string.h>

#include "resampler.h"
#include "./WebRtcMoudle/signal_processing_library.h"
Resampler::Resampler()
    : state1_(nullptr), state2_(nullptr), state3_(nullptr), in_buffer_(nullptr), out_buffer_(nullptr),
      in_buffer_size_(0), out_buffer_size_(0), in_buffer_size_max_(0), out_buffer_size_max_(0), my_in_frequency_khz_(0),
      my_out_frequency_khz_(0), my_mode_(kResamplerMode1To1), num_channels_(0), slave_left_(nullptr),
      slave_right_(nullptr) {}

Resampler::Resampler(size_t inFreq, size_t outFreq, size_t num_channels) : Resampler() {
  Reset(inFreq, outFreq, num_channels);
}

Resampler::~Resampler() {
  if (state1_) { free(state1_); }
  if (state2_) { free(state2_); }
  if (state3_) { free(state3_); }
  if (in_buffer_) { free(in_buffer_); }
  if (out_buffer_) { free(out_buffer_); }

  delete slave_left_;
  delete slave_right_;
}

int Resampler::ResetIfNeeded(size_t inFreq, size_t outFreq, size_t num_channels) {
  size_t tmpInFreq_kHz = inFreq / 1000;
  size_t tmpOutFreq_kHz = outFreq / 1000;

  if ((tmpInFreq_kHz != my_in_frequency_khz_) || (tmpOutFreq_kHz != my_out_frequency_khz_) ||
      (num_channels != num_channels_)) {
    return Reset(inFreq, outFreq, num_channels);
  } else {
    return 0;
  }
}

int Resampler::Reset(size_t inFreq, size_t outFreq, size_t num_channels) {
  if (num_channels != 1 && num_channels != 2) {
    printf("Reset() called with unsupported channel count, num_channels = %d .\n", num_channels);
    return -1;
  }
  ResamplerMode mode;
  if (ComputeResamplerMode(inFreq, outFreq, &mode) != 0) {
    printf("Reset() called with unsupported sample rates, inFreq = %d , outFreq = %d .\n", inFreq, outFreq);
    return -1;
  }
  // Reinitialize internal state for the frequencies and sample rates.
  num_channels_ = num_channels;
  my_mode_ = mode;

  if (state1_) {
    free(state1_);
    state1_ = nullptr;
  }
  if (state2_) {
    free(state2_);
    state2_ = nullptr;
  }
  if (state3_) {
    free(state3_);
    state3_ = nullptr;
  }
  if (in_buffer_) {
    free(in_buffer_);
    in_buffer_ = nullptr;
  }
  if (out_buffer_) {
    free(out_buffer_);
    out_buffer_ = nullptr;
  }
  if (slave_left_) {
    delete slave_left_;
    slave_left_ = nullptr;
  }
  if (slave_right_) {
    delete slave_right_;
    slave_right_ = nullptr;
  }

  in_buffer_size_ = 0;
  out_buffer_size_ = 0;
  in_buffer_size_max_ = 0;
  out_buffer_size_max_ = 0;

  // We need to track what domain we're in.
  my_in_frequency_khz_ = inFreq / 1000;
  my_out_frequency_khz_ = outFreq / 1000;

  if (num_channels_ == 2) {
    // Create two mono resamplers.
    slave_left_ = new Resampler(inFreq, outFreq, 1);
    slave_right_ = new Resampler(inFreq, outFreq, 1);
  }

  // Now create the states we need.
  switch (my_mode_) {
  case kResamplerMode1To1:
    // No state needed;
    break;
  case kResamplerMode1To2:
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode1To3:
    state1_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
    WebRtcSpl_ResetResample16khzTo48khz(static_cast<WebRtcSpl_State16khzTo48khz*>(state1_));
    break;
  case kResamplerMode1To4:
    // 1:2
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    // 2:4
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode1To6:
    // 1:2
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    // 2:6
    state2_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
    WebRtcSpl_ResetResample16khzTo48khz(static_cast<WebRtcSpl_State16khzTo48khz*>(state2_));
    break;
  case kResamplerMode1To12:
    // 1:2
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    // 2:4
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    // 4:12
    state3_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
    WebRtcSpl_ResetResample16khzTo48khz(static_cast<WebRtcSpl_State16khzTo48khz*>(state3_));
    break;
  case kResamplerMode2To3:
    // 2:6
    state1_ = malloc(sizeof(WebRtcSpl_State16khzTo48khz));
    WebRtcSpl_ResetResample16khzTo48khz(static_cast<WebRtcSpl_State16khzTo48khz*>(state1_));
    // 6:3
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode2To11:
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));

    state2_ = malloc(sizeof(WebRtcSpl_State8khzTo22khz));
    WebRtcSpl_ResetResample8khzTo22khz(static_cast<WebRtcSpl_State8khzTo22khz*>(state2_));
    break;
  case kResamplerMode4To11:
    state1_ = malloc(sizeof(WebRtcSpl_State8khzTo22khz));
    WebRtcSpl_ResetResample8khzTo22khz(static_cast<WebRtcSpl_State8khzTo22khz*>(state1_));
    break;
  case kResamplerMode8To11:
    state1_ = malloc(sizeof(WebRtcSpl_State16khzTo22khz));
    WebRtcSpl_ResetResample16khzTo22khz(static_cast<WebRtcSpl_State16khzTo22khz*>(state1_));
    break;
  case kResamplerMode11To16:
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));

    state2_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
    WebRtcSpl_ResetResample22khzTo16khz(static_cast<WebRtcSpl_State22khzTo16khz*>(state2_));
    break;
  case kResamplerMode11To32:
    // 11 -> 22
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));

    // 22 -> 16
    state2_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
    WebRtcSpl_ResetResample22khzTo16khz(static_cast<WebRtcSpl_State22khzTo16khz*>(state2_));

    // 16 -> 32
    state3_ = malloc(8 * sizeof(int32_t));
    memset(state3_, 0, 8 * sizeof(int32_t));

    break;
  case kResamplerMode2To1:
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode3To1:
    state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
    WebRtcSpl_ResetResample48khzTo16khz(static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
    break;
  case kResamplerMode4To1:
    // 4:2
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    // 2:1
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode6To1:
    // 6:2
    state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
    WebRtcSpl_ResetResample48khzTo16khz(static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
    // 2:1
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode12To1:
    // 12:4
    state1_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
    WebRtcSpl_ResetResample48khzTo16khz(static_cast<WebRtcSpl_State48khzTo16khz*>(state1_));
    // 4:2
    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));
    // 2:1
    state3_ = malloc(8 * sizeof(int32_t));
    memset(state3_, 0, 8 * sizeof(int32_t));
    break;
  case kResamplerMode3To2:
    // 3:6
    state1_ = malloc(8 * sizeof(int32_t));
    memset(state1_, 0, 8 * sizeof(int32_t));
    // 6:2
    state2_ = malloc(sizeof(WebRtcSpl_State48khzTo16khz));
    WebRtcSpl_ResetResample48khzTo16khz(static_cast<WebRtcSpl_State48khzTo16khz*>(state2_));
    break;
  case kResamplerMode11To2:
    state1_ = malloc(sizeof(WebRtcSpl_State22khzTo8khz));
    WebRtcSpl_ResetResample22khzTo8khz(static_cast<WebRtcSpl_State22khzTo8khz*>(state1_));

    state2_ = malloc(8 * sizeof(int32_t));
    memset(state2_, 0, 8 * sizeof(int32_t));

    break;
  case kResamplerMode11To4:
    state1_ = malloc(sizeof(WebRtcSpl_State22khzTo8khz));
    WebRtcSpl_ResetResample22khzTo8khz(static_cast<WebRtcSpl_State22khzTo8khz*>(state1_));
    break;
  case kResamplerMode11To8:
    state1_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
    WebRtcSpl_ResetResample22khzTo16khz(static_cast<WebRtcSpl_State22khzTo16khz*>(state1_));
    break;
  }

  return 0;
}

int Resampler::ComputeResamplerMode(int in_freq_hz, int out_freq_hz, ResamplerMode* mode) {
  // Start with a math exercise, Euclid's algorithm to find the gcd:
  int a = in_freq_hz;
  int b = out_freq_hz;
  int c = a % b;
  while (c != 0) {
    a = b;
    b = c;
    c = a % b;
  }
  // b is now the gcd;

  // Scale with GCD
  const int reduced_in_freq = in_freq_hz / b;
  const int reduced_out_freq = out_freq_hz / b;

  if (reduced_in_freq == reduced_out_freq) {
    *mode = kResamplerMode1To1;
  } else if (reduced_in_freq == 1) {
    switch (reduced_out_freq) {
    case 2: *mode = kResamplerMode1To2; break;
    case 3: *mode = kResamplerMode1To3; break;
    case 4: *mode = kResamplerMode1To4; break;
    case 6: *mode = kResamplerMode1To6; break;
    case 12: *mode = kResamplerMode1To12; break;
    default: return -1;
    }
  } else if (reduced_out_freq == 1) {
    switch (reduced_in_freq) {
    case 2: *mode = kResamplerMode2To1; break;
    case 3: *mode = kResamplerMode3To1; break;
    case 4: *mode = kResamplerMode4To1; break;
    case 6: *mode = kResamplerMode6To1; break;
    case 12: *mode = kResamplerMode12To1; break;
    default: return -1;
    }
  } else if ((reduced_in_freq == 2) && (reduced_out_freq == 3)) {
    *mode = kResamplerMode2To3;
  } else if ((reduced_in_freq == 2) && (reduced_out_freq == 11)) {
    *mode = kResamplerMode2To11;
  } else if ((reduced_in_freq == 4) && (reduced_out_freq == 11)) {
    *mode = kResamplerMode4To11;
  } else if ((reduced_in_freq == 8) && (reduced_out_freq == 11)) {
    *mode = kResamplerMode8To11;
  } else if ((reduced_in_freq == 3) && (reduced_out_freq == 2)) {
    *mode = kResamplerMode3To2;
  } else if ((reduced_in_freq == 11) && (reduced_out_freq == 2)) {
    *mode = kResamplerMode11To2;
  } else if ((reduced_in_freq == 11) && (reduced_out_freq == 4)) {
    *mode = kResamplerMode11To4;
  } else if ((reduced_in_freq == 11) && (reduced_out_freq == 16)) {
    *mode = kResamplerMode11To16;
  } else if ((reduced_in_freq == 11) && (reduced_out_freq == 32)) {
    *mode = kResamplerMode11To32;
  } else if ((reduced_in_freq == 11) && (reduced_out_freq == 8)) {
    *mode = kResamplerMode11To8;
  } else {
    return -1;
  }
  return 0;
}

// Synchronous resampling, all output samples are written to samplesOut
int Resampler::Push(const int16_t* samplesIn, size_t lengthIn, int16_t* samplesOut, size_t maxLen, size_t& outLen) {
  if (num_channels_ == 2) {
    // Split up the signal and call the slave object for each channel
    int16_t* left = static_cast<int16_t*>(malloc(lengthIn * sizeof(int16_t) / 2));
    int16_t* right = static_cast<int16_t*>(malloc(lengthIn * sizeof(int16_t) / 2));
    int16_t* out_left = static_cast<int16_t*>(malloc(maxLen / 2 * sizeof(int16_t)));
    int16_t* out_right = static_cast<int16_t*>(malloc(maxLen / 2 * sizeof(int16_t)));
    if ((left == nullptr) || (right == nullptr) || (out_left == nullptr) || (out_right == nullptr)) {
      if (left) free(left);
      if (right) free(right);
      if (out_left) free(out_left);
      if (out_right) free(out_right);
      return -1;
    }
    int res = 0;
    for (size_t i = 0; i < lengthIn; i += 2) {
      left[i >> 1] = samplesIn[i];
      right[i >> 1] = samplesIn[i + 1];
    }

    // It's OK to overwrite the local parameter, since it's just a copy
    lengthIn = lengthIn / 2;

    size_t actualOutLen_left = 0;
    size_t actualOutLen_right = 0;
    // Do resampling for right channel
    res |= slave_left_->Push(left, lengthIn, out_left, maxLen / 2, actualOutLen_left);
    res |= slave_right_->Push(right, lengthIn, out_right, maxLen / 2, actualOutLen_right);
    if (res || (actualOutLen_left != actualOutLen_right)) {
      free(left);
      free(right);
      free(out_left);
      free(out_right);
      return -1;
    }

    // Reassemble the signal
    for (size_t i = 0; i < actualOutLen_left; i++) {
      samplesOut[i * 2] = out_left[i];
      samplesOut[i * 2 + 1] = out_right[i];
    }
    outLen = 2 * actualOutLen_left;

    free(left);
    free(right);
    free(out_left);
    free(out_right);

    return 0;
  }

  // Containers for temp samples
  int16_t* tmp;
  int16_t* tmp_2;
  // tmp data for resampling routines
  int32_t* tmp_mem;

  switch (my_mode_) {
  case kResamplerMode1To1:
    memcpy(samplesOut, samplesIn, lengthIn * sizeof(int16_t));
    outLen = lengthIn;
    break;
  case kResamplerMode1To2:
    if (maxLen < (lengthIn * 2)) { return -1; }
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut, static_cast<int32_t*>(state1_));
    outLen = lengthIn * 2;
    return 0;
  case kResamplerMode1To3:

    // We can only handle blocks of 160 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 160) != 0) { return -1; }
    if (maxLen < (lengthIn * 3)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 160) {
      WebRtcSpl_Resample16khzTo48khz(samplesIn + i, samplesOut + i * 3,
                                     static_cast<WebRtcSpl_State16khzTo48khz*>(state1_), tmp_mem);
    }
    outLen = lengthIn * 3;
    free(tmp_mem);
    return 0;
  case kResamplerMode1To4:
    if (maxLen < (lengthIn * 4)) { return -1; }

    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
    // 1:2
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));
    // 2:4
    WebRtcSpl_UpsampleBy2(tmp, lengthIn * 2, samplesOut, static_cast<int32_t*>(state2_));
    outLen = lengthIn * 4;
    free(tmp);
    return 0;
  case kResamplerMode1To6:
    // We can only handle blocks of 80 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 80) != 0) { return -1; }
    if (maxLen < (lengthIn * 6)) { return -1; }

    // 1:2

    tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));
    outLen = lengthIn * 2;

    for (size_t i = 0; i < outLen; i += 160) {
      WebRtcSpl_Resample16khzTo48khz(tmp + i, samplesOut + i * 3, static_cast<WebRtcSpl_State16khzTo48khz*>(state2_),
                                     tmp_mem);
    }
    outLen = outLen * 3;
    free(tmp_mem);
    free(tmp);

    return 0;
  case kResamplerMode1To12:
    // We can only handle blocks of 40 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 40) != 0) { return -1; }
    if (maxLen < (lengthIn * 12)) { return -1; }

    tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 4 * lengthIn));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }  // 1:2
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut, static_cast<int32_t*>(state1_));
    outLen = lengthIn * 2;
    // 2:4
    WebRtcSpl_UpsampleBy2(samplesOut, outLen, tmp, static_cast<int32_t*>(state2_));
    outLen = outLen * 2;
    // 4:12
    for (size_t i = 0; i < outLen; i += 160) {
      // WebRtcSpl_Resample16khzTo48khz() takes a block of 160 samples
      // as input and outputs a resampled block of 480 samples. The
      // data is now actually in 32 kHz sampling rate, despite the
      // function name, and with a resampling factor of three becomes
      // 96 kHz.
      WebRtcSpl_Resample16khzTo48khz(tmp + i, samplesOut + i * 3, static_cast<WebRtcSpl_State16khzTo48khz*>(state3_),
                                     tmp_mem);
    }
    outLen = outLen * 3;
    free(tmp_mem);
    free(tmp);

    return 0;
  case kResamplerMode2To3:
    if (maxLen < (lengthIn * 3 / 2)) { return -1; }
    // 2:6
    // We can only handle blocks of 160 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 160) != 0) { return -1; }
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn * 3));
    tmp_mem = static_cast<int32_t*>(malloc(336 * sizeof(int32_t)));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    for (size_t i = 0; i < lengthIn; i += 160) {
      WebRtcSpl_Resample16khzTo48khz(samplesIn + i, tmp + i * 3, static_cast<WebRtcSpl_State16khzTo48khz*>(state1_),
                                     tmp_mem);
    }
    lengthIn = lengthIn * 3;
    // 6:3
    WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut, static_cast<int32_t*>(state2_));
    outLen = lengthIn / 2;
    free(tmp);
    free(tmp_mem);
    return 0;
  case kResamplerMode2To11:

    // We can only handle blocks of 80 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 80) != 0) { return -1; }
    if (maxLen < ((lengthIn * 11) / 2)) { return -1; }
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * 2 * lengthIn));
    tmp_mem = static_cast<int32_t*>(malloc(98 * sizeof(int32_t)));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    // 1:2
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));
    lengthIn *= 2;
    for (size_t i = 0; i < lengthIn; i += 80) {
      WebRtcSpl_Resample8khzTo22khz(tmp + i, samplesOut + (i * 11) / 4,
                                    static_cast<WebRtcSpl_State8khzTo22khz*>(state2_), tmp_mem);
    }
    outLen = (lengthIn * 11) / 4;
    free(tmp_mem);
    free(tmp);
    return 0;
  case kResamplerMode4To11:

    // We can only handle blocks of 80 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 80) != 0) { return -1; }
    if (maxLen < ((lengthIn * 11) / 4)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(98 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 80) {
      WebRtcSpl_Resample8khzTo22khz(samplesIn + i, samplesOut + (i * 11) / 4,
                                    static_cast<WebRtcSpl_State8khzTo22khz*>(state1_), tmp_mem);
    }
    outLen = (lengthIn * 11) / 4;
    free(tmp_mem);
    return 0;
  case kResamplerMode8To11:
    // We can only handle blocks of 160 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 160) != 0) { return -1; }
    if (maxLen < ((lengthIn * 11) / 8)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(88 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 160) {
      WebRtcSpl_Resample16khzTo22khz(samplesIn + i, samplesOut + (i * 11) / 8,
                                     static_cast<WebRtcSpl_State16khzTo22khz*>(state1_), tmp_mem);
    }
    outLen = (lengthIn * 11) / 8;
    free(tmp_mem);
    return 0;

  case kResamplerMode11To16:
    // We can only handle blocks of 110 samples
    if ((lengthIn % 110) != 0) { return -1; }
    if (maxLen < ((lengthIn * 16) / 11)) { return -1; }

    tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn * 2)));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));

    for (size_t i = 0; i < (lengthIn * 2); i += 220) {
      WebRtcSpl_Resample22khzTo16khz(tmp + i, samplesOut + (i / 220) * 160,
                                     static_cast<WebRtcSpl_State22khzTo16khz*>(state2_), tmp_mem);
    }

    outLen = (lengthIn * 16) / 11;

    free(tmp_mem);
    free(tmp);
    return 0;

  case kResamplerMode11To32:

    // We can only handle blocks of 110 samples
    if ((lengthIn % 110) != 0) { return -1; }
    if (maxLen < ((lengthIn * 32) / 11)) { return -1; }

    tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn * 2)));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    // 11 -> 22 kHz in samplesOut
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut, static_cast<int32_t*>(state1_));

    // 22 -> 16 in tmp
    for (size_t i = 0; i < (lengthIn * 2); i += 220) {
      WebRtcSpl_Resample22khzTo16khz(samplesOut + i, tmp + (i / 220) * 160,
                                     static_cast<WebRtcSpl_State22khzTo16khz*>(state2_), tmp_mem);
    }

    // 16 -> 32 in samplesOut
    WebRtcSpl_UpsampleBy2(tmp, (lengthIn * 16) / 11, samplesOut, static_cast<int32_t*>(state3_));

    outLen = (lengthIn * 32) / 11;

    free(tmp_mem);
    free(tmp);
    return 0;

  case kResamplerMode2To1:
    if (maxLen < (lengthIn / 2)) { return -1; }
    WebRtcSpl_DownsampleBy2(samplesIn, lengthIn, samplesOut, static_cast<int32_t*>(state1_));
    outLen = lengthIn / 2;
    return 0;
  case kResamplerMode3To1:
    // We can only handle blocks of 480 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 480) != 0) { return -1; }
    if (maxLen < (lengthIn / 3)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 480) {
      WebRtcSpl_Resample48khzTo16khz(samplesIn + i, samplesOut + i / 3,
                                     static_cast<WebRtcSpl_State48khzTo16khz*>(state1_), tmp_mem);
    }
    outLen = lengthIn / 3;
    free(tmp_mem);
    return 0;
  case kResamplerMode4To1:
    if (maxLen < (lengthIn / 4)) { return -1; }
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn / 2));
    if (tmp == nullptr) { return -1; }  // 4:2
    WebRtcSpl_DownsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));
    // 2:1
    WebRtcSpl_DownsampleBy2(tmp, lengthIn / 2, samplesOut, static_cast<int32_t*>(state2_));
    outLen = lengthIn / 4;
    free(tmp);
    return 0;

  case kResamplerMode6To1:
    // We can only handle blocks of 480 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 480) != 0) { return -1; }
    if (maxLen < (lengthIn / 6)) { return -1; }

    tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 3));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      return -1;
    }
    for (size_t i = 0; i < lengthIn; i += 480) {
      WebRtcSpl_Resample48khzTo16khz(samplesIn + i, tmp + i / 3, static_cast<WebRtcSpl_State48khzTo16khz*>(state1_),
                                     tmp_mem);
    }
    outLen = lengthIn / 3;
    free(tmp_mem);
    WebRtcSpl_DownsampleBy2(tmp, outLen, samplesOut, static_cast<int32_t*>(state2_));
    free(tmp);
    outLen = outLen / 2;
    return 0;
  case kResamplerMode12To1:
    // We can only handle blocks of 480 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 480) != 0) { return -1; }
    if (maxLen < (lengthIn / 12)) { return -1; }

    tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 3));
    tmp_2 = static_cast<int16_t*>(malloc((sizeof(int16_t) * lengthIn) / 6));
    if (tmp_mem == nullptr || tmp_2 == nullptr || tmp == nullptr) {
      if (tmp_mem) free(tmp_mem);
      if (tmp) free(tmp);
      if (tmp_2) free(tmp_2);
      return -1;
    }  // 12:4
    for (size_t i = 0; i < lengthIn; i += 480) {
      // WebRtcSpl_Resample48khzTo16khz() takes a block of 480 samples
      // as input and outputs a resampled block of 160 samples. The
      // data is now actually in 96 kHz sampling rate, despite the
      // function name, and with a resampling factor of 1/3 becomes
      // 32 kHz.
      WebRtcSpl_Resample48khzTo16khz(samplesIn + i, tmp + i / 3, static_cast<WebRtcSpl_State48khzTo16khz*>(state1_),
                                     tmp_mem);
    }
    outLen = lengthIn / 3;
    free(tmp_mem);
    // 4:2
    WebRtcSpl_DownsampleBy2(tmp, outLen, tmp_2, static_cast<int32_t*>(state2_));
    outLen = outLen / 2;
    free(tmp);
    // 2:1
    WebRtcSpl_DownsampleBy2(tmp_2, outLen, samplesOut, static_cast<int32_t*>(state3_));
    free(tmp_2);
    outLen = outLen / 2;
    return 0;
  case kResamplerMode3To2:
    if (maxLen < (lengthIn * 2 / 3)) { return -1; }
    // 3:6
    tmp = static_cast<int16_t*>(malloc(sizeof(int16_t) * lengthIn * 2));
    if (tmp == nullptr) { return -1; }
    WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, static_cast<int32_t*>(state1_));
    lengthIn *= 2;
    // 6:2
    // We can only handle blocks of 480 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 480) != 0) {
      free(tmp);
      return -1;
    }
    tmp_mem = static_cast<int32_t*>(malloc(496 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 480) {
      WebRtcSpl_Resample48khzTo16khz(tmp + i, samplesOut + i / 3, static_cast<WebRtcSpl_State48khzTo16khz*>(state2_),
                                     tmp_mem);
    }
    outLen = lengthIn / 3;
    free(tmp);
    free(tmp_mem);
    return 0;
  case kResamplerMode11To2:
    // We can only handle blocks of 220 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 220) != 0) { return -1; }
    if (maxLen < ((lengthIn * 2) / 11)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(126 * sizeof(int32_t)));
    tmp = static_cast<int16_t*>(malloc((lengthIn * 4) / 11 * sizeof(int16_t)));
    if (tmp_mem == nullptr || tmp == nullptr) {
      if (tmp) free(tmp);
      if (tmp_mem) free(tmp_mem);
      return -1;
    }
    for (size_t i = 0; i < lengthIn; i += 220) {
      WebRtcSpl_Resample22khzTo8khz(samplesIn + i, tmp + (i * 4) / 11,
                                    static_cast<WebRtcSpl_State22khzTo8khz*>(state1_), tmp_mem);
    }
    lengthIn = (lengthIn * 4) / 11;

    WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut, static_cast<int32_t*>(state2_));
    outLen = lengthIn / 2;

    free(tmp_mem);
    free(tmp);
    return 0;
  case kResamplerMode11To4:
    // We can only handle blocks of 220 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 220) != 0) { return -1; }
    if (maxLen < ((lengthIn * 4) / 11)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(126 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 220) {
      WebRtcSpl_Resample22khzTo8khz(samplesIn + i, samplesOut + (i * 4) / 11,
                                    static_cast<WebRtcSpl_State22khzTo8khz*>(state1_), tmp_mem);
    }
    outLen = (lengthIn * 4) / 11;
    free(tmp_mem);
    return 0;
  case kResamplerMode11To8:
    // We can only handle blocks of 160 samples
    // Can be fixed, but I don't think it's needed
    if ((lengthIn % 220) != 0) { return -1; }
    if (maxLen < ((lengthIn * 8) / 11)) { return -1; }
    tmp_mem = static_cast<int32_t*>(malloc(104 * sizeof(int32_t)));
    if (tmp_mem == nullptr) { return -1; }
    for (size_t i = 0; i < lengthIn; i += 220) {
      WebRtcSpl_Resample22khzTo16khz(samplesIn + i, samplesOut + (i * 8) / 11,
                                     static_cast<WebRtcSpl_State22khzTo16khz*>(state1_), tmp_mem);
    }
    outLen = (lengthIn * 8) / 11;
    free(tmp_mem);
    return 0;
    break;
  }
  return 0;
}