ramffpln.cpp

linux下的一款播放器

    m_uLastError = HXR_OK;

    m_pFFResponse = pFFResponse;
    m_pFileObject = pFileObject;

    HX_ADDREF(m_pFFResponse);
    HX_ADDREF(m_pFileObject);
 
    m_state = InitPending;

    m_pFileObject->Init(HX_FILE_READ, this);

    if (m_uLastError && m_uLastError != HXR_INVALID_METAFILE &&
	m_uLastError != HXR_DOC_MISSING  &&
        // /Need to pass through out-of-mem error as well:
        HXR_OUTOFMEMORY != m_uLastError)
    {
	m_uLastError = HXR_OK;
    }

    return m_uLastError;
}	

STDMETHODIMP CRAMFileFormat::GetFileHeader()
{
    // If we are not ready then something has gone wrong
    if (m_state != Ready) return HXR_UNEXPECTED;

    IHXValues* pHeader = NULL;
    if (HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXValues, (void**)&pHeader))
    {
	return HXR_UNEXPECTED;
    }

    pHeader->SetPropertyULONG32("StreamCount", 1);

    m_pFFResponse->FileHeaderReady(HXR_OK, pHeader);

    HX_RELEASE(pHeader);

    return HXR_OK;
}

STDMETHODIMP CRAMFileFormat::GetStreamHeader(UINT16 unStreamNumber)
{
    // If we are not ready then something has gone wrong
    if (m_state != Ready) return HXR_UNEXPECTED;

    IHXValues* pHeader = NULL;
    IHXBuffer* pBuffer = NULL;
    if (HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXValues, (void**)&pHeader) ||
	HXR_OK != m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer))
    {
	return HXR_UNEXPECTED;
    }

    pBuffer->Set((const BYTE*)zm_pStreamMimeTypes[0], strlen(zm_pStreamMimeTypes[0])+1);
    
    pHeader->SetPropertyCString("MimeType", pBuffer);
    pHeader->SetPropertyULONG32("Duration", 0);
    pHeader->SetPropertyULONG32("StreamNumber", unStreamNumber);
    pHeader->SetPropertyULONG32("AvgBitRate", 1000);
    pHeader->SetPropertyULONG32("PersistentVersion", m_ulPersistentVersion);

    m_bHeaderSent = TRUE;
    m_pFFResponse->StreamHeaderReady(HXR_OK, pHeader);

    HX_RELEASE(pBuffer);    
    HX_RELEASE(pHeader);

    return HXR_OK;
}

STDMETHODIMP CRAMFileFormat::GetPacket(UINT16 unStreamNumber)
{
    HX_RESULT result = HXR_OK;

    if (m_state != Ready || !m_bHeaderSent) 
    {
	return HXR_UNEXPECTED;
    }

    // the content of RAM is sent in ONE packet
    if (!m_pBuffer)
    {
	m_pFFResponse->StreamDone(unStreamNumber);
	return HXR_OK;
    }

    IHXPacket* pPacket = NULL;
    result = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket, (void**)&pPacket);

    if(HXR_OK == result)
    {
	pPacket->Set(m_pBuffer, 0, unStreamNumber, HX_ASM_SWITCH_ON, 0);
	m_pFFResponse->PacketReady(HXR_OK, pPacket);

	HX_RELEASE(m_pBuffer);
    }
    
    HX_RELEASE(pPacket);    

    return result;
}

STDMETHODIMP CRAMFileFormat::Seek(ULONG32 ulOffset)
{
    m_pFFResponse->SeekDone(HXR_OK);
    return HXR_OK;
}

STDMETHODIMP CRAMFileFormat::Close()
{
    HX_RELEASE(m_pBuffer);    
    HX_RELEASE(m_pRequest);

    HX_RELEASE(m_pFileObject);
    HX_RELEASE(m_pFFResponse);
    HX_RELEASE(m_pCommonClassFactory);
    HX_RELEASE(m_pContext);

    return HXR_OK;
}

STDMETHODIMP CRAMFileFormat::InitDone
(
    HX_RESULT	status
)
{
    // If we are not ready then something has gone wrong
    if (m_state != InitPending) return HXR_UNEXPECTED;

    m_state = ReadPending;

    if (status != HXR_OK)
    {
	m_uLastError = HXR_DOC_MISSING;
    }

    if (m_uLastError == HXR_OK)
    {
	m_pFileObject->Read(PACKET_SIZE);
    }
    else
    {
	m_pFFResponse->InitDone(m_uLastError); 
    }

    return HXR_OK;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IHXFileResponse::CloseDone
//  Purpose:
//	Notification interface provided by users of the IHXFileObject
//	interface. This method is called by the IHXFileObject when the
//	close of the file is complete.
//
STDMETHODIMP CRAMFileFormat::CloseDone(HX_RESULT status)
{
    return HXR_OK;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IHXFileResponse::ReadDone
//  Purpose:
//	Notification interface provided by users of the IHXFileObject
//	interface. This method is called by the IHXFileObject when the
//	last read from the file is complete and a buffer is available.
//
STDMETHODIMP CRAMFileFormat::ReadDone
(
    HX_RESULT		status,
    IHXBuffer*		pBuffer
)
{
    HX_RESULT	    result = HXR_OK;
    BOOL	    bAllReadDone = FALSE;
    char*	    pContent = NULL;
    IHXBuffer*	    pMergedBuffer = NULL;
    IHXValidator*  pValidator = NULL;
    IHXValues*	    pResponseHeaders = NULL;

    if(m_state != ReadPending) return HXR_UNEXPECTED;

    if (SUCCEEDED(status))
    {
	pContent = (char*) pBuffer->GetBuffer();

	// validate RAM on first read
	if (m_bFirstReadDone	&&
	    m_pContext		&&
    	    HXR_OK == m_pContext->QueryInterface(IID_IHXValidator, (void**)&pValidator))
	{
	    result = pValidator->ValidateMetaFile(m_pRequest, pBuffer);

	    if (HXR_OK != result)
	    {
		bAllReadDone = TRUE;
		m_pFileObject->Seek(0, FALSE);
		m_uLastError = result;
		goto cleanup;
	    }

	    // retrieve the version info
	    if (HXR_OK == m_pRequest->GetResponseHeaders(pResponseHeaders) && 
		pResponseHeaders)
	    {
		pResponseHeaders->GetPropertyULONG32("PersistentVersion", m_ulPersistentVersion);
	    }
	    HX_RELEASE(pResponseHeaders);

	    m_bFirstReadDone = FALSE;
	}
    
	pMergedBuffer = new CHXBuffer();
	pMergedBuffer->AddRef();

	if (!m_pBuffer)
	{
	    pMergedBuffer->SetSize(pBuffer->GetSize());
	    pMergedBuffer->Set(pBuffer->GetBuffer(), pBuffer->GetSize());
	}
	else
	{
            // /Check return value in case SetSize()'s alloc fails.  Overflow
            // was possible when this happened.  Fixes PR 93752:
            if (HXR_OK == (result = pMergedBuffer->SetSize(m_pBuffer->GetSize() + pBuffer->GetSize()) ) )
            {
                memcpy(pMergedBuffer->GetBuffer(), m_pBuffer->GetBuffer(), m_pBuffer->GetSize()); /* Flawfinder: ignore */
                memcpy(pMergedBuffer->GetBuffer()+m_pBuffer->GetSize(), pBuffer->GetBuffer(), pBuffer->GetSize()); /* Flawfinder: ignore */
            }
            else
            {
                m_pFileObject->Seek(0, FALSE);
                bAllReadDone = TRUE;
                m_uLastError = result;
            }
	}

	HX_RELEASE(m_pBuffer);
	m_pBuffer = pMergedBuffer;

        if (HXR_OK == result)
        {
            if (m_pBuffer->GetSize() > MAX_REASONABLE_RAM_FILE_SIZE)
            {
                // /We're past the reasonable size allowed for a ram file:
                result = HXR_INVALID_METAFILE;
                m_uLastError = result;
                bAllReadDone = TRUE;
                goto cleanup;
            }

	    m_pFileObject->Read(PACKET_SIZE);
        }
    }
    else
    {
	bAllReadDone = TRUE;

	if (m_pBuffer && m_pBuffer->GetSize())
	{	    
	    m_state = Ready;
	    m_uLastError = result;
	}
	else
	{	    
	    m_pFileObject->Seek(0, FALSE);
	    result = HXR_INVALID_METAFILE;
	    m_uLastError = result;
	}
    }

cleanup:
    
    HX_RELEASE(pValidator);

    if (bAllReadDone)
    {
	m_pFFResponse->InitDone(result); 
    }
    
    return result;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IHXFileResponse::WriteDone
//  Purpose:
//	Notification interface provided by users of the IHXFileObject
//	interface. This method is called by the IHXFileObject when the
//	last write to the file is complete.
//
STDMETHODIMP CRAMFileFormat::WriteDone(HX_RESULT status)
{
    // We don't ever write, so we don't expect to get this...
    return HXR_UNEXPECTED;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IHXFileResponse::SeekDone
//  Purpose:
//	Notification interface provided by users of the IHXFileObject
//	interface. This method is called by the IHXFileObject when the
//	last seek in the file is complete.
//
STDMETHODIMP CRAMFileFormat::SeekDone(HX_RESULT status)
{
    return HXR_OK;
}

/************************************************************************
 *	Method:
 *	    IHXFileResponse::FileObjectReady
 *	Purpose:
 *	    Notification interface provided by users of the IHXFileObject
 *	    interface. This method is called by the IHXFileObject when the
 *	    requested FileObject is ready. It may return NULL with 
 *	    HX_RESULT_FAIL if the requested filename did not exist in the 
 *	    same pool.
*/
STDMETHODIMP
CRAMFileFormat::FileObjectReady
(
    HX_RESULT status,
    IHXFileObject* pFileObject
)
{
    return HXR_OK;
}