audiofile.cpp

转换音频Wav到PCM PCM -> G723 G729 Gsm iLBC G723 G729 Gsm iLBC -> PCM 需要p_voice库支持

// AudioFile.cpp: implementation of the CAudioFile class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AudioFile.h"

#include "AcmCodec.h"

// G.711 and G.721 
#include "p_voice\pcm\g72x.h"
static struct g72x_state g_g721;
static struct g72x_state g_g721_enc;

//#define GSM_MS_2FRAME

// GSM 6.10
struct gsm_state;
extern "C" gsm_state * gsm_create();
extern "C" void gsm_destroy(gsm_state *);
extern "C" void gsm_encode(gsm_state *, const short *, BYTE *);
extern "C" void gsm_decode(gsm_state *, const BYTE *, short *);
extern "C" void gsm_bits_ms2normal(const BYTE *, BYTE *, BYTE *);
extern "C" void gsm_bits_normal2ms(const BYTE *, const BYTE *, BYTE *);
static struct gsm_state * g_gsm;
static struct gsm_state * g_gsm_enc;

// G.729
extern "C" void g729cp_init_encoder(int iVad);
extern "C" void g729cp_encode_frame(short * pSamples, char * pBits);
extern "C" void g729cp_init_decoder();
extern "C" void g729cp_decode_frame(short * pSamples, char * pBits);

// G.723.1
extern "C" void g723f_init_codec(int iVad, int iBitRate);
extern "C" void g723f_encode_frame(short * pSamples, char * pBits);
extern "C" void g723f_decode_frame(short * pSamples, char * pBits);

// iLBC
extern "C" void ilbc_init_codec(int iMode);
extern "C" void ilbc_encode_frame(short * pSamples, char * pBits);
extern "C" void ilbc_decode_frame(short * pSamples, char * pBits);

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

IMPLEMENT_DYNAMIC(CAudioFile, CFile)

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAudioFile::CAudioFile() : CFile()
{
}

CAudioFile::~CAudioFile()
{
}

BOOL CAudioFile::Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError)
{
	return CFile::Open(lpszFileName, nOpenFlags, pError);
}

void CAudioFile::Close()
{
	CFile::Close();
	if (!m_bUseAcm)
	{
		if (m_iType == ACM_CODEC_GSM610)
		{
			FreeGSM();
		}
	}
}

UINT CAudioFile::Read(void* lpBuf, UINT nCount)
{
	int iSize;
	int iLength = GetLength();
	char * p = (char *)malloc(iLength);

	CFile::Read(p, iLength);

	if (m_bUseAcm)
	{
		CAcmCodec * m_pDec;
		m_pDec = new CAcmCodec;
		m_pDec->Init(m_iType, FALSE);
		iSize = m_pDec->Decode((char *)lpBuf, p, iLength);
		m_pDec->Free();
		delete m_pDec;
	}
	else
	{
		iSize = Decode((unsigned char *)p, (short *)lpBuf, iLength);
	}

	free(p);
	return iSize;
}

void CAudioFile::Write(const void* lpBuf, UINT nCount)
{
	int iSize;
	char * p = (char *)malloc(nCount);

	memset(p, 0, nCount);
	if (m_bUseAcm)
	{
		CAcmCodec * m_pEnc;
		m_pEnc = new CAcmCodec;
		m_pEnc->Init(m_iType, TRUE);
		iSize = m_pEnc->Encode((char *)lpBuf, p, nCount);
		m_pEnc->Free();
		delete m_pEnc;
	}
	else
	{
		iSize = Encode((short *)lpBuf, (unsigned char *)p, nCount/2);
	}
	CFile::Write(p, iSize);
	free(p);
}

int CAudioFile::Decode(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int iSize;
	switch (m_iType)
	{
	case ACM_CODEC_PASS:
		iSize = iCodeLength;
		break;

	case ACM_CODEC_ALAW:
		iSize = DecodeG711a(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_MULAW:	
		iSize = DecodeG711u(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_ADPCM:	
		iSize = DecodeG721(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_GSM610:
		iCodeLength -= iCodeLength % 36;
		iSize = DecodeGSM(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_G729CP:
		iCodeLength -= iCodeLength % 12;
		iSize = DecodeG729cp(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_G723_1:
		iCodeLength -= iCodeLength % 24;
		iSize = DecodeG723f(pCode, pSample, iCodeLength);
		break;

	case ACM_CODEC_ILBC:
		iCodeLength -= iCodeLength % 50;
		iSize = DecodeILBCf(pCode, pSample, iCodeLength);
		break;

	default:
		iSize = iCodeLength * 40;
		break;
	}
	return iSize;
}

int CAudioFile::Encode(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int iSize;
	switch (m_iType)
	{
	case ACM_CODEC_PASS:
		iSize = iSampleLength;
		break;

	case ACM_CODEC_ALAW:
		iSize = EncodeG711a(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_MULAW:	
		iSize = EncodeG711u(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_ADPCM:	
		iSize = EncodeG721(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_GSM610:
		iSampleLength -= iSampleLength % 320;
		iSize = EncodeGSM(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_G729CP:
		iSampleLength -= iSampleLength % 160;
		iSize = EncodeG729cp(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_G723_1:
		iSampleLength -= iSampleLength % 480;
		iSize = EncodeG723f(pSample, pCode, iSampleLength);
		break;

	case ACM_CODEC_ILBC:
		iSampleLength -= iSampleLength % 480;
		iSize = EncodeILBCf(pSample, pCode, iSampleLength);
		break;

	default:
		iSize = iSampleLength / 10;
		break;
	}
	return iSize;
}

int CAudioFile::EncodeG711a(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i;

	for (i = 0; i < iSampleLength; i ++)
	{
		pCode[i] = linear2alaw(pSample[i]);
	}
	return iSampleLength;
}

int CAudioFile::EncodeG711u(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i;

	for (i = 0; i < iSampleLength; i ++)
	{
		pCode[i] = linear2ulaw(pSample[i]);
	}
	return iSampleLength;
}

int CAudioFile::DecodeG711a(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i;

	for (i = 0; i < iCodeLength; i ++)
	{
		pSample[i] = alaw2linear(pCode[i]);
	}
	return iCodeLength * 2;
}

int CAudioFile::DecodeG711u(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i;

	for (i = 0; i < iCodeLength; i ++)
	{
		pSample[i] = ulaw2linear(pCode[i]);
	}
	return iCodeLength * 2;
}

void CAudioFile::InitG721()
{
	g72x_init_state(&g_g721);
	g72x_init_state(&g_g721_enc);
}

int CAudioFile::EncodeG721(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i, iVal1, iVal2;

	for (i = 0; i < iSampleLength; i += 2)
	{
		iVal1 = g721_encoder(pSample[i], AUDIO_ENCODING_LINEAR, &g_g721_enc);
		iVal2 = g721_encoder(pSample[i+1], AUDIO_ENCODING_LINEAR, &g_g721_enc);
		pCode[i/2] = (unsigned char)((iVal1<<4) + iVal2);
	}

	return iSampleLength/2;
}

int CAudioFile::DecodeG721(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i, iVal;

	for (i = 0; i < iCodeLength; i ++)
	{
		iVal = pCode[i];
		pSample[i*2] = (short)g721_decoder(((iVal>>4)&0x0f), AUDIO_ENCODING_LINEAR, &g_g721);
		pSample[i*2+1] = (short)g721_decoder((iVal&0x0f), AUDIO_ENCODING_LINEAR, &g_g721);
	}

	return iCodeLength * 4;
}

void CAudioFile::InitGSM()
{
	g_gsm = gsm_create();
	g_gsm_enc = gsm_create();
}

void CAudioFile::FreeGSM()
{
	gsm_destroy(g_gsm);
	gsm_destroy(g_gsm_enc);
}

int CAudioFile::DecodeGSM(unsigned char * pCode, short * pSample, int iCodeLength)
{
#ifdef GSM_MS_2FRAME
	int i, iSize = 0;
	unsigned char pCode1[36], pCode2[36];

	for (i = 0; i < iCodeLength; i += 65)
	{
		gsm_bits_ms2normal(pCode, pCode1, pCode2);
		gsm_decode(g_gsm, pCode1, pSample);
		pSample += 160;
		gsm_decode(g_gsm, pCode2, pSample);
		pSample += 160;
		pCode += 65;
		iSize += 640;
	}
	return iSize;
#else
	int i, iSize = 0;

	for (i = 0; i < iCodeLength; i += 36)
	{
		gsm_decode(g_gsm, pCode, pSample);
		pSample += 160;
		pCode += 36;
		iSize += 320;
	}
	return iSize;
#endif
}

int CAudioFile::EncodeGSM(short * pSample, unsigned char * pCode, int iSampleLength)
{
#ifdef GSM_MS_2FRAME
	int i, iSize = 0;
	unsigned char pCode1[36], pCode2[36];

	for (i = 0; i < iSampleLength; i += 320)
	{
		gsm_encode(g_gsm_enc, pSample, pCode1);
		pSample += 160;
		gsm_encode(g_gsm_enc, pSample, pCode2);
		pSample += 160;
		gsm_bits_normal2ms(pCode1, pCode2, pCode);
		pCode += 65;
		iSize += 65;
	}
	return iSize;
#else
	int i, iSize = 0;

	for (i = 0; i < iSampleLength; i += 160)
	{
		gsm_encode(g_gsm_enc, pSample, pCode);
		pSample += 160;
		pCode += 36;
		iSize += 36;
	}
	return iSize;
#endif
}

void CAudioFile::InitG729cp(BOOL bUseVAD)
{
	g729cp_init_encoder((int)bUseVAD);
	g729cp_init_decoder();
}

int CAudioFile::EncodeG729cp(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i, iSize = 0;

	for (i = 0; i < iSampleLength; i += 80)
	{
		g729cp_encode_frame(pSample, (char *)pCode);
		pSample += 80;
		pCode += 12;
		iSize += 12;
	}
	return iSize;
}

int CAudioFile::DecodeG729cp(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i, iSize = 0;

	for (i = 0; i < iCodeLength; i += 12)
	{
		g729cp_decode_frame(pSample, (char *)pCode);
		pSample += 80;
		pCode += 12;
		iSize += 160;
	}
	return iSize;
}

void CAudioFile::InitG723f(BOOL bUseVAD, BOOL bUseHighRate)
{
	g723f_init_codec((int)bUseVAD, (int)bUseHighRate);
}

int CAudioFile::EncodeG723f(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i, iSize = 0;

	for (i = 0; i < iSampleLength; i += 240)
	{
		g723f_encode_frame(pSample, (char *)pCode);
		pSample += 240;
		pCode += 24;
		iSize += 24;
	}
	return iSize;
}

int CAudioFile::DecodeG723f(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i, iSize = 0;

	for (i = 0; i < iCodeLength; i += 24)
	{
		g723f_decode_frame(pSample, (char *)pCode);
		pSample += 240;
		pCode += 24;
		iSize += 480;
	}
	return iSize;
}

void CAudioFile::InitILBCf()
{
	ilbc_init_codec(30);
}

int CAudioFile::EncodeILBCf(short * pSample, unsigned char * pCode, int iSampleLength)
{
	int i, iSize = 0;

	for (i = 0; i < iSampleLength; i += 240)
	{
		ilbc_encode_frame(pSample, (char *)pCode);
		pSample += 240;
		pCode += 50;
		iSize += 50;
	}
	return iSize;
}

int CAudioFile::DecodeILBCf(unsigned char * pCode, short * pSample, int iCodeLength)
{
	int i, iSize = 0;

	for (i = 0; i < iCodeLength; i += 50)
	{
		ilbc_decode_frame(pSample, (char *)pCode);
		pSample += 240;
		pCode += 50;
		iSize += 480;
	}
	return iSize;
}

int CAudioFile::SetOptions(int iType, BOOL bUseAcm, BOOL bUseVAD, BOOL bUseHighRate)
{
	int iSize, iLength = GetLength();

	m_iType = iType;
	m_bUseAcm = bUseAcm;
	switch (m_iType)
	{
	case ACM_CODEC_PASS:
		iSize = iLength;
		break;

	case ACM_CODEC_ALAW:
	case ACM_CODEC_MULAW:	
		iSize = iLength * 2;
		break;

	case ACM_CODEC_ADPCM:	
		iSize = iLength * 4;
		if (!m_bUseAcm)
		{
			InitG721();
		}
		break;

	case ACM_CODEC_GSM610:
		iSize = iLength * 10;
		if (!m_bUseAcm)
		{
			InitGSM();
		}
		break;

	case ACM_CODEC_G729CP:
		iSize = iLength * 15;
		if (!m_bUseAcm)
		{
			InitG729cp(bUseVAD);
		}
		break;

	case ACM_CODEC_G723_1:
		iSize = iLength * 25;
		if (!m_bUseAcm)
		{
			InitG723f(bUseVAD, bUseHighRate);
		}
		break;

	case ACM_CODEC_ILBC:
		iSize = iLength * 15;
		if (!m_bUseAcm)
		{
			InitILBCf();
		}
		break;

	default:
		iSize = iLength * 40;
		break;
	}
	return iSize;
}