silk音频编解码C++类

/*silkcodec头文件*/

/*

* QQ: 617242746

* Developer: yu

* Time: 2013.4.16

*/

#ifndef _SILKCODEC_H_

#define _SILKCODEC_H_

#include "interface/SKP_Silk_SDK_API.h"

#include

#include

#pragma comment(lib,"")

#define MAX_BYTES_PRE_FRAME 250

#define MAX_INPUT_FRAME 5

#define MAX_API_FS_KHZ 48

#define FRAME_LENGTH_MS 20

#define SAFE_DELETE_ELEMENT(hp) if(hp != NULL){delete hp; hp = NULL;}

class SilkEncoder

{

public:

SilkEncoder();

~SilkEncoder();

void InitEncoder();

void SetEncoderParameter();

void CreateEncoder();

void StartEncoder(const SKP_int16* samplesIn, SKP_int counter

SKP_uint8** samplesOut, SKP_int16* bytesOut);

private:

SKP_SILK_SDK_EncControlStruct m_encControl;

SKP_SILK_SDK_EncControlStruct m_encStatus;

char* m_psEnc;

SKP_int32 m_enSizeBytesEncode;

// SKP_int16 in[FRAME_LENGTH_MS * MAX_API_FS_KHZ * MAX_INPUT_FRAME];

SKP_uint8* m_payloadEncode;

SKP_int16 m_nBytesEncode;

/*param*/

SKP_int m_packetSize_ms;

SKP_int m_API_fs_Hz;

SKP_int m_bitRate;

,

SKP_int m_complexity;

};

class SilkDecoder

{

public:

SilkDecoder();

~SilkDecoder();

void InitDecoder();

void SetDecoderParameter();

void CreateDecoder();

void StartDecoder(SKP_uint8* inData, SKP_int nBytesIn, SKP_int16**

samplesOutDec, SKP_int16* nSamplesOutDec);

private:

SKP_SILK_SDK_DecControlStruct m_decControl;

SKP_int32 m_enSizeBytesDecode;

char* m_psDec;

SKP_int16* m_samplesOutDecode;

SKP_int16 m_nSamplesOutDecode;

/*param*/

SKP_int m_packetSize_ms;

SKP_int m_API_sampleRate;

SKP_int m_framesPerPacket;

};

#endif

/*silkcodec 源文件*/

#include "silkcodec.h"

SilkEncoder::SilkEncoder()

{

m_nBytesEncode = MAX_BYTES_PRE_FRAME * MAX_INPUT_FRAME;

m_packetSize_ms = 20;

m_API_fs_Hz = 16000;

m_bitRate = 24000;

m_complexity = 2;

m_payloadEncode = new unsigned char[MAX_BYTES_PRE_FRAME *

MAX_INPUT_FRAME];

memset(m_payloadEncode, 0, MAX_BYTES_PRE_FRAME * MAX_INPUT_FRAME);

m_psEnc = NULL;

}

SilkEncoder::~SilkEncoder()

{

/*if(m_payloadEncode != NULL)

{

delete m_payloadEncode;

m_payloadEncode = NULL;

}*/

SAFE_DELETE_ELEMENT(m_payloadEncode);

/*if(m_psEnc != NULL)

{

delete m_psEnc;

m_psEnc = NULL;

}*/

SAFE_DELETE_ELEMENT(m_psEnc);

}

void SilkEncoder::SetEncoderParameter()

{

m__sampleRate = m_API_fs_Hz;

m_ernalSampleRate = m_API_fs_Hz;

m_Size =( m_packetSize_ms * m_API_fs_Hz ) / 1000;

m_LossPercentage = 0;

m_e = m_bitRate;

m_xity = m_complexity;

m_andFEC = 0;

m_ = 0;

}

void SilkEncoder::CreateEncoder()

{

int ret = SKP_Silk_SDK_Get_Encoder_Size(&m_enSizeBytesEncode);

if(ret)

{

//do sth;

}

m_psEnc = new char[m_enSizeBytesEncode];

}

void SilkEncoder::InitEncoder()

{

//320

int ret = SKP_Silk_SDK_InitEncoder(m_psEnc, &m_encStatus);

}

void SilkEncoder::StartEncoder(const SKP_int16* samplesIn, SKP_int counter , SKP_uint8**

samplesOutEnc, SKP_int16* bytesOutEnc)

{

m_nBytesEncode = MAX_BYTES_PRE_FRAME * MAX_INPUT_FRAME;

int ret = SKP_Silk_SDK_Encode((void* )m_psEnc, &m_encControl, samplesIn,

(SKP_int16)counter, m_payloadEncode, &m_nBytesEncode);

*samplesOutEnc = m_payloadEncode;

}

SilkDecoder::SilkDecoder()

{

m_samplesOutDecode = new SKP_int16[MAX_BYTES_PRE_FRAME *

*bytesOutEnc = m_nBytesEncode;

MAX_API_FS_KHZ];

memset(m_samplesOutDecode, 0, MAX_BYTES_PRE_FRAME * MAX_API_FS_KHZ);

m_nSamplesOutDecode = MAX_BYTES_PRE_FRAME * MAX_API_FS_KHZ;

}

m_packetSize_ms = 20;

m_API_sampleRate = 16000;

m_framesPerPacket = 1;

m_psDec = NULL;

SilkDecoder::~SilkDecoder()

{

}

void SilkDecoder::SetDecoderParameter()

{

m__sampleRate = m_API_sampleRate;

m_PerPacket = m_framesPerPacket;

/*if(m_samplesOutDecode != NULL)

{

delete m_samplesOutDecode;

m_samplesOutDecode = NULL;

}*/

SAFE_DELETE_ELEMENT(m_samplesOutDecode);

/*if(m_psDec != NULL)

{

delete m_psDec;

m_psDec = NULL;

}*/

SAFE_DELETE_ELEMENT(m_psDec);

m_ize = m_packetSize_ms * m_API_sampleRate / 1000;

}

void SilkDecoder::CreateDecoder()

{

int ret = SKP_Silk_SDK_Get_Encoder_Size(&m_enSizeBytesDecode);

if(ret)

{

}

//do sth;

m_psDec = new char[m_enSizeBytesDecode];

}

void SilkDecoder::InitDecoder()

{

}

void SilkDecoder::StartDecoder(SKP_uint8* inData,

samplesOutDec, SKP_int16* nSamplesOutDec)

{

SKP_int nBytesIn, SKP_int16**

int ret = SKP_Silk_SDK_InitDecoder(m_psDec);

// do sth;

m_nSamplesOutDecode = MAX_BYTES_PRE_FRAME * MAX_API_FS_KHZ;

int ret = SKP_Silk_SDK_Decode(m_psDec , &m_decControl, 0, inData, nBytesIn,

m_samplesOutDecode, &m_nSamplesOutDecode);

*samplesOutDec = m_samplesOutDecode;

*nSamplesOutDec = m_nSamplesOutDecode;

}