int NlsEncoder::nlsEncoding()

in nlsCppSdk/encoder/nlsEncoder.cpp [152:253]
87 lines of code
23 McCabe index (conditional complexity)

int NlsEncoder::nlsEncoding(const uint8_t *frameBuff, const int frameLen,
                            unsigned char *outputBuffer, int outputSize) {
  if (!frameBuff || frameLen <= 0 || !outputBuffer || outputSize <= 0) {
    LOG_ERROR("invalid params");
    return 0;
  }

  unsigned char *outputTmp = NULL;
  outputTmp = (unsigned char *)malloc(outputSize);
  if (!outputTmp) {
    return 0;
  }
  memset(outputTmp, 0x0, outputSize);

  int encoderSize = -1;
  /* 1. 灌入数据开始编码 */
  if (encoder_type_ == ENCODER_OPU) {
    // uint8 to int16
    int16_t *interBuffer = (int16_t *)malloc(frameLen);
    if (interBuffer == NULL) {
      LOG_ERROR("interBuffer malloc failed");
      free(outputTmp);
      return 0;
    }
    int i = 0;
    for (i = 0; i < frameLen; i += 2) {
      interBuffer[i / 2] =
          (int16_t)((frameBuff[i + 1] << 8 & 0xff00) | (frameBuff[i] & 0xff));
    }

    encoderSize = opus_encode((OpusEncoder *)nlsEncoder_, interBuffer,
                              frameLen / 2, outputTmp, outputSize);
    //    LOG_DEBUG("frameLen:%d, outputSize:%d, encoderSize:%d",
    //        frameLen, outputSize, encoderSize);

    if (encoderSize < 0) {
      free(interBuffer);
      free(outputTmp);
      return encoderSize;
    }

    if (interBuffer) free(interBuffer);
    interBuffer = NULL;
  } else if (encoder_type_ == ENCODER_OPUS) {
#ifdef ENABLE_OGGOPUS
    encoderSize = (static_cast<OggOpusDataEncoder *>(nlsEncoder_))
                      ->OggopusEncode((const char *)frameBuff, frameLen);
    if (encoderSize != Success) {
      LOG_ERROR("OggopusEncode failed, ret %d", encoderSize);
      free(outputTmp);
      return encoderSize;
    }
#endif
  }

  /* 2. 取出编码后数据 */
  if (encoder_type_ == ENCODER_OPU) {
    *(outputBuffer + 0) = (unsigned char)encoderSize;
    memcpy((outputBuffer + 1), outputTmp, encoderSize);
    encoderSize += 1;
  } else if (encoder_type_ == ENCODER_OPUS) {
#ifdef ENABLE_OGGOPUS
    encoderSize = 0;
    int data_len = 0;
    data_len = encoded_data_.ElementNum();
    if (data_len > 0) {
      int array_idx = 0;
      int element_idx = 0;
      data_len = (data_len > outputSize) ? outputSize : data_len;
      encoderSize = encoded_data_.Get(outputTmp, data_len, &array_idx,
                                      &element_idx, true);
      if (encoderSize > 0) {
        //        LOG_DEBUG("opus encoded %dbytes", encoderSize);
        memcpy(outputBuffer, outputTmp, encoderSize);
      }
    }
#endif
  }

#ifdef OPU_DEBUG
  if (encoderSize > 0) {
    std::ofstream ofs;
    if (encoder_type_ == ENCODER_OPU) {
      ofs.open("./mid_out.opu",
               std::ios::out | std::ios::app | std::ios::binary);
    } else if (encoder_type_ == ENCODER_OPUS) {
      ofs.open("./mid_out.ogg",
               std::ios::out | std::ios::app | std::ios::binary);
    }
    if (ofs.is_open()) {
      ofs.write((const char *)outputBuffer, encoderSize);
      ofs.flush();
      ofs.close();
    }
  }
#endif

  if (outputTmp) free(outputTmp);
  outputTmp = NULL;

  return encoderSize;
}