wma.cpp

音频wma格式文件解码库

		ASSERT (0);
		info.SamplesPerSecond = 44100;
		break;
	}
	
	m_CallbackTable.info (WMA_MSG_MP3_DECODE_INFO, &info, m_CallbackTable.context);
	m_State = WMA_STATE_DECODE_DATA;
	return WMA_DECODER_ERROR_NO_ERROR;
}

WMA_DECODER_ERROR WMADecoder::DecodeFileJackson (RMint8 *filename,unsigned long int* totaltime)
{
	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"));
	*totaltime = m_sFileHeader.duration;
	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:
		ASSERT (0);
		info.SamplesPerSecond = 44100;
		break;
	}
	
	m_CallbackTable.info (WMA_MSG_MP3_DECODE_INFO, &info, m_CallbackTable.context);
	m_State = WMA_STATE_DECODE_DATA;
	return WMA_DECODER_ERROR_NO_ERROR;
}

WMA_DECODER_ERROR WMADecoder::Schedule ()
{
	tWMAFileStatus iResult;
	RMuint32 pcmlength;

	switch (m_State)
	{
	case WMA_STATE_FILE_DONE:
		DEBUGMSG (0, ("WMADecoder::Schedule (WMA_STATE_FILE_DONE)\n"));
		return WMA_DECODER_ERROR_FILE_DONE;
		break;
	case WMA_STATE_INIT:
		DEBUGMSG (0, ("WMADecoder::Schedule (WMA_STATE_INIT)\n"));
		break;
	case WMA_STATE_DECODE_DATA:
		DEBUGMSG (0, ("WMADecoder::Schedule (WMA_STATE_DECODE_DATA)\n"));
		ASSERT (m_pcmbuffer == 0);
		ASSERT (m_iSamples == 0);
#ifdef _WIN32
		iResult = WMAFileDecodeData (m_sState);
		m_iSampleCount = 1;
#else
		iResult = WMAFileDecodeData (m_sState, &m_iSampleCount);
#endif
		if (iResult != cWMA_NoErr)
		{		
			m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
			m_handle = 0;
			WMAFileDecodeClose (&m_sState);
			m_State = WMA_STATE_FILE_DONE;
			return WMA_DECODER_ERROR_FILE_DONE;
		}		
		if (m_iSampleCount)
			m_State = WMA_STATE_GET_PCM;
		
		break;
	case WMA_STATE_GET_PCM:
		DEBUGMSG (0, ("WMADecoder::Schedule (WMA_STATE_GET_PCM)\n"));
		ASSERT (m_pcmbuffer == 0);
		ASSERT (m_iSamples == 0);
		if (m_CallbackTable.getPCM (&m_pcmbuffer, &pcmlength, m_CallbackTable.context) == 0)
		{
			m_CallbackTable.addref (m_pcmbuffer, m_CallbackTable.context);
			ASSERT (m_iSamples == 0);
			m_iSamples = WMAFileGetPCM (m_sState, (tWMA_I16*)m_pcmbuffer, NULL, pcmlength/(m_sFileHeader.num_channels*sizeof(short)));
			DEBUGMSG (0, ("WMAFileGetPCM (%lu)\n", m_iSamples));
			if (m_iSamples == 0)
			{
				m_CallbackTable.release (m_pcmbuffer, m_CallbackTable.context);
				m_pcmbuffer = 0;
				m_iSamples = 0;
				m_State = WMA_STATE_DECODE_DATA;
			}
			else
			{
				wma_swapWord (m_pcmbuffer, m_iSamples * m_sFileHeader.num_channels * sizeof(short));
				m_State = WMA_STATE_PUT_PCM;
			}
		}
		break;
	case WMA_STATE_PUT_PCM:
		ASSERT (m_iSamples);		
		ASSERT (m_pcmbuffer);
		DEBUGMSG (0, ("putPCM (%lu)\n", m_iSamples * m_sFileHeader.num_channels * sizeof(short)));
		if (m_CallbackTable.putPCM (m_pcmbuffer, m_iSamples * m_sFileHeader.num_channels * sizeof(short), m_CallbackTable.context) == 0)
		{
			m_CallbackTable.release (m_pcmbuffer, m_CallbackTable.context);
			m_pcmbuffer = 0;
			m_iSamples = 0;
			m_State = WMA_STATE_GET_PCM;
		}
		break;
	default:
		ASSERT (0);
		break;
	}
	return WMA_DECODER_ERROR_NO_ERROR;
}

void WMADecoder::DecodeEndJackson (void)
{		
	if(m_handle != 0) {
		m_CallbackTable.fclose (m_handle, m_CallbackTable.context);
		m_handle = 0;
	}
	WMAFileDecodeClose (&m_sState);
	m_State = WMA_STATE_FILE_DONE;
}		

int WMADecoder::GetContJackson(unsigned char* ptitle,unsigned short int length1, unsigned char* pauthor, unsigned short int length2)
{
	tWMAFileContDesc desc;
	tWMAFileStatus ret;
	desc.pTitle = ptitle;
	desc.pAuthor = pauthor;
	desc.title_len = length1;
	desc.author_len = length2;
	ret = WMAFileContentDesc (m_sState, &desc);
	if (ret == cWMA_NoErr)
		return 0;
	return -1;
}

// for buffer streaming
WMA_DECODER_ERROR WMADecoder::DecodeBuffer (RMuint8 *pBuffer, RMuint32 length)
{
	DEBUGMSG (1, ("WMADecoder::DecodeBuffer ()\n"));
	return WMA_DECODER_ERROR_NOT_IMPLEMENTED;
}

// for wma library
RMuint32 WMADecoder::WMAFileCBGetData (tHWMAFileState state, RMuint32 offset, RMuint32 num_bytes, RMuint8 **ppData)
{
	tWMA_U32 iBytesRead;
	RMuint8 *pWMA;
	RMuint32 wmaLength;
	DEBUGMSG (0, ("WMADecoder::WMAFileCBGetData (%lu) @ %lu\n", num_bytes, offset));
	ASSERT (m_pWMA);
	ASSERT (num_bytes <= m_wmaLength);
	if (num_bytes > m_wmaLength)
	{
		DEBUGMSG (0, ("WMADecoder: WMAFileCBGetData requested too much (%lu bytes)\n", num_bytes));
		num_bytes = m_wmaLength;
    }		
	// is it already in the cache?	
	if ((offset >= m_wmaOffset) && 
		(offset < (m_wmaOffset + m_wmaValid)) && 
		((offset + num_bytes) < (m_wmaOffset + m_wmaValid)))
	{
		// yes
		pWMA = m_pWMA + (offset - m_wmaOffset);
		iBytesRead = num_bytes;
		DEBUGMSG (0, ("data cached (%lu) @ %lu\n", num_bytes, (offset - m_wmaOffset)));
	}
	else
	{
		// no - refill
		m_CallbackTable.fseek (m_handle, offset, m_CallbackTable.context);
		m_wmaOffset = offset;
		m_wmaValid = m_CallbackTable.fread (m_handle, m_pWMA, m_wmaLength, m_CallbackTable.context);
		DEBUGMSG (0, ("refill cache (%lu) @ %lu\n", m_wmaValid, offset));
		pWMA = m_pWMA;
		iBytesRead = num_bytes;
	}
	DEBUGMSG (0, ("pWma = 0x%08lx\n", (RMuint32)pWMA));
    *ppData = pWMA;
	ASSERT (iBytesRead <= sizeof (m_wmatmpbuf));
	// for data alignment - we should re-compile the wma library
	// so this copy is not necessary
	// check out LOADBYTE() etc. in asfparse/loadstuff.h 
	memcpy (m_wmatmp, pWMA, iBytesRead);
	*ppData = m_wmatmp;
    return iBytesRead;
}

#endif