JNIEXPORT jint JNICALL Java_org_sipdroid_codecs_SILK8_open (JNIEnv *env, jobject obj, jint compression) { int ret; if (codec_open++ != 0) return (jint)0; /* Set the samplingrate that is requested for the output */ DecControl.sampleRate = 8000; /* Create decoder */ ret = SKP_Silk_SDK_Get_Decoder_Size( &decSizeBytes ); if( ret ) { __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "\n!!!!!!!! SKP_Silk_SDK_Get_Decoder_Size returned %d", ret ); } #ifdef DEBUG_SILK8 __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "### INIT Decoder decSizeBytes = %d\n", decSizeBytes); #endif psDec = malloc( decSizeBytes ); /* Reset decoder */ ret = SKP_Silk_SDK_InitDecoder( psDec ); if( ret ) { __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "\n!!!!!!!! SKP_Silk_InitDecoder returned %d", ret ); } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "\n!!!!!!!! SKP_Silk_SDK_Get_Encoder_Size returned %d", ret ); } #ifdef DEBUG_SILK8 __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "### INIT Encoder encSizeBytes = %d\n", encSizeBytes); #endif psEnc = malloc( encSizeBytes ); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( psEnc, &encControl ); if( ret ) { __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "\n!!!!!!!! SKP_Silk_SDK_InitEncoder returned %d", ret ); } /* Set Encoder parameters */ encControl.sampleRate = fs_kHz * 1000; encControl.packetSize = packetSize_ms * fs_kHz; encControl.packetLossPercentage = packetLoss_perc; encControl.useInBandFEC = INBandFec_enabled; encControl.useDTX = DTX_enabled; encControl.complexity = compression; encControl.bitRate = targetRate_bps; return (jint)0; }
//initialize SILK codec //sets number of 20mS(160 samples) frames per packet (1-5) void SILK8_open(int fpp) { //set number of 20 mS (160 samoles) frames per packet (1-5) if ((fpp <= MAX_INPUT_FRAMES) && (fpp > 0)) skp_frames_pp = fpp; packetSize_ms = skp_frames_pp * 20; // Set the samplingrate that is requested for the output DecControl.sampleRate = 8000; // Create decoder SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes); psDec = malloc(decSizeBytes); // Reset decoder SKP_Silk_SDK_InitDecoder(psDec); // Create Encoder SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes); psEnc = malloc(encSizeBytes); // Reset Encoder SKP_Silk_SDK_InitEncoder(psEnc, &encControl); // Set Encoder parameters encControl.sampleRate = 8000; encControl.packetSize = packetSize_ms * 8; //samples per packet encControl.packetLossPercentage = packetLoss_perc; encControl.useInBandFEC = INBandFec_enabled; encControl.useDTX = DTX_enabled; encControl.complexity = compression; encControl.bitRate = targetRate_bps; }
static int encode_update(struct auenc_state **aesp, const struct aucodec *ac, struct auenc_param *prm, const char *fmtp) { struct auenc_state *st; int ret, err = 0; int32_t enc_size; (void)fmtp; if (!aesp || !ac || !prm) return EINVAL; if (*aesp) return 0; ret = SKP_Silk_SDK_Get_Encoder_Size(&enc_size); if (ret || enc_size <= 0) return EINVAL; st = mem_alloc(sizeof(*st), encode_destructor); if (!st) return ENOMEM; st->enc = mem_alloc(enc_size, NULL); if (!st->enc) { err = ENOMEM; goto out; } ret = SKP_Silk_SDK_InitEncoder(st->enc, &st->encControl); if (ret) { err = EPROTO; goto out; } st->encControl.API_sampleRate = ac->srate; st->encControl.maxInternalSampleRate = ac->srate; st->encControl.packetSize = prm->ptime * ac->srate / 1000; st->encControl.bitRate = 64000; st->encControl.complexity = 2; st->encControl.useInBandFEC = 0; st->encControl.useDTX = 0; re_printf("SILK encoder: %dHz, psize=%d, bitrate=%d, complex=%d," " fec=%d, dtx=%d\n", st->encControl.API_sampleRate, st->encControl.packetSize, st->encControl.bitRate, st->encControl.complexity, st->encControl.useInBandFEC, st->encControl.useDTX); out: if (err) mem_deref(st); else *aesp = st; return err; }
bool VoiceEncoder_Silk::ResetState() { if (m_pEncoder) SKP_Silk_SDK_InitEncoder(m_pEncoder, &this->m_encControl); if (m_pDecoder) SKP_Silk_SDK_InitDecoder(m_pDecoder); m_bufOverflowBytes.Clear(); return true; }
bool VoiceEncoder_Silk::Init(int quality) { m_targetRate_bps = 25000; m_packetLoss_perc = 0; int encSizeBytes; SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes); m_pEncoder = malloc(encSizeBytes); SKP_Silk_SDK_InitEncoder(m_pEncoder, &this->m_encControl); int decSizeBytes; SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes); m_pDecoder = malloc(decSizeBytes); SKP_Silk_SDK_InitDecoder(m_pDecoder); return true; }
virtual bool Construct() { SKP_int32 sizeBytes = 0; if (SKP_Silk_SDK_Get_Encoder_Size(&sizeBytes) != 0) return false; m_state = malloc(sizeBytes); if (m_state == NULL) return false; if (SKP_Silk_SDK_InitEncoder(m_state, &m_control) != 0) return false; m_control.API_sampleRate = m_control.maxInternalSampleRate = m_definition->sampleRate; return true; }
static void * SILKEncoderCreate (const struct PluginCodec_Definition * codec) { SKP_int ret; SKP_int32 encSizeBytes; struct SILKEncoderControl * ctxt; /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { printf( "SKP_Silk_create_encoder returned %d", ret ); } ctxt = (struct SILKEncoderControl*)malloc(1*(sizeof(struct SILKEncoderControl)+encSizeBytes)); ctxt->context = malloc( encSizeBytes ); ctxt->mutex = new CriticalSection(); // printf("\nbitrate in SILKEncoderCreate %d\n", codec->bitsPerSec); // printf( "\nSilky Encoder created"); ret = SKP_Silk_SDK_InitEncoder(ctxt->context, &ctxt->control ); if( ret ) { printf( "\nSKP_Silk_reset_encoder returned %d", ret ); } else { ctxt->control.API_sampleRate = codec->sampleRate; ctxt->control.packetSize = codec->parm.audio.samplesPerFrame; ctxt->control.maxInternalSampleRate = codec->sampleRate; ctxt->control.packetLossPercentage = 0; ctxt->control.useInBandFEC = 0; ctxt->control.useDTX = 0; ctxt->control.complexity = 2; ctxt->control.bitRate = codec->bitsPerSec; } return ctxt; }
static int create_SILK_encoder(SILK_state* st, unsigned int rtp_Hz, unsigned int avg_bit_rate) { SKP_int32 ret,encSizeBytes; /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { ERROR( "SKP_Silk_create_encoder returned %d", ret ); return ret; } st->psEnc = malloc( encSizeBytes ); if(st->psEnc == NULL) { ERROR( "could not allocate SILK encoder state" ); return -1; } /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( st->psEnc, &st->encControl ); if( ret ) { ERROR( "SKP_Silk_SDK_InitEncoder returned %d", ret ); return ret; } /* Set Encoder parameters */ st->encControl.API_sampleRate = rtp_Hz; st->encControl.maxInternalSampleRate = rtp_Hz; st->encControl.packetSize = ( 20 * rtp_Hz ) / 1000; st->encControl.packetLossPercentage = 0; st->encControl.useInBandFEC = 0; st->encControl.useDTX = 0; st->encControl.complexity = 2; st->encControl.bitRate = avg_bit_rate; return 0; }
/* * Open codec. */ static pj_status_t silk_codec_open(pjmedia_codec *codec, pjmedia_codec_param *attr ) { silk_private *silk; silk_param *sp; SKP_int st_size, err; pj_bool_t enc_use_fec; unsigned enc_bitrate, i; PJ_ASSERT_RETURN(codec && attr, PJ_EINVAL); silk = (silk_private*)codec->codec_data; sp = &silk_factory.silk_param[silk->mode]; /* Already opened? */ if (silk->enc_ready || silk->dec_ready) return PJ_SUCCESS; /* Allocate and initialize encoder */ err = SKP_Silk_SDK_Get_Encoder_Size(&st_size); if (err) { PJ_LOG(3,(THIS_FILE, "Failed to get encoder state size (err=%d)", err)); return PJMEDIA_CODEC_EFAILED; } silk->enc_st = pj_pool_zalloc(silk->pool, st_size); err = SKP_Silk_SDK_InitEncoder(silk->enc_st, &silk->enc_ctl); if (err) { PJ_LOG(3,(THIS_FILE, "Failed to init encoder (err=%d)", err)); return PJMEDIA_CODEC_EFAILED; } /* Check fmtp params */ enc_use_fec = PJ_TRUE; enc_bitrate = sp->bitrate; for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) { pjmedia_codec_fmtp *fmtp = &attr->setting.enc_fmtp; const pj_str_t STR_USEINBANDFEC = {"useinbandfec", 12}; const pj_str_t STR_MAXAVERAGEBITRATE = {"maxaveragebitrate", 17}; if (!pj_stricmp(&fmtp->param[i].name, &STR_USEINBANDFEC)) { enc_use_fec = pj_strtoul(&fmtp->param[i].val) != 0; } else if (!pj_stricmp(&fmtp->param[i].name, &STR_MAXAVERAGEBITRATE)) { enc_bitrate = pj_strtoul(&fmtp->param[i].val); if (enc_bitrate > sp->max_bitrate) { enc_bitrate = sp->max_bitrate; } } } /* Setup encoder control for encoding process */ silk->enc_ready = PJ_TRUE; silk->samples_per_frame = FRAME_LENGTH_MS * attr->info.clock_rate / 1000; silk->pcm_bytes_per_sample = attr->info.pcm_bits_per_sample / 8; silk->enc_ctl.API_sampleRate = attr->info.clock_rate; silk->enc_ctl.maxInternalSampleRate = attr->info.clock_rate; silk->enc_ctl.packetSize = attr->setting.frm_per_pkt * silk->samples_per_frame; /* For useInBandFEC setting to be useful, we need to set * packetLossPercentage greater than LBRR_LOSS_THRES (1) */ silk->enc_ctl.packetLossPercentage = SILK_ENC_CTL_PACKET_LOSS_PCT; silk->enc_ctl.useInBandFEC = enc_use_fec; silk->enc_ctl.useDTX = attr->setting.vad; silk->enc_ctl.complexity = sp->complexity; silk->enc_ctl.bitRate = enc_bitrate; /* Allocate and initialize decoder */ err = SKP_Silk_SDK_Get_Decoder_Size(&st_size); if (err) { PJ_LOG(3,(THIS_FILE, "Failed to get decoder state size (err=%d)", err)); return PJMEDIA_CODEC_EFAILED; } silk->dec_st = pj_pool_zalloc(silk->pool, st_size); err = SKP_Silk_SDK_InitDecoder(silk->dec_st); if (err) { PJ_LOG(3,(THIS_FILE, "Failed to init decoder (err=%d)", err)); return PJMEDIA_CODEC_EFAILED; } /* Setup decoder control for decoding process */ silk->dec_ctl.API_sampleRate = attr->info.clock_rate; silk->dec_ctl.framesPerPacket = 1; /* for proper PLC at start */ silk->dec_ready = PJ_TRUE; silk->dec_buf_sz = attr->info.clock_rate * attr->info.channel_cnt * attr->info.frm_ptime / 1000 * silk->pcm_bytes_per_sample; /* Inform the stream to prepare a larger buffer since we cannot parse * SILK packets and split it into individual frames. */ attr->info.max_rx_frame_size = attr->info.max_bps * attr->info.frm_ptime / 8 / 1000; if ((attr->info.max_bps * attr->info.frm_ptime) % 8000 != 0) { ++attr->info.max_rx_frame_size; } attr->info.max_rx_frame_size *= SILK_MAX_FRAMES_PER_PACKET; return PJ_SUCCESS; }
static switch_status_t switch_silk_init(switch_codec_t *codec, switch_codec_flag_t freeswitch_flags, const switch_codec_settings_t *codec_settings) { struct silk_context *context = NULL; switch_codec_fmtp_t codec_fmtp; silk_codec_settings_t silk_codec_settings; SKP_int32 encSizeBytes; SKP_int32 decSizeBytes; int encoding = (freeswitch_flags & SWITCH_CODEC_FLAG_ENCODE); int decoding = (freeswitch_flags & SWITCH_CODEC_FLAG_DECODE); if (!(encoding || decoding) || (!(context = switch_core_alloc(codec->memory_pool, sizeof(*context))))) { return SWITCH_STATUS_FALSE; } memset(&codec_fmtp, '\0', sizeof(struct switch_codec_fmtp)); codec_fmtp.private_info = &silk_codec_settings; switch_silk_fmtp_parse(codec->fmtp_in, &codec_fmtp); codec->fmtp_out = switch_core_sprintf(codec->memory_pool, "useinbandfec=%s; usedtx=%s; maxaveragebitrate=%d", silk_codec_settings.useinbandfec ? "1" : "0", silk_codec_settings.usedtx ? "1" : "0", silk_codec_settings.maxaveragebitrate ? silk_codec_settings.maxaveragebitrate : codec->implementation->bits_per_second); if (encoding) { if (SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes)) { return SWITCH_STATUS_FALSE; } context->enc_state = switch_core_alloc(codec->memory_pool, encSizeBytes); if (SKP_Silk_SDK_InitEncoder(context->enc_state, &context->encoder_object)) { return SWITCH_STATUS_FALSE; } context->encoder_object.API_sampleRate = codec->implementation->actual_samples_per_second; context->encoder_object.maxInternalSampleRate = codec->implementation->actual_samples_per_second; context->encoder_object.packetSize = codec->implementation->samples_per_packet; context->encoder_object.useInBandFEC = silk_codec_settings.useinbandfec; context->encoder_object.complexity = 0; context->encoder_object.bitRate = silk_codec_settings.maxaveragebitrate ? silk_codec_settings.maxaveragebitrate : codec->implementation->bits_per_second; context->encoder_object.useDTX = silk_codec_settings.usedtx; context->encoder_object.packetLossPercentage = silk_codec_settings.plpct; } if (decoding) { if (SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes)) { return SWITCH_STATUS_FALSE; } context->dec_state = switch_core_alloc(codec->memory_pool, decSizeBytes); if (SKP_Silk_SDK_InitDecoder(context->dec_state)) { return SWITCH_STATUS_FALSE; } context->decoder_object.API_sampleRate = codec->implementation->actual_samples_per_second; } codec->private_info = context; return SWITCH_STATUS_SUCCESS; }
/* * Open codec. */ static pj_status_t silk_codec_open(pjmedia_codec *codec, pjmedia_codec_param *attr ) { pj_status_t status; struct silk_private *silk; int id, ret = 0; unsigned i; struct silk_param params; SKP_int32 encSizeBytes, decSizeBytes, API_fs_Hz, max_internal_fs_Hz, maxBitRate; // useinbandfec: specifies that SILK in-band FEC is supported by the decoder and MAY be used during a session. // [...] If no value is specified, useinbandfec is assumed to be 1. SKP_int useInBandFEC = 1; const pj_str_t STR_FMTP_USE_INBAND_FEC = {"useinbandfec", 12}; const pj_str_t STR_FMTP_MAX_AVERAGE_BITRATE = {"maxaveragebitrate", 17}; silk = (struct silk_private*) codec->codec_data; id = silk->param_id; pj_assert(silk != NULL); pj_assert(silk->enc_ready == PJ_FALSE && silk->dec_ready == PJ_FALSE); params = silk_factory.silk_param[id]; //PJ_LOG(4, (THIS_FILE, "Open silk codec @ %d", params.clock_rate)); /* default settings */ API_fs_Hz = params.clock_rate; max_internal_fs_Hz = params.clock_rate; maxBitRate = ( params.bitrate > 0 ? params.bitrate : 0 ); /* Check fmtp params */ for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) { if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_FMTP_USE_INBAND_FEC) == 0) { useInBandFEC = (pj_uint8_t) (pj_strtoul(&attr->setting.enc_fmtp.param[i].val)); break; }else if(pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_FMTP_MAX_AVERAGE_BITRATE) == 0) { SKP_int32 remoteBitRate = (SKP_int32)(pj_strtoul(&attr->setting.enc_fmtp.param[i].val)); if(remoteBitRate < maxBitRate || maxBitRate == 0){ maxBitRate = remoteBitRate; } } } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if(ret){ PJ_LOG(1, (THIS_FILE, "Unable to get encoder size : %d", ret)); return PJ_EINVAL; } silk->psEnc = pj_pool_zalloc(silk->pool, encSizeBytes); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( silk->psEnc, &silk->enc ); if(ret){ PJ_LOG(1, (THIS_FILE, "Unable to init encoder : %d", ret)); return PJ_EINVAL; } /* Set Encoder parameters */ silk->enc.API_sampleRate = API_fs_Hz; silk->enc.maxInternalSampleRate = max_internal_fs_Hz; silk->enc.packetSize = ( params.packet_size_ms * API_fs_Hz ) / 1000; // TODO : our packet loss percentage is probably not always 0... // Should this be configurable? Or set to some value so that FEC works? Well ... if we can get it working... silk->enc.packetLossPercentage = 0; silk->enc.useInBandFEC = useInBandFEC; silk->enc.useDTX = 0; silk->enc.complexity = params.complexity; silk->enc.bitRate = maxBitRate; silk->enc_ready = PJ_TRUE; //Decoder /* Create decoder */ ret = SKP_Silk_SDK_Get_Decoder_Size( &decSizeBytes ); if(ret){ PJ_LOG(1, (THIS_FILE, "Unable to get dencoder size : %d", ret)); return PJ_EINVAL; } silk->psDec = pj_pool_zalloc(silk->pool, decSizeBytes); /* Reset decoder */ ret = SKP_Silk_SDK_InitDecoder( silk->psDec ); if(ret){ PJ_LOG(1, (THIS_FILE, "Unable to init dencoder : %d", ret)); return PJ_EINVAL; } /* Set Decoder parameters */ silk->dec.API_sampleRate = API_fs_Hz; silk->dec_ready = PJ_TRUE; return PJ_SUCCESS; }
bool MIPSILKEncoder::init(int samplingRate, MIPTime interval, int targetBitrate, int encoderSamplingRate) { if (m_init) { setErrorString(MIPSILKENCODER_ERRSTR_ALREADYINIT); return false; } if (!(samplingRate == 8000 || samplingRate == 12000 || samplingRate == 16000 || samplingRate == 24000 || samplingRate == 32000 || samplingRate == 44100 || samplingRate == 48000 )) { setErrorString(MIPSILKENCODER_ERRSTR_INVALIDINPUTSAMPLINGRATE); return false; } if (!(encoderSamplingRate == 8000 || encoderSamplingRate == 12000 || encoderSamplingRate == 16000 || encoderSamplingRate == 24000 )) { setErrorString(MIPSILKENCODER_ERRSTR_INVALIDENCODERSAMPLINGRATE); return false; } if (targetBitrate < 0) targetBitrate = 0; /* if (targetBitrate < 5000 || targetBitrate > 100000) { setErrorString(MIPSILKENCODER_ERRSTR_INVALIDBITRATE); return false; } */ int intervalMs = (int)(interval.getValue()*1000.0 + 0.5); if (!(intervalMs == 20 || intervalMs == 40 || intervalMs == 60 || intervalMs == 80 || intervalMs == 100 )) { setErrorString(MIPSILKENCODER_ERRSTR_INVALIDINTERVAL); return false; } int frameSize = (samplingRate*intervalMs)/1000; int frameSize2 = (int)((double)samplingRate * interval.getValue() + 0.5); if (frameSize2 != frameSize) { setErrorString(MIPSILKENCODER_ERRSTR_INVALIDINTERVAL); return false; } int32_t encSize = 0; int status = SKP_Silk_SDK_Get_Encoder_Size(&encSize); if (status != 0) { setErrorString(MIPSILKENCODER_ERRSTR_CANTGETENCODERSIZE); return false; } m_pState = new uint8_t[encSize]; m_pEncoderControlStruct = new SKP_SILK_SDK_EncControlStruct; SKP_SILK_SDK_EncControlStruct *pCtrl = (SKP_SILK_SDK_EncControlStruct *)m_pEncoderControlStruct; status = SKP_Silk_SDK_InitEncoder(m_pState, pCtrl); if (status != 0) { setErrorString(MIPSILKENCODER_ERRSTR_CANTINITENCODER); delete [] m_pState; delete pCtrl; return false; } pCtrl->API_sampleRate = samplingRate; pCtrl->maxInternalSampleRate = encoderSamplingRate; pCtrl->packetSize = frameSize; pCtrl->bitRate = targetBitrate; pCtrl->packetLossPercentage = 0; pCtrl->complexity = 2; pCtrl->useInBandFEC = 0; pCtrl->useDTX = 0; // TODO: when this is 1, output size can be 0! m_inputSamplingRate = samplingRate; m_maxInternalSamplingRate = samplingRate; m_frameSize = frameSize; m_targetBitrate = targetBitrate; m_prevIteration = -1; m_msgIt = m_messages.begin(); m_init = true; return true; }
static int lintosilk_new(struct ast_trans_pvt *pvt) { SKP_int32 ret; int silk_samplerate = 8000; int slin_samplerate = 8000; struct silk_coder_pvt *coder = pvt->pvt; char format_string[100]; char* pointer = format_string; char* format; struct ast_format format_struct; struct ast_format* format_def = &format_struct; int attr_dtx = 0, attr_fec = 0, attr_pktloss_pct = 0, attr_max_bitrate = 0, attr_samp_rate = 0; /* init the silk encoder */ coder->psEnc = malloc(encSizeBytes); ret = SKP_Silk_SDK_InitEncoder(coder->psEnc, &coder->encControl); if (ret) { ast_log(LOG_WARNING, "SKP_Silk_SDK_InitEncoder returned %d\n", ret); } /* Get the names of the silk codecs */ ast_getformatname_multiple_byid(format_string, sizeof(format_string), AST_FORMAT_SILK); /* The destination sample rate is set explicitly */ ret = ast_format_get_value(&pvt->explicit_dst, SILK_ATTR_KEY_SAMP_RATE, &attr_samp_rate); switch(attr_samp_rate){ case SILK_ATTR_VAL_SAMP_8KHZ: silk_samplerate = 8000; break; case SILK_ATTR_VAL_SAMP_12KHZ: silk_samplerate = 12000; break; case SILK_ATTR_VAL_SAMP_16KHZ: silk_samplerate = 16000; break; case SILK_ATTR_VAL_SAMP_24KHZ: silk_samplerate = 24000; break; } /* get the source rate */ switch(pvt->t->src_format.id){ case AST_FORMAT_SLINEAR: slin_samplerate = 8000; break; case AST_FORMAT_SLINEAR12: slin_samplerate = 12000; break; case AST_FORMAT_SLINEAR16: slin_samplerate = 16000; break; case AST_FORMAT_SLINEAR24: slin_samplerate = 24000; break; default: slin_samplerate = 8000; break; } /* SILK Docs say that internal sampling rate > API Sampling rate is not allowed */ if(slin_samplerate < silk_samplerate){ silk_samplerate = slin_samplerate; } /* set the parameters for the coder */ coder->encControl.API_sampleRate = (SKP_int32)slin_samplerate; /* lin input rate */ coder->encControl.maxInternalSampleRate = (SKP_int32)silk_samplerate; /* silk output rate */ coder->encControl.packetSize = (packetSize_ms * slin_samplerate) / 1000; coder->encControl.complexity = complexity; while ((format = strsep(&pointer, "(|)"))){ if(strlen(format) > 0){ if((format_def = ast_getformatbyname(format, format_def))){ /* now pull out the format attributes */ ret = ast_format_get_value(format_def, SILK_ATTR_KEY_DTX, &attr_dtx); coder->encControl.useDTX = !ret ? (SKP_int32)attr_dtx : useDTX; ret = ast_format_get_value(format_def, SILK_ATTR_KEY_FEC, &attr_fec); coder->encControl.useInBandFEC = !ret ? (SKP_int32)attr_fec : useInBandFEC; ret = ast_format_get_value(format_def, SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE, &attr_pktloss_pct); coder->encControl.packetLossPercentage = !ret ? (SKP_int32)attr_pktloss_pct : packetLossPercentage; ret = ast_format_get_value(format_def, SILK_ATTR_KEY_MAX_BITRATE, &attr_max_bitrate); coder->encControl.bitRate = !ret ? (SKP_int32)attr_max_bitrate : bitRate; break; } } } return 0; }
void init_silk_encoder() { /* If no max internal is specified, set to minimum of API fs and 24 kHz */ if( max_internal_fs_Hz == 0 ) { max_internal_fs_Hz = 8000; if( API_fs_Hz < max_internal_fs_Hz ) { max_internal_fs_Hz = API_fs_Hz; } } /* Print options */ if( !quiet ) { printf("******************* Silk Encoder v %s ****************\n", SKP_Silk_SDK_get_version()); printf("******************* Compiled for %d bit cpu ********* \n", (int)sizeof(void*) * 8 ); printf( "Input: %s\n", speechInFileName ); printf( "Output: %s\n", bitOutFileName ); printf( "API sampling rate: %d Hz\n", API_fs_Hz ); printf( "Maximum internal sampling rate: %d Hz\n", max_internal_fs_Hz ); printf( "Packet interval: %d ms\n", packetSize_ms ); printf( "Inband FEC used: %d\n", INBandFEC_enabled ); printf( "DTX used: %d\n", DTX_enabled ); printf( "Complexity: %d\n", complexity_mode ); printf( "Target bitrate: %d bps\n", targetRate_bps ); } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { printf( "\nSKP_Silk_create_encoder returned %d", ret ); } printf("encSizeBytes: %d\n", encSizeBytes); psEnc = malloc(encSizeBytes); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( psEnc, &encControl ); if(ret) { printf( "\nSKP_Silk_reset_encoder returned %d", ret ); } //printf("111111111111\n"); /* Set Encoder parameters */ encControl.API_sampleRate = API_fs_Hz; encControl.maxInternalSampleRate = max_internal_fs_Hz; encControl.packetSize = ( packetSize_ms * API_fs_Hz ) / 1000; encControl.packetLossPercentage = packetLoss_perc; encControl.useInBandFEC = INBandFEC_enabled; encControl.useDTX = DTX_enabled; encControl.complexity = complexity_mode; encControl.bitRate = ( targetRate_bps > 0 ? targetRate_bps : 0 ); if( API_fs_Hz > MAX_API_FS_KHZ * 1000 || API_fs_Hz < 0 ) { printf( "\nError: API sampling rate = %d out of range, valid range 8000 - 48000 \n \n", API_fs_Hz ); exit( 0 ); } //printf("22222222\n"); totPackets = 0; totActPackets = 0; smplsSinceLastPacket = 0; sumBytes = 0.0; sumActBytes = 0.0; }
int main( int argc, char* argv[] ) { unsigned long int temp=0; clock_t start_cycles,stop_cycles; double filetime; size_t counter; SKP_int32 args, totPackets, ret, nBytes; double sumBytes,avg_rate; SKP_int16 in[ MAX_FRAME_LENGTH_MS * MAX_API_FS_KHZ * MAX_INPUT_FRAMES ]; char speechInFileName[ 150 ], bitOutFileName[ 150 ]; FILE *bitOutFile, *speechInFile; SKP_int32 encSizeBytes; void *psEnc; SKP_uint8 range_buf[ MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES ]; ec_enc range_enc_celt_state; /* default settings */ SKP_int32 API_fs_Hz = 48000; SKP_int32 max_internal_fs_Hz = 16000; SKP_int32 min_internal_fs_Hz = 8000; SKP_int32 targetRate_bps = 64000; SKP_int32 packetSize_ms = 20; SKP_int32 frameSizeReadFromFile_ms = 10; SKP_int32 complexity_mode = 2, smplsSinceLastPacket; SKP_int32 quiet = 0; SKP_SILK_SDK_EncControlStruct encControl; // Struct for input to encoder if( argc < 3 ) { print_usage( argv ); exit( 0 ); } /* get arguments */ args = 1; strcpy( speechInFileName, argv[ args ] ); args++; strcpy( bitOutFileName, argv[ args ] ); args++; while( args < argc ) { if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &API_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs_maxInternal" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &max_internal_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-plength" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &packetSize_ms ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-rate" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &targetRate_bps ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &complexity_mode ); args += 2; }else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-quiet" ) == 0 ) { quiet = 1; args++; } else { printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); print_usage( argv ); exit( 0 ); } } /* If no max internal set set to API fs */ if( max_internal_fs_Hz == 0 ) { max_internal_fs_Hz = API_fs_Hz; } /* Print options */ if( !quiet ) { printf("******************* Compiled for %d bit cpu ********* \n", (int)sizeof(void*) * 8 ); printf( "Input: %s\n", speechInFileName ); printf( "Output: %s\n", bitOutFileName ); printf( "API sampling rate: %d Hz\n", API_fs_Hz ); printf( "Maximum internal sampling rate: %d Hz\n", max_internal_fs_Hz ); printf( "Packet interval: %d ms\n", packetSize_ms ); printf( "Complexity: %d\n", complexity_mode ); printf( "Target bitrate: %d bps\n", targetRate_bps ); } /* Open files */ speechInFile = fopen( speechInFileName, "rb" ); if( speechInFile == NULL ) { printf( "Error: could not open input file %s\n", speechInFileName ); exit( 0 ); } bitOutFile = fopen( bitOutFileName, "wb" ); if( bitOutFile == NULL ) { printf( "Error: could not open output file %s\n", bitOutFileName ); exit( 0 ); } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { printf( "\nSKP_Silk_create_encoder returned %d", ret ); } psEnc = malloc( encSizeBytes ); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( psEnc, &encControl ); if( ret ) { printf( "\nSKP_Silk_reset_encoder returned %d", ret ); } /* Set Encoder parameters */ encControl.API_sampleRate = API_fs_Hz; encControl.maxInternalSampleRate = max_internal_fs_Hz; encControl.minInternalSampleRate = min_internal_fs_Hz; encControl.payloadSize_ms = packetSize_ms; encControl.complexity = complexity_mode; encControl.bitRate = ( targetRate_bps > 0 ? targetRate_bps : 0 ); if( API_fs_Hz > MAX_API_FS_KHZ * 1000 || API_fs_Hz < 0 ) { printf( "\nError: API sampling rate = %d out of range, valid range 8000 - 48000 \n \n", API_fs_Hz ); exit( 0 ); } /*Reset init */ totPackets = 0; // totActPackets = 0; smplsSinceLastPacket = 0; sumBytes = 0.0; // sumActBytes = 0.0; while( 1 ) { if( smplsSinceLastPacket == 0 ) { /* Init range coder */ ec_enc_init( &range_enc_celt_state, range_buf, MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES ); } /* Read input from file */ counter = fread( in, sizeof( SKP_int16 ), ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000, speechInFile ); /*check end of input file*/ if( (SKP_int)counter < ( ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000 ) ) { break; } /* max payload size */ nBytes = MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES; /////////////* Silk Encoder *///////////////////// start_cycles = clock(); ret = SKP_Silk_SDK_Encode( psEnc, &encControl, in, (SKP_int16)counter, &range_enc_celt_state, &nBytes, 0 ); stop_cycles = clock(); temp = temp + (stop_cycles - start_cycles); if( ret ) { printf( "\nSKP_Silk_Encode returned %d", ret ); break; } ////////////////////////////////////////////////// /* Get packet size */ packetSize_ms = encControl.payloadSize_ms; smplsSinceLastPacket += ( SKP_int )counter; if( ( ( 1000 * smplsSinceLastPacket ) / API_fs_Hz ) == packetSize_ms ) { /* Finish up the range coder */ ec_enc_done( &range_enc_celt_state ); /* Sends a dummy zero size packet in case of DTX period */ /* to make it work with the decoder test program. */ /* In practice should be handled by RTP sequence numbers */ totPackets++; sumBytes += nBytes; /* Write payload size */ fwrite( &nBytes, sizeof( SKP_int32 ), 1, bitOutFile ); /* Write payload */ fwrite( range_buf, sizeof( SKP_uint8 ), nBytes, bitOutFile ); smplsSinceLastPacket = 0; } } /* Write dummy because it can not end with 0 bytes */ nBytes = -1; /* Write payload size */ fwrite( &nBytes, sizeof( SKP_int32 ), 1, bitOutFile ); /* Free Encoder */ free( psEnc ); fclose( speechInFile ); fclose( bitOutFile ); filetime = totPackets * 1e-3 * packetSize_ms; avg_rate = 8.0 / packetSize_ms * sumBytes / totPackets; // act_rate = 8.0 / packetSize_ms * sumActBytes / totActPackets; if( !quiet ) { printf( "Took %ld cycles to decode...\n", temp); printf( "\nFile length: %.3f s\n", filetime ); printf( "\nAverage bitrate: %.3f kbps\n", avg_rate ); printf( "\rPackets encoded: %d\n", totPackets ); // printf( "\nActive bitrate: %.3f kbps", act_rate ); printf( "\n\n" ); } return 0; }
int main( int argc, char* argv[] ) { unsigned long tottime, starttime; double filetime; size_t counter; SKP_int32 k, args, totPackets, totActPackets, ret; SKP_int16 nBytes; double sumBytes, sumActBytes, avg_rate, act_rate, nrg; SKP_uint8 payload[ MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES ]; SKP_int16 in[ FRAME_LENGTH_MS * MAX_API_FS_KHZ * MAX_INPUT_FRAMES ]; char speechInFileName[ 150 ], bitOutFileName[ 150 ]; FILE *bitOutFile, *speechInFile; SKP_int32 encSizeBytes; void *psEnc; #ifdef _SYSTEM_IS_BIG_ENDIAN SKP_int16 nBytes_LE; #endif /* default settings */ SKP_int32 API_fs_Hz = 24000; SKP_int32 max_internal_fs_Hz = 0; SKP_int32 targetRate_bps = 25000; SKP_int32 smplsSinceLastPacket, packetSize_ms = 20; SKP_int32 frameSizeReadFromFile_ms = 20; SKP_int32 packetLoss_perc = 0; #if LOW_COMPLEXITY_ONLY SKP_int32 complexity_mode = 0; #else SKP_int32 complexity_mode = 2; #endif SKP_int32 DTX_enabled = 0, INBandFEC_enabled = 0, quiet = 0; SKP_SILK_SDK_EncControlStruct encControl; // Struct for input to encoder SKP_SILK_SDK_EncControlStruct encStatus; // Struct for status of encoder if( argc < 3 ) { print_usage( argv ); exit( 0 ); } /* get arguments */ args = 1; strcpy( speechInFileName, argv[ args ] ); args++; strcpy( bitOutFileName, argv[ args ] ); args++; while( args < argc ) { if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs_API" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &API_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs_maxInternal" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &max_internal_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-packetlength" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &packetSize_ms ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-rate" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &targetRate_bps ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-loss" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &packetLoss_perc ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &complexity_mode ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-inbandFEC" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &INBandFEC_enabled ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-DTX") == 0 ) { sscanf( argv[ args + 1 ], "%d", &DTX_enabled ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-quiet" ) == 0 ) { quiet = 1; args++; } else { printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); print_usage( argv ); exit( 0 ); } } /* If no max internal is specified, set to minimum of API fs and 24 kHz */ if( max_internal_fs_Hz == 0 ) { max_internal_fs_Hz = 24000; if( API_fs_Hz < max_internal_fs_Hz ) { max_internal_fs_Hz = API_fs_Hz; } } /* Print options */ if( !quiet ) { printf("********** Silk Encoder (Fixed Point) v %s ********************\n", SKP_Silk_SDK_get_version()); printf("********** Compiled for %d bit cpu ******************************* \n", (int)sizeof(void*) * 8 ); printf( "Input: %s\n", speechInFileName ); printf( "Output: %s\n", bitOutFileName ); printf( "API sampling rate: %d Hz\n", API_fs_Hz ); printf( "Maximum internal sampling rate: %d Hz\n", max_internal_fs_Hz ); printf( "Packet interval: %d ms\n", packetSize_ms ); printf( "Inband FEC used: %d\n", INBandFEC_enabled ); printf( "DTX used: %d\n", DTX_enabled ); printf( "Complexity: %d\n", complexity_mode ); printf( "Target bitrate: %d bps\n", targetRate_bps ); } /* Open files */ speechInFile = fopen( speechInFileName, "rb" ); if( speechInFile == NULL ) { printf( "Error: could not open input file %s\n", speechInFileName ); exit( 0 ); } bitOutFile = fopen( bitOutFileName, "wb" ); if( bitOutFile == NULL ) { printf( "Error: could not open output file %s\n", bitOutFileName ); exit( 0 ); } /* Add Silk header to stream */ { static const char Silk_header[] = "#!SILK_V3"; fwrite( Silk_header, sizeof( char ), strlen( Silk_header ), bitOutFile ); } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { printf( "\nError: SKP_Silk_create_encoder returned %d\n", ret ); exit( 0 ); } psEnc = malloc( encSizeBytes ); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( psEnc, &encStatus ); if( ret ) { printf( "\nError: SKP_Silk_reset_encoder returned %d\n", ret ); exit( 0 ); } /* Set Encoder parameters */ encControl.API_sampleRate = API_fs_Hz; encControl.maxInternalSampleRate = max_internal_fs_Hz; encControl.packetSize = ( packetSize_ms * API_fs_Hz ) / 1000; encControl.packetLossPercentage = packetLoss_perc; encControl.useInBandFEC = INBandFEC_enabled; encControl.useDTX = DTX_enabled; encControl.complexity = complexity_mode; encControl.bitRate = ( targetRate_bps > 0 ? targetRate_bps : 0 ); if( API_fs_Hz > MAX_API_FS_KHZ * 1000 || API_fs_Hz < 0 ) { printf( "\nError: API sampling rate = %d out of range, valid range 8000 - 48000 \n \n", API_fs_Hz ); exit( 0 ); } tottime = 0; totPackets = 0; totActPackets = 0; smplsSinceLastPacket = 0; sumBytes = 0.0; sumActBytes = 0.0; smplsSinceLastPacket = 0; while( 1 ) { /* Read input from file */ counter = fread( in, sizeof( SKP_int16 ), ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000, speechInFile ); #ifdef _SYSTEM_IS_BIG_ENDIAN swap_endian( in, counter ); #endif if( ( SKP_int )counter < ( ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000 ) ) { break; } /* max payload size */ nBytes = MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES; starttime = GetHighResolutionTime(); /* Silk Encoder */ ret = SKP_Silk_SDK_Encode( psEnc, &encControl, in, (SKP_int16)counter, payload, &nBytes ); if( ret ) { printf( "\nSKP_Silk_Encode returned %d", ret ); } tottime += GetHighResolutionTime() - starttime; /* Get packet size */ packetSize_ms = ( SKP_int )( ( 1000 * ( SKP_int32 )encControl.packetSize ) / encControl.API_sampleRate ); smplsSinceLastPacket += ( SKP_int )counter; if( ( ( 1000 * smplsSinceLastPacket ) / API_fs_Hz ) == packetSize_ms ) { /* Sends a dummy zero size packet in case of DTX period */ /* to make it work with the decoder test program. */ /* In practice should be handled by RTP sequence numbers */ totPackets++; sumBytes += nBytes; nrg = 0.0; for( k = 0; k < ( SKP_int )counter; k++ ) { nrg += in[ k ] * (double)in[ k ]; } if( ( nrg / ( SKP_int )counter ) > 1e3 ) { sumActBytes += nBytes; totActPackets++; } /* Write payload size */ #ifdef _SYSTEM_IS_BIG_ENDIAN nBytes_LE = nBytes; swap_endian( &nBytes_LE, 1 ); fwrite( &nBytes_LE, sizeof( SKP_int16 ), 1, bitOutFile ); #else fwrite( &nBytes, sizeof( SKP_int16 ), 1, bitOutFile ); #endif /* Write payload */ fwrite( payload, sizeof( SKP_uint8 ), nBytes, bitOutFile ); smplsSinceLastPacket = 0; if( !quiet ) { fprintf( stderr, "\rPackets encoded: %d", totPackets ); } } } /* Write dummy because it can not end with 0 bytes */ nBytes = -1; /* Write payload size */ fwrite( &nBytes, sizeof( SKP_int16 ), 1, bitOutFile ); /* Free Encoder */ free( psEnc ); fclose( speechInFile ); fclose( bitOutFile ); filetime = totPackets * 1e-3 * packetSize_ms; avg_rate = 8.0 / packetSize_ms * sumBytes / totPackets; act_rate = 8.0 / packetSize_ms * sumActBytes / totActPackets; if( !quiet ) { printf( "\nFile length: %.3f s", filetime ); printf( "\nTime for encoding: %.3f s (%.3f%% of realtime)", 1e-6 * tottime, 1e-4 * tottime / filetime ); printf( "\nAverage bitrate: %.3f kbps", avg_rate ); printf( "\nActive bitrate: %.3f kbps", act_rate ); printf( "\n\n" ); } else { /* print time and % of realtime */ printf("%.3f %.3f %d ", 1e-6 * tottime, 1e-4 * tottime / filetime, totPackets ); /* print average and active bitrates */ printf( "%.3f %.3f \n", avg_rate, act_rate ); } return 0; }
static switch_status_t switch_silk_init(switch_codec_t *codec, switch_codec_flag_t freeswitch_flags, const switch_codec_settings_t *codec_settings) { struct silk_context *context = NULL; SKP_int useinbandfec = 0, usedtx = 0, maxaveragebitrate = 0, plpct =0; SKP_int32 encSizeBytes; SKP_int32 decSizeBytes; int encoding = (freeswitch_flags & SWITCH_CODEC_FLAG_ENCODE); int decoding = (freeswitch_flags & SWITCH_CODEC_FLAG_DECODE); if (!(encoding || decoding) || (!(context = switch_core_alloc(codec->memory_pool, sizeof(*context))))) { return SWITCH_STATUS_FALSE; } if (codec->fmtp_in) { int x, argc; char *argv[10]; argc = switch_separate_string(codec->fmtp_in, ';', argv, (sizeof(argv) / sizeof(argv[0]))); for (x = 0; x < argc; x++) { char *data = argv[x]; char *arg; switch_assert(data); while (*data == ' ') { data++; } if ((arg = strchr(data, '='))) { *arg++ = '\0'; if (!strcasecmp(data, "useinbandfec")) { if (switch_true(arg)) { useinbandfec = 1; plpct = 10;// 10% for now } } if (!strcasecmp(data, "usedtx")) { if (switch_true(arg)) { usedtx = 1; } } if (!strcasecmp(data, "maxaveragebitrate")) { maxaveragebitrate = atoi(arg); switch(codec->implementation->actual_samples_per_second) { case 8000: { if(maxaveragebitrate < 6000 || maxaveragebitrate > 20000) { maxaveragebitrate = 20000; } break; } case 12000: { if(maxaveragebitrate < 7000 || maxaveragebitrate > 25000) { maxaveragebitrate = 25000; } break; } case 16000: { if(maxaveragebitrate < 8000 || maxaveragebitrate > 30000) { maxaveragebitrate = 30000; } break; } case 24000: { if(maxaveragebitrate < 12000 || maxaveragebitrate > 40000) { maxaveragebitrate = 40000; } break; } default: /* this should never happen but 20000 is common among all rates */ maxaveragebitrate = 20000; break; } } } } } codec->fmtp_out = switch_core_sprintf(codec->memory_pool, "useinbandfec=%s; usedtx=%s; maxaveragebitrate=%d", useinbandfec ? "true" : "false", usedtx ? "true" : "false", maxaveragebitrate ? maxaveragebitrate : codec->implementation->bits_per_second); if (encoding) { if (SKP_Silk_SDK_Get_Encoder_Size(&encSizeBytes)) { return SWITCH_STATUS_FALSE; } context->enc_state = switch_core_alloc(codec->memory_pool, encSizeBytes); if (SKP_Silk_SDK_InitEncoder(context->enc_state, &context->encoder_object)) { return SWITCH_STATUS_FALSE; } context->encoder_object.sampleRate = codec->implementation->actual_samples_per_second; context->encoder_object.packetSize = codec->implementation->samples_per_packet; context->encoder_object.useInBandFEC = useinbandfec; context->encoder_object.complexity = 2; context->encoder_object.bitRate = maxaveragebitrate ? maxaveragebitrate : codec->implementation->bits_per_second; context->encoder_object.useDTX = usedtx; context->encoder_object.packetLossPercentage = plpct;; } if (decoding) { if (SKP_Silk_SDK_Get_Decoder_Size(&decSizeBytes)) { return SWITCH_STATUS_FALSE; } context->dec_state = switch_core_alloc(codec->memory_pool, decSizeBytes); if (SKP_Silk_SDK_InitDecoder(context->dec_state)) { return SWITCH_STATUS_FALSE; } context->decoder_object.sampleRate = codec->implementation->actual_samples_per_second; } codec->private_info = context; return SWITCH_STATUS_SUCCESS; }