hxaudstr.cpp

linux下的一款播放器

        {
            m_Owner->UpdateStreamLastWriteTime();
            UpdateStreamLastWriteTime(TRUE);
        }
    }
//{FILE* f1 = ::fopen("c:\\temp\\audio.txt", "a+"); ::fprintf(f1, "%lu\tAddData\t%p\t%lu\n", HX_GET_BETTERTICKCOUNT(), this, pAudioData->ulAudioTime);::fclose(f1);}
//    ::fwrite(pAudioData->pData->GetBuffer(), pAudioData->pData->GetSize(), 1, fdin);

    UINT32 ulDataTime = CalcMs(pAudioData->pData->GetSize());
    UINT32 ulEndTime = pAudioData->ulAudioTime + ulDataTime;

    if (m_pAvailableBuffers && !m_bDeterminedInitialCacheSize && ulDataTime > 0)
    {
        m_bDeterminedInitialCacheSize = TRUE;
        m_uCacheSize = (UINT16) (m_ulGranularity*2/ulDataTime) + 1;
        /* make sure it is atleast CACHE_INCREMENT_SIZE to begin with */
        m_uCacheSize = m_uCacheSize < CACHE_INCREMENT_SIZE ? 
                            CACHE_INCREMENT_SIZE : m_uCacheSize;
    }

    if (m_ulLastInputStartTime > pAudioData->ulAudioTime &&
        ((m_ulLastInputStartTime - pAudioData->ulAudioTime) > MAX_TIMESTAMP_GAP))
    {
        bInTSRollOver = TRUE;
        m_ulTSRollOver++;
    }

    m_ulLastInputStartTime  = pAudioData->ulAudioTime;
    m_ulLastInputEndTime    = ulEndTime;

    /* even in STREAMING_AUDIO case, it might happen, that the packets
     * written are late. e.g. packets received late on the network 
     */
    INT64 llActualTimestamp = CAST_TO_INT64 (pAudioData->ulAudioTime) + CAST_TO_INT64 m_ulTSRollOver * CAST_TO_INT64 MAX_UINT32;
    INT64 llActualEndTime = CAST_TO_INT64 (pAudioData->ulAudioTime) + CAST_TO_INT64 (ulDataTime) +
                            CAST_TO_INT64 m_ulTSRollOver * CAST_TO_INT64 MAX_UINT32;

    if ((pAudioData->uAudioStreamType == STREAMING_AUDIO ||
         pAudioData->uAudioStreamType == TIMED_AUDIO) &&
       !(llActualTimestamp >= m_llLastWriteTime ||
         llActualEndTime > m_llLastWriteTime)) 
    {
        /* Too late*/
        m_bTobeTimed    = TRUE;
//{FILE* f1 = ::fopen("e:\\audio.txt", "a+"); ::fprintf(f1, "%lu\t%p\t%d\t%lu\t%lu\tLATE\n", HX_GET_BETTERTICKCOUNT(), this, m_pDataList->GetCount(), pAudioData->ulAudioTime, (INT32)m_llLastWriteTime);::fclose(f1);}
        return HXR_LATE_PACKET; 
    }

    pAinfo = new HXAudioInfo;
    if(!pAinfo)
    {
        theErr = HXR_OUTOFMEMORY;
        goto exit;
    }

    pAudioData->pData->AddRef();
    pAinfo->pBuffer             = pAudioData->pData;
    pAinfo->ulStartTime         = pAudioData->ulAudioTime;
    pAinfo->pOffset             = pAudioData->pData->GetBuffer();  
    pAinfo->ulBytesLeft         = pAudioData->pData->GetSize();  
    pAinfo->uAudioStreamType    = pAudioData->uAudioStreamType;

    if (m_bTobeTimed && pAudioData->uAudioStreamType == STREAMING_AUDIO)
    {
        pAinfo->uAudioStreamType = TIMED_AUDIO;
        m_bTobeTimed             = FALSE;
    }
    else if (m_bTobeTimed && pAudioData->uAudioStreamType == TIMED_AUDIO)
    {
        m_bTobeTimed    = FALSE;
    }

//{FILE* f1 = ::fopen("c:\\temp\\audio.txt", "a+"); ::fprintf(f1, "AddData ulAudioTime: %lu\n", pAudioData->ulAudioTime);::fclose(f1);}

    if (pAinfo->uAudioStreamType == INSTANTANEOUS_AUDIO)
    {
	CHXSimpleList* pList = new CHXSimpleList;
        if(!pList)
        {
            theErr = HXR_OUTOFMEMORY;
            goto exit;
        }
	pList->AddHead((void*) pAinfo);
	m_pInstantaneousList->AddTail((void*) pList);
	m_Owner->m_Owner->ToBeRewound();
    }
    else if (pAinfo->uAudioStreamType == STREAMING_INSTANTANEOUS_AUDIO)
    {
	HX_ASSERT(m_pInstantaneousList && m_pInstantaneousList->GetCount() > 0);
	CHXSimpleList* pList = NULL;
	if (m_pInstantaneousList->GetCount() == 0)
	{
	    pList = new CHXSimpleList;
            if(!pList)
            {
                theErr = HXR_OUTOFMEMORY;
                goto exit;
            }
	    m_pInstantaneousList->AddTail((void*) pList);

	    // fix for naive users!
	    pAinfo->uAudioStreamType = INSTANTANEOUS_AUDIO;
	    m_Owner->m_Owner->ToBeRewound();
	}

        pList = (CHXSimpleList*) m_pInstantaneousList->GetTail();
        pList->AddTail(pAinfo);
    }
    else if (m_pDataList->IsEmpty())
    {
        m_pDataList->AddTail((void*) pAinfo);
    }
    else
    {
        HXAudioInfo* pInfo = (HXAudioInfo*) m_pDataList->GetTail();

        UINT32  ulActualTSRollOver = m_ulTSRollOver;

        if (bInTSRollOver && ulActualTSRollOver)
        {
            ulActualTSRollOver--;
        }

        INT64 llActualLastEndTime = CAST_TO_INT64 (pInfo->ulStartTime) + CAST_TO_INT64 (CalcMs(pInfo->pBuffer->GetSize())) +
                                    CAST_TO_INT64 ulActualTSRollOver * CAST_TO_INT64 MAX_UINT32;
        INT64 llActualLastStartTime = CAST_TO_INT64 (pInfo->ulStartTime) + CAST_TO_INT64 ulActualTSRollOver * CAST_TO_INT64 MAX_UINT32;
        
        if (llActualTimestamp < llActualLastStartTime)
        {
            /* Not allowed */
            theErr = HXR_OUTOFORDER_PACKET; 
            /* something is fu*#$#up... figure out what?*/

            HX_ASSERT(!("Packets written out of order"));
            goto exit;
        }

        if (pAinfo->uAudioStreamType == STREAMING_AUDIO)
        {
            /* is it a resonable packet to add to the list */
            if ((llActualTimestamp <= llActualLastEndTime               &&
                 llActualLastEndTime - llActualTimestamp <= m_ulFudge)  || 
                (llActualTimestamp >= llActualLastEndTime               &&
                 llActualTimestamp - llActualLastEndTime <= m_ulFudge))
            {
                m_pDataList->AddTail((void*) pAinfo);
            }
            else
            {
                theErr = HXR_NONCONTIGUOUS_PACKET; //HX_LATE_PACKET;
                /* something is fu*#$#up... figure out what?*/
                HX_ASSERT(!("Streaming Audio: Non-Contigous Write"));
                m_bTobeTimed    = TRUE;
                goto exit;
            }
        }
        else
        {
            /* see if there is any overlap.. we do not allow any overlap */
            if (llActualTimestamp < llActualLastEndTime &&
                llActualLastEndTime - llActualTimestamp > m_ulFudge)
            {
                /* hmmm an overlapped packet */
                theErr = HXR_OVERLAPPED_PACKET;
                /* something is fu*#$#up... figure out what?*/
                HX_ASSERT(!("Timed Audio: Overlapping write"));
                m_bTobeTimed    = TRUE;
                goto exit;
            }
            else
            {
                m_pDataList->AddTail((void*) pAinfo);
            }
        }
    }

exit:
    if (theErr != HXR_OK && pAinfo)
    {
        pAinfo->pBuffer->Release();
        delete pAinfo;
    }

    /* Make sure to discard any data that is prior to cross-fade time */
    if (!theErr && m_bCrossFadingToBeDone && m_bFadeToThisStream)
    {
        RemoveExcessCrossFadeData();
    }

//{FILE* f1 = ::fopen("e:\\audio.txt", "a+"); ::fprintf(f1, "%lu\t%p\t%d\t%lu\t%lu\n", HX_GET_BETTERTICKCOUNT(), this, m_pDataList->GetCount(), pAudioData->ulAudioTime, (UINT32)m_llLastWriteTime);::fclose(f1);}
    
    return theErr;
}

HX_RESULT CHXAudioStream::ProcessInfo(void)
{
    HX_RESULT theErr = HXR_OK;

    // Calculate the number of bytes per granularity.
    m_ulInputBytesPerGran = (ULONG32) 
                (((m_AudioFmt.uChannels * ((m_AudioFmt.uBitsPerSample==8)?1:2) *  m_AudioFmt.ulSamplesPerSec) 
                                / 1000.0) * m_ulGranularity);

    m_ulOutputBytesPerGran  = (ULONG32) 
                (((m_DeviceFmt.uChannels * ((m_DeviceFmt.uBitsPerSample==8)?1:2) *  m_DeviceFmt.ulSamplesPerSec) 
                                / 1000.0) * m_ulGranularity);

    /* Number of samples required at output should be a multiple of 8 if 
     * sampling rate is 8K/16K/32K...or a multiple of 11 for 11K/22K...
     * This is needed since the resamplerequires works reliably ONLY if
     * this condition is true. Ken is working on this problem. This is 
     * an interim fix 
     */
    ULONG32 ulExtraGranularity = 1;
    if (m_DeviceFmt.ulSamplesPerSec % 8 == 0)
    {
        ulExtraGranularity = 8;
    }
    else
    {
        ulExtraGranularity = 11;
    }

    // Make sure that number of bytes per granularity is an even number.
    if (m_ulInputBytesPerGran % (2*m_AudioFmt.uChannels*ulExtraGranularity) != 0)
    {
        m_ulInputBytesPerGran -= m_ulInputBytesPerGran % (2*m_AudioFmt.uChannels*ulExtraGranularity);
    }

    if (m_ulOutputBytesPerGran % (2*m_DeviceFmt.uChannels*ulExtraGranularity) != 0)
    {
        m_ulOutputBytesPerGran -= m_ulOutputBytesPerGran % (2*m_DeviceFmt.uChannels*ulExtraGranularity);
    }


    if (!theErr)
    {
        // Setup the resampler
        theErr = SetupResampler();
    }

    if (!theErr)
    {
        m_bInited = TRUE;
        
        if (m_eState == E_STOPPED)
        {
            m_eState = E_INITIALIZED;
        } 
    }

    if (!theErr && m_bInited && m_bCrossFadingToBeDone && 
        m_bFadeToThisStream)
    {
        InitializeCrossFader();
    }

    /* Get the current player time to set the last write audio time 
     * If someone creates a stream mid presentation, we ask the player 
     * object for the current write time.
     */
    // set last write time to be the current playback time since
    // this is what other system components(i.e. renderers) based on 
    // fixed b#69847 - loss of push-down-worth of data =
    // m_Owner->GetLastAudioWriteTime() - m_Owner->GetCurrentPlayBackTime()
//    m_llLastWriteTime = m_Owner->GetCurrentPlayBackTime();

    // XXXRA: It is necessary to use last audio write time for any delayed
    // audio streams to work that do not involve any Pause/Rewind logic.
    // To cover the case where a source (and an audio stream) has been added
    // mid-playback by SMIL renderer which has a delay equivalent to the 
    // current playback time, it should result in a player rewind which should 
    // reset the lastaudiowrite time accordingly...so we should be able
    // to use m_Owner->GetLastAudioWriteTime() value in such a use case as well.
    // this change is required to fix PR 79161 and PR 69780.
    // Henry, PR 69847 (the reason for the earlier change) is still busted. 
    // so I am reverting this code to the original code. you will have 
    // to come up with a different fix for PR 69847 since this was clearly not 
    // the correct fix.
    m_llLastWriteTime = m_Owner->GetLastAudioWriteTime();

    if (!theErr && m_bInited)
    {
        m_Owner->StreamInitialized(this);
    }

    return theErr;
}


/************************************************************************
 *  Method:
 *              IHXAudioStream::SetupResampler
 *      Purpose:
 */
HX_RESULT CHXAudioStream::SetupResampler()
{
    HX_RESULT theErr = HXR_OK;

#if defined(HELIX_FEATURE_RESAMPLER)
    // Create a resampler for this stream if we need one.
    // Current resampler code resamples these sampling rates:
    // 8000,11025,16000,22050,32000,44100.  The resample also
    // converts 8-bit to 16-bit. NOTE: We convert all 8-bit samples
    // to 16-bit before input into the resampler or mixer.

    /* Resampler does the following tasks:
     * 1. Conversion for sampling rates
     * 2. Conversion from 8->16 and will also do 16->8 (XXX TBD)
     * 3. Conversion from stereo to mono

     * We do not use resampler for conversion from mono to stereo. This
     * takes place in the Mixer.
     */

/*
    fprintf(fdbeforetxt, "Samples: %lu, Channels: %lu, Bits/Sample: %lu\n",
         m_AudioFmt.ulSamplesPerSec, m_AudioFmt.uChannels, m_AudioFmt.uBitsPerSample);

    fprintf(fdaftertxt, "Samples: %lu, Channels: %lu, Bits/Sample: %lu\n",
         m_DeviceFmt.ulSamplesPerSec, m_DeviceFmt.uChannels, m_DeviceFmt.uBitsPerSample);
*/

    if ((m_AudioFmt.ulSamplesPerSec != m_DeviceFmt.ulSamplesPerSec) ||
        (m_AudioFmt.uBitsPerSample != m_DeviceFmt.uBitsPerSample)   ||
        (m_AudioFmt.uChannels == 2 && m_DeviceFmt.uChannels == 1))
    {
	m_AudioFmt.uMaxBlockSize = (UINT16) (m_ulInputBytesPerGran*1.5);

        if (HXR_OK == m_Owner->GetOwner()->CreateResampler(m_AudioFmt, 
                                                           m_DeviceFmt, 
                                                           m_pResampler))
        {                               
            /* times 2 since resampler always returns data in 16 bit.
             * times 2 if i/p or o/p is stereo
             * May change in future when we do 16->8 conversion in resampler
             */
            m_ulMaxBlockSize = (ULONG32) m_DeviceFmt.uMaxBlockSize * 2 * 2;

            /* This may be TRUE in downsampling */
            if (m_ulMaxBlockSize < (ULONG32) (m_ulInputBytesPerGran*1.5))
            {
                m_ulMaxBlockSize = (ULONG32) (m_ulInputBytesPerGran*1.5);
            }
        }
        else
        {
            HX_RELEASE(m_pResampler);
            theErr = HX_RESAMPLER_ERROR;
        }

        if ( !theErr )
        {
            m_pResampleBuf = (UCHAR*) new char [ m_ulMaxBlockSize ];
            m_pTmpResBuf = (UCHAR*) new char [ m_ulMaxBlockSize ];

            if (!m_pResampleBuf || !m_pTmpResBuf)
            {
                theErr = HXR_OUTOFMEMORY;
            }
        }

    }
    else
    {
        m_ulMaxBlockSize =  m_DeviceFmt.uMaxBlockSize;
    }

    /* Do not rely on max block size specified by the user */
    if (!theErr)
    {
        m_AudioFmt.uMaxBlockSize = (UINT16) m_ulMaxBlockSize;
    }

    m_bChannelConvert = (m_AudioFmt.uChannels == 1 && m_DeviceFmt.uChannels == 2);
#endif /* HELIX_FEATURE_RESAMPLER */

    // Create the resampler output buffer. Size it to the largest needed.
    return theErr;
}

/************************************************************************
 *  Method:
 *              IHXAudioStream::GetFormat
 *      Purpose:
 *      Return the stream's audio format.
 */
HX_RESULT CHXAudioStream::GetFormat
( 
    HXAudioFormat*      pAudioFormat
)
{
    if (!m_bAudioFormatKnown)
    {
        return HXR_NOT_INITIALIZED;
    }

    pAudioFormat->uChannels       = m_AudioFmt.uChannels;
    pAudioFormat->uBitsPerSample  = m_AudioFmt.uBitsPerSample;
    pAudioFormat->ulSamplesPerSec = m_AudioFmt.ulSamplesPerSec;
    pAudioFormat->uMaxBlockSize   = m_AudioFmt.uMaxBlockSize;

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *              IHXAudioStream::Setup
 *      Purpose:
 *              This is called by the player's Setup method. At this
 *              time the audio device format is set and we can now
 *              set up the streams pre-mixing buffer. This buffer
 *              contains data that has been resampled to match the
 *              audio device format.
 */