audrendf.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

	m_pCommonClassFactory = pCommonClassFactory;
	m_pCommonClassFactory->AddRef();
    }
}

void CAudioFormat::SetCompressionRation(double fCompressionRatio)
{
    HX_ASSERT(fCompressionRatio > 0.0);
    
    if (fCompressionRatio > 0.0)
    {
	m_fCompressionRatio = fCompressionRatio;
    }
}


UINT32 CAudioFormat::ConvertMsToBytes(UINT32 ulMs)
{
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulMs) * 
		    ((double) m_pAudioFmt->uChannels) * 
		    ((double) m_pAudioFmt->uBitsPerSample) *
		    ((double) m_pAudioFmt->ulSamplesPerSec) / 
		    8000.0 + 
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND
    UINT32 ulBitsPerSecond = ((UINT32) m_pAudioFmt->uChannels) * 
			     ((UINT32) m_pAudioFmt->uBitsPerSample) *
			     ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    HX_ASSERT(ulMs < (((ULONG32) 0xFFFFF05F) / ulBitsPerSecond));

    return (ulMs * ulBitsPerSecond + 4000) / 8000;
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertBytesToMs(UINT32 ulBytes)
{    	
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulBytes) * 
		    8000.0 /
		    (((double) m_pAudioFmt->uChannels) * 
		     ((double) m_pAudioFmt->uBitsPerSample) *
		     ((double) m_pAudioFmt->ulSamplesPerSec)) + 
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND
    UINT32 ulBitsPerSecond = ((UINT32) m_pAudioFmt->uChannels) * 
			     ((UINT32) m_pAudioFmt->uBitsPerSample) *
			     ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    HX_ASSERT(ulBytes < 536871);

    return ((ulBytes * 8000) / ulBitsPerSecond + 
	    ((ulBytes * 8000) % ulBitsPerSecond + (ulBitsPerSecond >> 1)) / ulBitsPerSecond);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertMsToSamples(UINT32 ulMs)
{
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulMs) /
		    1000.0 *
		    ((double) m_pAudioFmt->uChannels) *
		    ((double) m_pAudioFmt->ulSamplesPerSec) +
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulCombinedSamplesPerSecond = ((UINT32) m_pAudioFmt->uChannels) *
				        ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    return ((ulMs / 1000) * ulCombinedSamplesPerSecond +
	    ((ulMs % 1000) * ulCombinedSamplesPerSecond + 500) / 1000);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertSamplesToMs(UINT32 ulSamples)
{
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulSamples) /
		    (((double) m_pAudioFmt->uChannels) *
		     ((double) m_pAudioFmt->ulSamplesPerSec)) *
		    1000.0 + 
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulCombinedSamplesPerSecond = ((UINT32) m_pAudioFmt->uChannels) *
				        ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    return ((ulSamples / ulCombinedSamplesPerSecond) * 1000 +
	    ((ulSamples % ulCombinedSamplesPerSecond) * 1000 + 500) / ulCombinedSamplesPerSecond);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertBytesToSamples(UINT32 ulBytes)
{
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulBytes) *
		    8.0 /
		    ((double) m_pAudioFmt->uBitsPerSample) +
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulBitsPerSample = ((UINT32) m_pAudioFmt->uBitsPerSample);

    return (((ulBytes / ulBitsPerSample) << 3) +
	    (((ulBytes % ulBitsPerSample) << 3) + (ulBitsPerSample >> 1)) / ulBitsPerSample);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertSamplesToBytes(UINT32 ulSamples)
{    	
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulSamples) *
		    ((double) m_pAudioFmt->uBitsPerSample) /
		    8.0 + 
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulBitsPerSample = ((UINT32) m_pAudioFmt->uBitsPerSample);

    return ((ulSamples / 8) * ulBitsPerSample +
	    ((ulSamples % 8) * ulBitsPerSample + 4) / 8);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertCompressedBytesToMs(UINT32 ulBytes)
{
    return (UINT32)(((double) ulBytes) * 
		    8000.0 /
		    ((double) m_pAudioFmt->uChannels) * 
		    ((double) m_pAudioFmt->uBitsPerSample) *
		    ((double) m_pAudioFmt->ulSamplesPerSec) *
		    m_fCompressionRatio +
		    0.5);
}

UINT32 CAudioFormat::ConvertMsToCompressedBytes(UINT32 ulMs)
{
    return (UINT32)(((double) ulMs) * 
		    ((double) m_pAudioFmt->uChannels) * 
		    ((double) m_pAudioFmt->uBitsPerSample) *
		    ((double) m_pAudioFmt->ulSamplesPerSec) / 
		    8000.0 /
		    m_fCompressionRatio + 
		    0.5);
}

UINT32 CAudioFormat::ConvertMsToTime(UINT32 ulMs)
{
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulMs) /
		    1000.0 *
		    ((double) m_pAudioFmt->ulSamplesPerSec) +
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulSamplesPerSec = ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    return ((ulMs / 1000) * ulSamplesPerSec +
	    ((ulMs % 1000) * ulSamplesPerSec + 500) / 1000);
#endif	// HELIX_FEATURE_FLP_AUDREND
}

UINT32 CAudioFormat::ConvertTimeToMs(UINT32 ulTime)
{   
#ifdef HELIX_FEATURE_FLP_AUDREND
    return (UINT32)(((double) ulTime) /
		    ((double) m_pAudioFmt->ulSamplesPerSec) *
		    1000.0 + 
		    0.5);
#else	// HELIX_FEATURE_FLP_AUDREND

    UINT32 ulSamplesPerSec = ((UINT32) m_pAudioFmt->ulSamplesPerSec);

    return ((ulTime / ulSamplesPerSec) * 1000 +
	    ((ulTime % ulSamplesPerSec) * 1000 + (ulSamplesPerSec >> 1)) / ulSamplesPerSec);
#endif	// HELIX_FEATURE_FLP_AUDREND
}


BOOL CAudioFormat::ClipAudioBuffer(HXAudioData* pAudioData, 
				     UINT32 ulAudioTime, 
				     BOOL bFromStart)
{
    BOOL	bResult = FALSE;
    UINT32	ulDuration = 0;
    UINT32	ulSize = 0;
    UINT32	ulExtraInMs = 0;
    UINT32	ulExtraInBytes = 0;
    IHXBuffer* pBuffer = NULL;

    HX_ASSERT(pAudioData);
    HX_ASSERT(pAudioData->pData);

    ulSize = (pAudioData->pData)->GetSize();

    // caculate the worth of this data in ms
    ulDuration = ConvertBytesToMs(ulSize);
    
    // trim off any extra bytes
    if (bFromStart)
    {
	HX_ASSERT(IsTimeLess(pAudioData->ulAudioTime, ulAudioTime));

	if (IsTimeGreater(pAudioData->ulAudioTime + ulDuration, ulAudioTime))
	{	 	    
	    // trim off partial data
	    ulExtraInMs = ulAudioTime - pAudioData->ulAudioTime;

	    // convert to bytes
	    ulExtraInBytes = ConvertMsToBytes(ulExtraInMs);

	    // align in sample boundary
	    ulExtraInBytes -= (ulExtraInBytes % (m_pAudioFmt->uBitsPerSample * 
			       m_pAudioFmt->uChannels / 8));

	    m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, 
		(void**) &pBuffer);

	    if (pBuffer)
	    {
		if (pBuffer->Set((pAudioData->pData)->GetBuffer() + ulExtraInBytes, 
				  ulSize - ulExtraInBytes)
		    == HXR_OK)
		{
		    pAudioData->pData->Release();

		    pAudioData->pData = pBuffer;	 	 
		    pAudioData->ulAudioTime = ulAudioTime;

		    bResult = TRUE;
		}
		else
		{
		    pBuffer->Release();
		}
	    }
	}
    }
    else
    {
	HX_ASSERT(IsTimeGreater(pAudioData->ulAudioTime + ulDuration, ulAudioTime));

	if (IsTimeLess(pAudioData->ulAudioTime, ulAudioTime))
	{
	    // trim off the extra ones
	    ulExtraInMs = pAudioData->ulAudioTime + ulDuration - ulAudioTime;

	    // convert to bytes
	    ulExtraInBytes = ConvertMsToBytes(ulExtraInMs);

	    // align in sample boundary
	    ulExtraInBytes -= (ulExtraInBytes % (m_pAudioFmt->uBitsPerSample * 
			       m_pAudioFmt->uChannels / 8));

	    m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, 
		(void**) &pBuffer);

	    if (pBuffer)
	    {
		if (pBuffer->Set((pAudioData->pData)->GetBuffer(), 
				 ulSize - ulExtraInBytes)
		    == HXR_OK)
		{
		    pAudioData->pData->Release();

		    pAudioData->pData = pBuffer;

		    bResult = TRUE;
		}
		else
		{
		    pAudioData->pData;
		}
	    }   
	}
    }

    return bResult;
}


inline BOOL CAudioFormat::AdjustAudioData(REF(HXAudioData) audioData)
{
    BOOL	bResult = TRUE;
    UINT32	ulDuration = 0;
    UINT32	ulSize = 0;
    UINT32	ulExtraInMs = 0;
    UINT32	ulExtraInBytes = 0;
    IHXBuffer* pBuffer = NULL;

    if (((!m_bPostStartTime) && (m_ulTrackStartTime != NO_TIME_SET)) || 
	(m_ulTrackEndTime != NO_TIME_SET) ||
	(m_ulForceDiscardUntilTime != NO_TIME_SET))
    {
	ulSize = (audioData.pData)->GetSize();

	// caculate the worth of this data in ms
	ulDuration = ConvertBytesToMs(ulSize);
	
	// trim off any extra bytes
	if (((!m_bPostStartTime) &&
	     (m_ulTrackStartTime != NO_TIME_SET) && 
	     IsTimeLess(audioData.ulAudioTime, m_ulTrackStartTime)) ||
	    ((m_ulForceDiscardUntilTime != NO_TIME_SET) && 
	     IsTimeLess(audioData.ulAudioTime, m_ulForceDiscardUntilTime)))
	{
	    UINT32 ulStartTimeToUse = m_ulTrackStartTime;
	    
	    if (m_bPostStartTime ||
		(ulStartTimeToUse == NO_TIME_SET) ||
		IsTimeLess(m_ulTrackStartTime, m_ulForceDiscardUntilTime))
	    {
		ulStartTimeToUse = m_ulForceDiscardUntilTime;
	    }

	    bResult = ClipAudioBuffer(&audioData,
				      ulStartTimeToUse,
				      TRUE);
	}

	if ((m_ulTrackEndTime != NO_TIME_SET) &&
	    bResult &&
	    IsTimeGreater((audioData.ulAudioTime + ulDuration), m_ulTrackEndTime))
	{
	    bResult = ClipAudioBuffer(&audioData,
				      m_ulTrackEndTime,
				      FALSE);
	}
    }

    return bResult;
}


// *** IUnknown methods ***
/****************************************************************************
*  IUnknown::QueryInterface                                    ref:  hxcom.h
*
*  This routine indicates which interfaces this object supports. If a given
*  interface is supported, the object's reference count is incremented, and
*  a reference to that interface is returned. Otherwise a NULL object and
*  error code are returned. This method is called by other objects to
*  discover the functionality of this object.
*/
STDMETHODIMP CAudioFormat::QueryInterface(REFIID riid, void** ppvObj)
{
    if (IsEqualIID(riid, IID_IUnknown))
    {
	AddRef();
	*ppvObj = (IUnknown*) this;
	return HXR_OK;
    }
    
    *ppvObj = NULL;
    return HXR_NOINTERFACE;
}

/****************************************************************************
*  IUnknown::AddRef                                            ref:  hxcom.h
*
*  This routine increases the object reference count in a thread safe
*  manner. The reference count is used to manage the lifetime of an object.
*  This method must be explicitly called by the user whenever a new
*  reference to an object is used.
*/
STDMETHODIMP_(ULONG32) CAudioFormat::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

/****************************************************************************
*  IUnknown::Release                                           ref:  hxcom.h
*
*  This routine decreases the object reference count in a thread safe
*  manner, and deletes the object if no more references to it exist. It must
*  be called explicitly by the user whenever an object is no longer needed.
*/
STDMETHODIMP_(ULONG32) CAudioFormat::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }
    
    delete this;
    return 0;
}

UINT32 CAudioFormat::GetULONG32Property(IHXValues*  pValues,
                                        const char* pszName,
                                        UINT32      ulDefault)
{
    UINT32 ulRet = ulDefault;

    if (pValues && pszName)
    {
        pValues->GetPropertyULONG32(pszName, ulRet);
    }

    return ulRet;
}