rtsptran.cpp

linux下的一款播放器

    {
	return;
    }

    RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
    HX_ASSERT(pStreamData);

    m_bSourceDone = TRUE;
    while(pStreamData)
    {
	if (pStreamData->m_streamNumber == uStreamNumber)
	{
	    pStreamData->m_bReceivedAllPackets = TRUE;
	}
	else if (!pStreamData->m_bReceivedAllPackets)
	{
	    m_bSourceDone = FALSE;
	    return;
	}

	pStreamData = m_pStreamHandler->nextStreamData();
    }

    /* We have received all the packets... Tell the reposnse object */
    if (!m_bIsSource)
    {
	m_pResp->OnSourceDone();
    }

}    

void      
RTSPTransport::HandleBufferError()
{
    if (m_pResp)
    {
	m_pResp->OnProtocolError(HXR_BUFFERING);
    }
}

RTSPResendBuffer*
RTSPTransport::getResendBuffer(UINT16 uStreamNumber)
{
    return m_pStreamHandler->getResendBuffer(uStreamNumber);
}

HX_RESULT
RTSPTransport::initializeStatistics
(
    UINT32 ulRegistryID
)
{
    m_bIsInitialized = TRUE;

    if (m_bIsSource)
    {
	m_ulRegistryID = ulRegistryID;
    }
    else
    {
	// XXX HP
	// rather than create a new copy of STREAM_STATS, we simply
	// obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
	// this could save us on both the memory and several ms during the startup
/*
	IHXBuffer* pParentName = NULL;
	CHAR RegKeyName[MAX_DISPLAY_NAME] = {0};

	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	ASSERT(pStreamData);

	if (!m_pRegistry)
	{
	    return HXR_FAIL;
	}

	HX_RESULT result = m_pRegistry->GetPropName(ulRegistryID, pParentName);

	if (result != HXR_OK)
	{
	    return result;
	}

	// create registry entries of each stream
	while (pStreamData)
	{
	    UINT16 uStreamNumber = pStreamData->m_streamNumber;

	    sprintf(RegKeyName, "%s.Stream%d", pParentName->GetBuffer(),
	                                       uStreamNumber);
	
	    UINT32 uStreamId = m_pRegistry->GetId(RegKeyName);

	    // create stream reg key if it has not been created
	    // by the source yet
	    if (!uStreamId)
	    {
		return HXR_FAIL;
	    }

	    pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
	                                                   uStreamId);
							   
	    pStreamData = m_pStreamHandler->nextStreamData();
	}

	pParentName->Release();
*/
    }

    return HXR_OK;
}

HX_RESULT
RTSPTransport::SetStatistics(UINT16 uStreamNumber, STREAM_STATS* pStats)
{
    HX_RESULT	    rc = HXR_OK;
#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
    RTSPStreamData* pStreamData = NULL;

    if (!m_pStreamHandler)
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
    if (!pStreamData)
    {
	rc = HXR_FAILED;
	goto cleanup;
    }

    pStreamData->m_pStreamStats = pStats;

cleanup:
#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

    return rc;
}

HX_RESULT 
RTSPTransport::updateStatistics(BOOL bUseRegistry)
{
    m_bIsUpdated = TRUE;

#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
    if (m_bIsSource)
    {
	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	if (!pStreamData)
	{
	    return HXR_FAIL;
	}

	/*
	 * XXXGH...streams are managed by the PPM and should not show up
	 *         under the transport
	 */
	while (pStreamData)
	{
	    UINT32 ulResendSuccess = 0;
	    UINT32 ulResendFailure = 0;

	    if (pStreamData->m_pResendBuffer)
	    {
		pStreamData->m_pResendBuffer->UpdateStatistics(ulResendSuccess,
		                                               ulResendFailure);
	    }

	    m_ulTotalSuccessfulResends += ulResendSuccess;
	    m_ulTotalFailedResends += ulResendFailure;

	    pStreamData = m_pStreamHandler->nextStreamData();
	}

        m_ulSendingTime = CALCULATE_ELAPSED_TICKS(m_ulStartTime, HX_GET_TICKCOUNT()) / 1000;

	IHXBuffer* pName;

	if (bUseRegistry
        &&  m_pRegistry 
        &&  HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pName))
	{
	    char str[512]; /* Flawfinder: ignore */
	    const char* name = (const char*)pName->GetBuffer();
	    char pTemp[32]; /* Flawfinder: ignore */

	    i64toa(m_lBytesSent, pTemp, 10);

	    sprintf(str, "%-.400s.PacketsSent", name); /* Flawfinder: ignore */
	    m_pRegistry->AddInt(str, m_ulPacketsSent);
	    sprintf(str, "%-.400s.BytesSent", name); /* Flawfinder: ignore */
	    m_pRegistry->AddInt(str, INT64_TO_INT32(m_lBytesSent));

	    // Add the total bytes sent as a string because we don't want
	    // to have to truncate the INT64 value that is storing it
	    sprintf(str, "%-.400s.TotalBytesSent", name); /* Flawfinder: ignore */
	    IHXBuffer* pBuffer = new CHXBuffer();
	    pBuffer->AddRef();
	    pBuffer->Set((UCHAR*)pTemp, strlen(pTemp) + 1);
	    m_pRegistry->AddStr(str, pBuffer);
	    HX_RELEASE(pBuffer);

	    sprintf(str, "%-.400s.SendingTime", name); /* Flawfinder: ignore */
	    m_pRegistry->AddInt(str, m_ulSendingTime); 
	    sprintf(str, "%-.400s.ResendSuccess", name); /* Flawfinder: ignore */
	    m_pRegistry->AddInt(str, m_ulTotalSuccessfulResends);
	    sprintf(str, "%-.400s.ResendFailure", name); /* Flawfinder: ignore */
	    m_pRegistry->AddInt(str, m_ulTotalFailedResends);
	    pName->Release();
	}
    }
    else
    {
	ULONG32 ulNormal = 0;
	ULONG32 ulReceived = 0;
	ULONG32 ulLost = 0;
	ULONG32 ulLate = 0;
	ULONG32 ulTotal = 0;
	ULONG32 ulResendRequested = 0;
	ULONG32 ulResendReceived = 0;
	ULONG32 ulAvgBandwidth = 0;
	ULONG32 ulCurBandwidth = 0;

	UINT32	ulTotal30 = 0;
	UINT32	ulLost30 = 0;
	UINT32  ulDuplicate = 0;
	UINT32	ulOutOfOrder = 0;

	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	if (!pStreamData)
	{
	    return HXR_FAIL;
	}

	while (pStreamData)
	{
	    STREAM_STATS* pStreamStats = pStreamData->m_pStreamStats;

            if (!pStreamStats || !pStreamStats->m_bInitialized)
	    {
		goto updateContinue;
	    }

	    pStreamData->m_pTransportBuffer->UpdateStatistics(ulNormal,
	                                                      ulLost,
	                                                      ulLate,
	                                                      ulResendRequested,
	                                                      ulResendReceived,
	                                                      ulAvgBandwidth,
	                                                      ulCurBandwidth,
							      ulTotal30,
							      ulLost30,
							      ulDuplicate,
							      ulOutOfOrder);
	                  
	    ulReceived = ulNormal + ulResendReceived;
	    ulTotal = ulReceived + ulLost + ulLate;

	    pStreamStats->m_pNormal->SetInt((INT32)ulNormal);
	    pStreamStats->m_pRecovered->SetInt((INT32)ulResendReceived);
	    pStreamStats->m_pReceived->SetInt((INT32)ulReceived);
	    pStreamStats->m_pLost->SetInt((INT32)ulLost);
	    pStreamStats->m_pLate->SetInt((INT32)ulLate);
	    pStreamStats->m_pDuplicate->SetInt((INT32)ulDuplicate);
	    pStreamStats->m_pOutOfOrder->SetInt((INT32)ulOutOfOrder);
	    pStreamStats->m_pTotal->SetInt((INT32)ulTotal);
	    pStreamStats->m_pLost30->SetInt((INT32)ulLost30);
	    pStreamStats->m_pTotal30->SetInt((INT32)ulTotal30);
	    pStreamStats->m_pResendRequested->SetInt((INT32)ulResendRequested);
	    pStreamStats->m_pResendReceived->SetInt((INT32)ulResendReceived);
	    pStreamStats->m_pAvgBandwidth->SetInt((INT32)ulAvgBandwidth);
	    pStreamStats->m_pCurBandwidth->SetInt((INT32)ulCurBandwidth);

updateContinue:

	    pStreamData = m_pStreamHandler->nextStreamData();
	}
    }
#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

    return HXR_OK;
}

HX_RESULT 
RTSPTransport::UpdateRegistry(UINT32 ulStreamNumber,
			      UINT32 ulRegistryID)
{
    if (m_bIsSource)
    {
	m_ulRegistryID = ulRegistryID;
    }
    else
    {
	// XXX HP
	// rather than create a new copy of STREAM_STATS, we simply
	// obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
	// this could save us on both the memory and several ms during the startup
/*
	if (!m_pRegistry)
	{
	    return HXR_FAIL;
	}

	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
	while (pStreamData)
	{
	    if (pStreamData->m_streamNumber == (UINT16)ulStreamNumber)
	    {
		HX_DELETE(pStreamData->m_pStreamStats);
		pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
							       ulRegistryID);
		break;
	    }							   
	    pStreamData = m_pStreamHandler->nextStreamData();
	}
*/
    }

    return HXR_OK;
}

RTSPTransportBuffer*
RTSPTransport::getTransportBuffer(UINT16 uStreamNumber)
{
    if (!m_pStreamHandler)
    {
	return NULL;
    }

    RTSPStreamData* pStreamData;	    

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);

    if (!pStreamData)
    {
	return NULL;
    }

    return pStreamData->m_pTransportBuffer;
}

HX_RESULT
RTSPTransport::playReset()
{
    m_bSourceDone = FALSE;

    if(m_pStreamHandler)
    {
	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	while(pStreamData)
	{
	    if (m_bIsSource)
	    {
		pStreamData->m_packetSent = FALSE;
	    }
	    else
	    {
		pStreamData->m_pTransportBuffer->Reset();
		pStreamData->m_bReceivedAllPackets = FALSE;
	    }

	    pStreamData = m_pStreamHandler->nextStreamData();
	}
    }
    return HXR_OK;
}

HX_RESULT
RTSPTransport::pauseBuffers()
{
    if (m_pStreamHandler)
    {
	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	ASSERT(pStreamData);

	while(pStreamData)
	{
	    pStreamData->m_pTransportBuffer->Pause();

	    pStreamData = m_pStreamHandler->nextStreamData();
	}
    }

    return HXR_OK;
}

HX_RESULT
RTSPTransport::resumeBuffers()
{
    m_bIsReceivedData = FALSE;

    if (m_pStreamHandler)
    {
	RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

	ASSERT(pStreamData);

	while(pStreamData)
	{
	    pStreamData->m_pTransportBuffer->Resume();
	    pStreamData = m_pStreamHandler->nextStreamData();
	}
    }

    return HXR_OK;
}

HX_RESULT
RTSPTransport::setFirstSeqNum(UINT16 uStreamNumber, UINT16 uSeqNum)
{
    RTSPStreamData* pStreamData;

    pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);

    if(pStreamData)
    {
	if (m_bIsSource)
	{	    
	    pStreamData->m_seqNo = uSeqNum;

	    if(pStreamData->m_pResendBuffer)
	    {
		pStreamData->m_pResendBuffer->SetFirstSequenceNumber(uSeqNum);
	    }
	}
	else
	{
	    if (!pStreamData->m_pTransportBuffer)
	    {
		return HXR_FAIL;
	    }

	    if (!m_bMulticast)
	    {
		pStreamData->m_lastSeqNo = uSeqNum;
    		pStreamData->m_pTransportBuffer->Init(uSeqNum);
	    }
	}
    }

    return HXR_OK;
}

HX_RESULT
RTSPTransport::Init(IUnknown* pContext)
{
    HX_RESULT			hresult;
    
    if (!m_pContext)
    {
	m_pContext = pContext;
	m_pContext->AddRef();
    }

    hresult = pContext->QueryInterface(IID_IHXCommonClassFactory,
				       (void**)&m_pCommonClassFactory);

    if (HXR_OK != hresult)
    {
	return hresult;
    }
					    
    hresult = pContext->QueryInterface(IID_IHXScheduler,
                                       (void**)&m_pScheduler);

    if (HXR_OK != hresult)
    {
	DPRINTF(D_INFO, ("could not get scheduler...\n"));
	return hresult;
    }

    pContext->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry);

    pContext->QueryInterface(IID_IHXInternalReset,
	                               (void**)&m_pInternalReset);

    pContext->QueryInterface(IID_IHXPlayerState,
	                               (void**)&m_pPlayerState);

    pContext->QueryInterface(IID_IHXSourceBufferingStats2,
			     (void**)&m_pSrcBufferStats);

#ifdef RDT_MESSAGE_DEBUG
    IHXPreferences* pPreferences = NULL;
    
    if (pContext &&
	(HXR_OK == pContext->QueryInterface(IID_IHXPreferences,
                                            (void**) &pPreferences)))
    {
	IHXBuffer* pBuffer = NULL;

        ReadPrefBOOL(pPreferences, "RDTMessageDebug", m_bRDTMessageDebug);
	if (m_bRDTMessageDebug)
	{
	    if (HXR_OK == pPreferences->ReadPref("RDTMessageDebugFile", pBuffer))
	    {
		if (pBuffer->GetSize() <= 0)
		{
		    // no file name, no log
		    m_bRDTMessageDebug = FALSE;
		}
		else
		{
		    m_RDTmessageDebugFileName = (const char*) pBuffer->GetBuffer();
		}			
	    }
            HX_RELEASE(pBuffer);
	}
    }

    HX_RELEASE(pPreferences);
#endif	// RDT_MESSAGE_DEBUG
    
    return HXR_OK;
}

HX_RESULT
RTSPTransport::SetResendBufferDepth(UINT32 uMilliseconds)
{
    RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();

    ASSERT(pStreamData);

    while (pStreamData)
    {
	if (m_bIsSource)
	{
	    if (pStreamData->m_pResendBuffer)
	    {
		pStreamData->m_pResendBuffer->SetBufferDepth(uMilliseconds);
	    }
	}
	else
	{
	    if (pStreamData->m_pTransportBuffer)
	    {
		pStreamData->m_pTransportBuffer->SetBufferDepth(uMilliseconds);
	    }
	}

	pStreamData = m_pStreamHandler->nextStreamData();
    }

    return HXR_OK;
}

#ifdef RDT_MESSAGE_DEBUG
void RTSPTransport::RDTmessageFormatDebugFileOut(const char* fmt, ...)
{
    if(m_bRDTMessageDebug)
    {
        char buf[4096]; /* Flawfinder: ignore */
	va_list args;
	va_start(args, fmt);
	FILE* fp = fopen((const char*)m_RDTmessageDebugFileName, "a");
	if (fp)
	{
	    vsprintf(buf, fmt, args);
	    fprintf(fp, "%s\n", buf);
	    fclose(fp);
	}

	va_end(args);
    }
}
#endif	// RDT_MESSAGE_DEBUG