wma.cpp

音频wma格式文件解码库

#include "wma.h"

#if 0
// to enable WMA playback you must get a license from microsoft
// after you have obtained a proper WMA license, contact Sigma Designs,
// for the WMA library 
WMADecoder::WMADecoder ()
{
}

WMADecoder::~WMADecoder ()
{
}

WMA_DECODER_ERROR WMADecoder::Init (void)
{
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}
WMA_DECODER_ERROR WMADecoder::InitCallbackTable (WMA_CALLBACK_TABLE *pCallbackTable)
{
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}
WMA_DECODER_ERROR WMADecoder::DecodeFile (RMint8 *filename)
{
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}
WMA_DECODER_ERROR WMADecoder::Schedule ()
{
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}
WMA_DECODER_ERROR WMADecoder::DecodeBuffer (RMuint8 *pBuffer, RMuint32 length)
{
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}
RMuint32 WMADecoder::WMAFileCBGetData (tHWMAFileState state, RMuint32 offset, RMuint32 num_bytes, RMuint8 **ppData)
{
	return 0;
}

#else

#if 0
static void debug_break (void)
{
}
#define ASSERT(exp)					((void)((exp)?1:(printf ("ASSERT failed: line %d, file %s\n", __LINE__,__FILE__), debug_break(), 0)))
#define DEBUGMSG(cond,printf_exp)	((void)((cond)?(printf printf_exp),1:0))
#else
#define ASSERT(exp)
#define DEBUGMSG(cond,printf_exp)
#endif	 

#define WMA_STATE_INIT			0
#define WMA_STATE_DECODE_DATA	1
#define WMA_STATE_GET_PCM		2
#define WMA_STATE_PUT_PCM		3
#define WMA_STATE_FILE_DONE		4

static WMADecoder *pWMADecoder = 0;

// misc functions needed by libwma
tWMA_U32 WMAFileCBGetData (tHWMAFileState state, tWMA_U32 offset, tWMA_U32 num_bytes, unsigned char **ppData)
{
	return pWMADecoder->WMAFileCBGetData (state, offset, num_bytes, ppData); 
}
tWMA_U32 WMAFileCBGetLicenseData (tHWMAFileState *state, tWMA_U32 offset, tWMA_U32 num_bytes, unsigned char **ppData) 
{
	// we don't support DRM
    return 0;
}
#include <stdarg.h>
void WMADebugMessage (const char* pszFmt, ...) 
{
	DEBUGMSG (1, ("WMADebugMessage ...\n"));
	va_list argList;
	va_start(argList, pszFmt);
	vprintf (pszFmt, argList);
	va_end (argList);
}
// end functions required by libwma

static inline void wma_swapWord (RMuint8 *buffer, const RMuint32 bufferLength) 
{
	RMuint16 temp;
	RMuint16 *s;
	RMuint32 i;
	s = (RMuint16 *)buffer;	
	ASSERT (((RMuint32)buffer & 1) == 0);
	for (i=0; i<bufferLength/2; i++)
	{
		temp = *s;						
		*s++ = (temp >> 8) | ((temp & 0xff) << 8);
	}
}

WMADecoder::WMADecoder ()
{	   
	DEBUGMSG (1, ("WMADecoder::WMADecoder\n"));
	m_CallbackTable.fclose = 0;
	m_wmaLength = 0;
	m_wmaOffset = 0;
	m_wmaValid = 0;
	m_pWMA = 0;
	// alignment
	m_wmatmp = (RMuint8 *)((RMuint32)(m_wmatmpbuf + 4) & 0xfffffffc);
	Init ();
	ASSERT (pWMADecoder == 0);
	pWMADecoder = this;
}

WMADecoder::~WMADecoder ()
{
	DEBUGMSG (1, ("WMADecoder::~WMADecoder\n"));
	if (m_pWMA)
	{
		ASSERT (m_CallbackTable.release);
		m_CallbackTable.release (m_pWMA, m_CallbackTable.context);
		m_pWMA = 0;
		m_wmaOffset = 0;
		m_wmaLength = 0;
		m_wmaValid = 0;
	}
	if (m_handle)
	{
		ASSERT (m_CallbackTable.fclose);
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
	}
	pWMADecoder = 0;
}

WMA_DECODER_ERROR WMADecoder::Init (void)
{
	DEBUGMSG (1, ("WMADecoder::Init\n"));
	if (m_handle)
	{
		if (m_CallbackTable.fclose)
			m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
	}
	m_handle = 0;
	m_CallbackTable.context = 0;
	m_CallbackTable.fopen = 0;
	m_CallbackTable.fread = 0;
	m_CallbackTable.fclose = 0;
	m_CallbackTable.addref = 0;
	m_CallbackTable.release = 0;
	m_CallbackTable.info = 0;
	m_CallbackTable.putPCM = 0;
	m_CallbackTable.getPCM = 0;
	m_CallbackTable.getWMA = 0;
	m_iSampleCount = 0;
	m_TotalBytesProcessed = 0;
	m_iSamples = 0;
	m_pcmbuffer = 0;
	m_wmaLength = 0;
	m_wmaOffset = 0;
	m_wmaValid = 0;
	m_pWMA = 0;
	m_State = WMA_STATE_INIT;
	return WMA_DECODER_ERROR_NO_ERROR;
}

WMA_DECODER_ERROR WMADecoder::InitCallbackTable (WMA_CALLBACK_TABLE *pCallbackTable)
{
	DEBUGMSG (1, ("WMADecoder::InitCallbackTable\n"));
	m_CallbackTable.context = pCallbackTable->context;
	m_CallbackTable.fopen = pCallbackTable->fopen;
	m_CallbackTable.fseek = pCallbackTable->fseek;
	m_CallbackTable.fread = pCallbackTable->fread;
	m_CallbackTable.fclose = pCallbackTable->fclose;
	m_CallbackTable.addref = pCallbackTable->addref;
	m_CallbackTable.release = pCallbackTable->release;
	m_CallbackTable.info = pCallbackTable->info;
	m_CallbackTable.putPCM = pCallbackTable->putPCM;
	m_CallbackTable.getPCM = pCallbackTable->getPCM;
	m_CallbackTable.getWMA = pCallbackTable->getWMA;
	return WMA_DECODER_ERROR_NO_ERROR;
}

// for file streaming
WMA_DECODER_ERROR WMADecoder::DecodeFile (RMint8 *filename)
{
	ASSERT (m_handle == 0);
	ASSERT (m_CallbackTable.fopen);
	ASSERT (m_State == WMA_STATE_INIT);

	DEBUGMSG (1, ("WMADecoder::DecodeFile (%s)\n", filename));

	RMuint32 r = m_CallbackTable.getWMA (&m_pWMA, &m_wmaLength, m_CallbackTable.context);
	ASSERT (m_pWMA);
	ASSERT (m_wmaLength);
	ASSERT (m_wmaValid == 0);
	ASSERT (m_wmaOffset == 0);
	ASSERT (r == 0);
	m_CallbackTable.addref (m_pWMA, m_CallbackTable.context);

	m_handle = m_CallbackTable.fopen (filename, m_CallbackTable.context);
	ASSERT (m_handle);
	if (m_handle == 0)
	{
		DEBUGMSG (1, ("fopen (%s) failed\n", filename));
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
	}
	if (WMAFileIsWMA (&m_sFileHeaderState) != cWMA_NoErr) 
	{
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
		DEBUGMSG (1, ("WMAFileIsWMA failed (%s)\n", filename));
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
	}

	m_sState = 0;

	// create wma decoder
    if (WMAFileDecodeCreate (&m_sState) != cWMA_NoErr) 
	{
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
        WMAFileDecodeClose (&m_sState);
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
    }	
#ifdef _WIN32
	if (WMAFileDecodeInit (m_sState) != cWMA_NoErr) 
#else
	if (WMAFileDecodeInit (m_sState, 0) != cWMA_NoErr) 
#endif
	{
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
        WMAFileDecodeClose (&m_sState);
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
    }
	if (WMAFileDecodeInfo (m_sState, &m_sFileHeader) != cWMA_NoErr)
	{
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
        WMAFileDecodeClose (&m_sState);
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
	}
    DEBUGMSG (1, ("- WMA version : %d\n", m_sFileHeader.version));
	DEBUGMSG (1, ("- Sample Rate : %ld\n", m_sFileHeader.sample_rate));
    DEBUGMSG (1, ("- Channels    : %d\n", m_sFileHeader.num_channels));
    DEBUGMSG (1, ("- Bit Rate    : %ld bps\n", m_sFileHeader.bitrate));
    DEBUGMSG (1, ("- Duration    : %ld ms\n", m_sFileHeader.duration));
    DEBUGMSG (1, ("- DRM         : %s\n", m_sFileHeader.has_DRM ? "Yes" : "No"));
	if (m_sFileHeader.has_DRM)
	{
		DEBUGMSG (1, ("DRM not supported\n"));
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
        WMAFileDecodeClose (&m_sState);
		return WMA_DECODER_ERROR_NOT_A_WMA_FILE;
	}
	WMA_DECODE_INFO info;
	info.NumberOfBitsPerSample = 16;
	info.NumberOfChannels = m_sFileHeader.num_channels;
	switch (m_sFileHeader.sample_rate)
	{
	case cWMA_SR_08kHz:
		info.SamplesPerSecond = 8000;
		break;
	case cWMA_SR_11_025kHz:
		info.SamplesPerSecond = 11025;
		break;
	case cWMA_SR_22_05kHz:
		info.SamplesPerSecond = 22050;
		break;
	case cWMA_SR_16kHz:
		info.SamplesPerSecond = 16000;
		break;
	case cWMA_SR_32kHz:
		info.SamplesPerSecond = 32000;
		break;
	case cWMA_SR_44_1kHz:
		info.SamplesPerSecond = 44100;
		break;
	case cWMA_SR_48kHz:
		info.SamplesPerSecond = 48000;
		break;
	default: