rtsptran.cpp

linux下的一款播放器

	if (!pStreamData->m_pTSOrderHack)
	{
	    pStreamData->m_pTSOrderHack = new RTSPStreamData::TSOrderHackInfo();
	    
	    if (pStreamData->m_pTSOrderHack)
	    {
		pStreamData->m_pTSOrderHack->m_ulLastSentTS = 
		    pPacket->GetTime();
		pStreamData->m_pTSOrderHack->m_ulLastRecvTS = 
		    pStreamData->m_pTSOrderHack->m_ulLastSentTS;
	    }
	}

	if (pStreamData->m_pTSOrderHack)
	{
	    IHXBuffer* pBuf=NULL;	    
	    UINT32 ulHX;
	    UINT32 ulRTP;
	    UINT16 unStrmNo;
	    UINT8  uchASMFlag;
	    UINT16 unRuleNo;

	    // pkts've been sorted based on seq_no
	    IHXRTPPacket* pRTPPacket = NULL;

	    pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);

	    if (pRTPPacket)
	    {
		// RTP transport generates RTP packets
		result = pRTPPacket->GetRTP(pBuf, ulHX, ulRTP, 
					    unStrmNo, uchASMFlag, unRuleNo);
	    }
	    else
	    {
		// RDT transport generates RMA packets
		result = pPacket->Get(pBuf, ulHX,
				      unStrmNo, uchASMFlag, unRuleNo);

		if (pStreamData->m_pTSConverter)
		{
		    ulRTP = pStreamData->m_pTSConverter->hxa2rtp(ulHX);
		}
		else
		{
		    ulRTP = ulHX;
		}
	    }

	    HX_ASSERT(result == HXR_OK);

	    if (result == HXR_OK)
	    {
		if (((LONG32) (ulHX - pStreamData->m_pTSOrderHack->m_ulLastSentTS)) > 0)
		{
		    pStreamData->m_pTSOrderHack->m_ulLastSentTS = ulHX;
		    pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
		}
		else if (ulHX == pStreamData->m_pTSOrderHack->m_ulLastRecvTS)
		{
		    ulHX = pStreamData->m_pTSOrderHack->m_ulLastSentTS;	    	    
		}
		else
		{
		    pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
		    ulHX = (++pStreamData->m_pTSOrderHack->m_ulLastSentTS);
		}
		
		HX_RELEASE(pRTPPacket);
		HX_RELEASE(pPacket);
		pRTPPacket = new CHXRTPPacket;
		pRTPPacket->AddRef();
		result = pRTPPacket->SetRTP(pBuf,
					    ulHX,
					    ulRTP,
					    unStrmNo,
					    uchASMFlag,
					    unRuleNo);
		HX_ASSERT(result == HXR_OK);		
		pRTPPacket->QueryInterface(IID_IHXPacket, (void**) &pPacket);
		HX_ASSERT(pPacket);
	    }
	    HX_RELEASE(pBuf);

	    HX_RELEASE(pRTPPacket);
	}
    }

    /*
     * No longer need the ClientPacket wrapper
     */
    HX_RELEASE(clientPacket);    

    return HXR_OK;
}

HX_RESULT
RTSPTransport::startPackets(UINT16 uStreamNumber)
{
    RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);

    if (!pTransportBuffer)
    {
	return HXR_FAIL;
    }

    return pTransportBuffer->StartPackets();
}

HX_RESULT
RTSPTransport::stopPackets(UINT16 uStreamNumber)
{
    RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);

    if (!pTransportBuffer)
    {
	return HXR_FAIL;
    }

    return pTransportBuffer->StopPackets();
}

void
RTSPTransport::SetFilterResponse(RawPacketFilter* pResp)
{
    HX_RELEASE(m_pPacketFilter);
    m_pPacketFilter = pResp;
    if (m_pPacketFilter)
    {
	m_pPacketFilter->AddRef();
    }
}

void
RTSPTransport::FilterPacket(IHXPacket* pPacket)
{
    UINT16 uStreamNumber;

    ClientPacket* clientPacket = 0;
    clientPacket = (ClientPacket*)m_pClientPacketList->RemoveTail();
    clientPacket->SetPacket(pPacket);
    
    uStreamNumber = clientPacket->GetStreamNumber();
    RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
    pTransportBuffer->Add(clientPacket);
}

void RTSPTransport::GetContext(IUnknown*& pContext)   
{   
	pContext = m_pContext;   

	if (pContext)   
	{   
		pContext->AddRef();   
	}   
} 

void 
RTSPTransport::LeavePrefetch(void)
{
    RTSPStreamData* pStreamData = NULL; 
    
    m_bPrefetch = FALSE;

    HX_ASSERT(m_pStreamHandler);

    pStreamData = m_pStreamHandler->firstStreamData();
    while(pStreamData)    
    {
	if (pStreamData->m_pTransportBuffer)
	{
	    pStreamData->m_pTransportBuffer->LeavePrefetch();
	}
	pStreamData = m_pStreamHandler->nextStreamData();
    }

    return;
}

void 
RTSPTransport::EnterFastStart(void)
{
    RTSPStreamData* pStreamData = NULL; 
    
    m_bFastStart = TRUE;

    HX_ASSERT(m_pStreamHandler);

    pStreamData = m_pStreamHandler->firstStreamData();
    while(pStreamData)    
    {
	if (pStreamData->m_pTransportBuffer)
	{
	    pStreamData->m_pTransportBuffer->EnterFastStart();
	}
	pStreamData = m_pStreamHandler->nextStreamData();
    }

    return;
}

void 
RTSPTransport::LeaveFastStart(void)
{
    RTSPStreamData* pStreamData = NULL; 
    
    m_bFastStart = FALSE;

    HX_ASSERT(m_pStreamHandler);

    pStreamData = m_pStreamHandler->firstStreamData();
    while(pStreamData)    
    {
	if (pStreamData->m_pTransportBuffer)
	{
	    pStreamData->m_pTransportBuffer->LeaveFastStart();
	}
	pStreamData = m_pStreamHandler->nextStreamData();
    }

    return;
}

BOOL 
RTSPTransport::isSparseStream(UINT16 uStreamNumber)
{
    BOOL		bResult = FALSE;
    const char*		pMimeType = NULL;
    IUnknown*		pUnknown = NULL;
    IHXStreamSource*	pStreamSource = NULL;    
    IHXStream*		pStream = NULL;

    if (m_pContext  &&
	HXR_OK == m_pContext->QueryInterface(IID_IHXStreamSource, (void**)&pStreamSource))
    {
	if (HXR_OK == pStreamSource->GetStream(uStreamNumber, pUnknown))
	{
	    if (HXR_OK == pUnknown->QueryInterface(IID_IHXStream, (void**)&pStream))
	    {
		pMimeType = pStream->GetStreamType();

		// special handling for sparsed streams for multicast
		if (pMimeType							&&
		    (strcasecmp(SYNCMM_MIME_TYPE, pMimeType) == 0		||
		     strcasecmp(REALEVENT_MIME_TYPE, pMimeType) == 0		||
		     strcasecmp("application/vnd.rn-realtext", pMimeType) == 0	||
		     strcasecmp("application/x-pn-realtext", pMimeType) == 0))
		{
		    bResult = TRUE;
		}
	    }
	    HX_RELEASE(pStream);
	}
	HX_RELEASE(pUnknown);
    }
    HX_RELEASE(pStreamSource);

    return bResult;
}

HX_RESULT
RTSPTransport::storePacket(IHXPacket* pPacket,
                           UINT16 uStreamNumber,
                           UINT16 uSeqNo,
                           UINT16 uReliableSeqNo,
                           BOOL isReliable)
{
    RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);

    if (!pTransportBuffer)
    {
	return HXR_FAIL;
    }

    ClientPacket* clientPacket = 0;
    
    m_bIsReceivedData = TRUE;

    if (pPacket->IsLost())
    {
        clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
		                        pPacket->GetTime(), 0, isReliable,
		                        0, pTransportBuffer->GetTime(), FALSE);

	clientPacket->AddRef();

	return pTransportBuffer->Add(clientPacket);
    }
    
    IHXBuffer* pBuffer = pPacket->GetBuffer();

    if (m_pPacketFilter)
    {
	if (!m_pClientPacketList)
	{
	    m_pClientPacketList = new CHXSimpleList;
	    m_pPacketFilter->SetFilterResponse(this);
	}
	clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
		pPacket->GetTime(), pBuffer->GetSize(), isReliable,
		NULL, pTransportBuffer->GetTime(),
		FALSE);
	
	clientPacket->AddRef();
	pBuffer->Release();

	m_pClientPacketList->AddHead((void*)clientPacket);
	m_pPacketFilter->FilterPacket(pPacket);

	// just guessing on what this should be?????
        return HXR_OK;
    }
    else
    {
       clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
		pPacket->GetTime(), pBuffer->GetSize(), isReliable,
		pPacket, pTransportBuffer->GetTime(), FALSE);

	clientPacket->AddRef();
	pBuffer->Release();

	return pTransportBuffer->Add(clientPacket);
    }
}

HX_RESULT			
RTSPTransport::packetReady(HX_RESULT status, RTSPStreamData* pStreamData, IHXPacket* pPacket)
{
    HX_RESULT result = HXR_OK;

    ASSERT(!m_bIsSource);

    if (!pStreamData)
    {
	return HXR_UNEXPECTED;
    }

    HX_ASSERT(pStreamData);
    
    if (pPacket)
    {
	if (pStreamData->m_bUsesRTPPackets)
	{
	    IHXRTPPacket* pRTPPacket = NULL;

	    pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);

	    if (pRTPPacket)
	    {
		// This already is RTP Packet - proceed
		pRTPPacket->Release();
	    }
	    else
	    {
		// Must Transfer to an RTP Packet
		result = m_pCommonClassFactory->CreateInstance(
				CLSID_IHXRTPPacket,
				(void**) &pRTPPacket);

		if (pRTPPacket)
		{
		    ULONG32 ulTime;
		    ULONG32 ulRTPTime;
		    UINT16 uStreamNumber;
		    UINT8 unASMFlags;
		    UINT16 unASMRuleNumber;
		    BOOL bIsLost = pPacket->IsLost();
		    IHXBuffer* pBuffer = NULL;

		    pPacket->Get(pBuffer,
				 ulTime,
				 uStreamNumber,
				 unASMFlags,
				 unASMRuleNumber);

		    if (pStreamData->m_pTSConverter)
		    {
			ulRTPTime = pStreamData->m_pTSConverter->hxa2rtp(ulTime);
		    }
		    else
		    {
			ulRTPTime = ulTime;
		    }

		    pRTPPacket->SetRTP(pBuffer,
				       ulTime,
				       ulRTPTime,
				       uStreamNumber,
				       unASMFlags,
				       unASMRuleNumber);

		    if (bIsLost)
		    {
			pRTPPacket->SetAsLost();
		    }

		    HX_RELEASE(pBuffer);

		    result = m_pResp->PacketReady(status, m_sessionID, pRTPPacket);
		    pRTPPacket->Release();
		}

		return result;
	    }
	}
    }
    else
    {
	/*
	 * This is a lost packet
	 */
	if (pStreamData->m_bUsesRTPPackets)
	{
	    result = m_pCommonClassFactory->CreateInstance(
			CLSID_IHXRTPPacket,
			(void**) &pPacket);
	}
	else
	{
	    result = m_pCommonClassFactory->CreateInstance(
			CLSID_IHXPacket,
			(void**) &pPacket);
	}
	    
	if (pPacket)
	{
	    pPacket->Set(0, 0, pStreamData->m_streamNumber, 0, 0);
	    pPacket->SetAsLost();
	    result = m_pResp->PacketReady(status, m_sessionID, pPacket);
	    pPacket->Release();
	}
	return result;
    }

    return m_pResp->PacketReady(status, m_sessionID, pPacket);
}

HX_RESULT
RTSPTransport::packetReady(HX_RESULT status, UINT16 uStreamNumber, IHXPacket* pPacket)
{
    RTSPStreamData* pStreamData = NULL;

    ASSERT(!m_bIsSource);

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);

    HX_ASSERT(pStreamData);

    return packetReady(status, pStreamData, pPacket);
}

HX_RESULT
RTSPTransport::getStatus
(
    UINT16& uStatusCode, 
    IHXBuffer*& pStatusDesc, 
    UINT16& ulPercentDone
)
{
#if 0
    if (!m_pStreamHandler)
    {
	uStatusCode = HX_STATUS_INITIALIZING;
	pStatusDesc = 0;
	ulPercentDone = 0;

	return HXR_OK;
    }

    uStatusCode = HX_STATUS_READY;
    pStatusDesc = 0;
    ulPercentDone = 100;

    RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

    ASSERT(pStreamData);

    while(pStreamData)
    {
	UINT16 tempStatusCode;
	UINT16 tempPercentDone;

	pStreamData->m_pTransportBuffer->GetStatus(tempStatusCode,
	                                           tempPercentDone);

	/*
	 * The status is always that of the stream which is least ready
	 */

	if (tempStatusCode < uStatusCode)
	{
	    uStatusCode	    = tempStatusCode;
	    ulPercentDone   = tempPercentDone;
	}
	else if (tempStatusCode == uStatusCode && 
		 tempPercentDone < ulPercentDone)
	{
	    ulPercentDone = tempPercentDone;
	}

	pStreamData = m_pStreamHandler->nextStreamData();
    }

    return HXR_OK;
#else
    return HXR_NOTIMPL;
#endif
}

HX_RESULT
RTSPTransport::GetCurrentBuffering(UINT16  uStreamNumber,
				   INT64&  llLowestTimestamp, 
				   INT64&  llHighestTimestamp,
				   UINT32& ulNumBytes,
				   BOOL&   bDone)
{
    if (!m_pStreamHandler)
    {
	return HXR_OK;
    }

    RTSPStreamData* pStreamData;

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);

    HX_ASSERT(pStreamData);

    return pStreamData ? 
           pStreamData->m_pTransportBuffer->GetCurrentBuffering(
                                            llLowestTimestamp,
                                            llHighestTimestamp,
                                            ulNumBytes,
                                            bDone) : HXR_OK;
}

HX_RESULT
RTSPTransport::SeekFlush(UINT16 uStreamNumber)
{
    if (!m_pStreamHandler)
    {
	return HXR_OK;
    }

    RTSPStreamData* pStreamData;

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);

    HX_ASSERT(pStreamData);

    if (pStreamData)
    {
	pStreamData->m_pTransportBuffer->SeekFlush();
    }

    return HXR_OK;
}

BOOL
RTSPTransport::IsSourceDone(void)
{
    return m_bSourceDone;
}

void      
RTSPTransport::CheckForSourceDone(UINT16 uStreamNumber)
{
    if (m_bSourceDone)
    {
	return;
    }

    HX_ASSERT(m_pStreamHandler);

    if (!m_pStreamHandler)