mp4desc.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 802 行 · 第 1/2 页

}

DecoderSpecifcInfo::~DecoderSpecifcInfo()
{
    HX_DELETE(m_pData);
}

/****************************************************************************
 *  Public functions
 */
HX_RESULT DecoderSpecifcInfo::Unpack(UINT8* &pData, 
				     ULONG32 &ulSize,
				     ULONG32 ulFlags)
{
    ULONG32 ulTagSize = 1;
    HX_RESULT retVal = HXR_INVALID_PARAMETER;

    m_ulFlags = ulFlags;
    
    if (ulSize >= 1)
    {
	m_uTag = GetTag(pData, ulSize, TRUE);
	retVal = HXR_OK;
    }
    
    if (retVal == HXR_OK)
    {
	switch (GetDescType(m_uTag))
	{
	case DTYP_DECODER_INFO_SHORT:
	    m_ulLength = GetSize(pData, ulSize, TRUE);
	    break;
	default:
	    retVal = HXR_INVALID_PARAMETER;
	    break;
	}
    }

    if ((ulFlags & SIZE_HEADER_INCLUSIVE) && (retVal == HXR_OK))
    {
	if (m_ulLength > 2)
	{
	    m_ulLength -= 2;
	}
    }

    if ((retVal == HXR_OK) &&
	(m_ulLength > 0))
    {
	retVal = HXR_INVALID_PARAMETER;

	if (ulSize >= m_ulLength)
	{
	    m_pData = new UINT8 [m_ulLength];
	
	    retVal = HXR_OUTOFMEMORY;
	    if (m_pData)
	    {
		memcpy(m_pData, pData, m_ulLength); /* Flawfinder: ignore */
		pData += m_ulLength;
		ulSize -= m_ulLength;
		retVal = HXR_OK;
	    }
	}
    }

    return retVal;
}


/****************************************************************************
 *  DecoderConfigDescriptor
 */
/****************************************************************************
 *  Constructor/Destructor
 */
DecoderConfigDescriptor::DecoderConfigDescriptor(void)
    : m_uLength(0)
    , m_pDecSpecificInfo(NULL)
{
    ;
}

DecoderConfigDescriptor::~DecoderConfigDescriptor()
{
    HX_DELETE(m_pDecSpecificInfo);
}

/****************************************************************************
 *  Public functions
 */
HX_RESULT DecoderConfigDescriptor::Unpack(UINT8* &pData, 
					  ULONG32 &ulSize,
					  ULONG32 ulFlags)
{
    HX_RESULT retVal = HXR_INVALID_PARAMETER;
    
    m_ulFlags = ulFlags;

    if (ulSize >= 15)
    {
	m_uTag = GetTag(pData, ulSize, TRUE);
	retVal = HXR_OK;
    }
    
    if (retVal == HXR_OK)
    {
	retVal = HXR_INVALID_PARAMETER;

	if (ulSize >= 14)
	{
	    m_uLength = (UINT8) GetSize(pData, ulSize, TRUE);

	    if (ulSize >= 13)
	    {
		m_uObjectProfileIndication = *(pData++);
		m_uStreamType = ((*pData) >> 2);
		m_bUpStream = (((*pData) >> 1) & 0x01);
		m_bReservedBit = ((*pData) & 0x01);
		pData++;
		m_ulBufferSizeDB = GetUI24(pData);
		pData += 3;
		m_ulMaxBitrate = GetUL32(pData);
		pData += 4;
		m_ulAvgBitrate = GetUL32(pData);
		pData += 4;
		
		ulSize -= 13;
		
		retVal = HXR_OK;
	    }
	}
    }

    if (retVal == HXR_OK)
    {
	if (ulSize > 0)
	{
	    UINT8 uTag = GetTag(pData, ulSize);
	
	    if (GetDescType(uTag) == DTYP_DECODER_INFO_SHORT)
	    {
		m_pDecSpecificInfo = new DecoderSpecifcInfo;
	    
		retVal = HXR_OUTOFMEMORY;
		if (m_pDecSpecificInfo)
		{
		    retVal = m_pDecSpecificInfo->Unpack(pData, 
							ulSize, 
							ulFlags);
		}
	    }
	}
    }

    return retVal;
}
    

/****************************************************************************
 *  ES_Descriptor
 */
/****************************************************************************
 *  Constructor/Destructor
 */
ES_Descriptor::ES_Descriptor(void)
    : m_uLength(0)
    , m_pURLString(NULL)
    , m_pExtDescrArray(NULL)
    , m_pLangDescr(NULL)
    , m_pDecConfigDescr(NULL)
    , m_pSLConfigDescr(NULL)
    , m_pIPIPtr(NULL)
    , m_pIPIDS(NULL)
    , m_pQOSDescr(NULL)
{
    ;
}

ES_Descriptor::~ES_Descriptor(void)
{
    HX_VECTOR_DELETE(m_pURLString);
    HX_DELETE(m_pExtDescrArray);
    HX_DELETE(m_pLangDescr);
    HX_DELETE(m_pDecConfigDescr);
    HX_DELETE(m_pSLConfigDescr);
    HX_DELETE(m_pIPIPtr);
    HX_DELETE(m_pIPIDS);
    HX_DELETE(m_pQOSDescr);
}


/****************************************************************************
 *  Public functions
 */
HX_RESULT ES_Descriptor::Unpack(UINT8* &pData, 
				ULONG32 &ulSize,
				ULONG32 ulFlags)
{
    LD bitInfo;
    UINT8 uTag;
    UINT8* pPreOCRData = NULL;
    ULONG32 ulPreOCRSize = 0;
    UINT8* pLastData = NULL;
    ULONG32 ulLastSize = 0;
    ULONG32 ulStartSize = ulSize;
    BOOL bAlternateParseMode = FALSE;
    BOOL bAttemptPreOCRSyntax = FALSE;
    HX_RESULT retVal = HXR_INVALID_PARAMETER;
    
    m_ulFlags = ulFlags;

    if (ulSize >= 5)
    {
	m_uTag = GetTag(pData, ulSize, TRUE);
	retVal = HXR_OK;
    }
    
    if (retVal == HXR_OK)
    {
	retVal = HXR_INVALID_PARAMETER;
	if (ulSize >= 4)
	{   
	    m_uLength = (UINT16) GetSize(pData, ulSize, TRUE);
	    
	    if (ulSize >= 3)
	    {
		m_uESid = GetUI16(pData);
		pData += 2;
	    
		initbuffer(pData, &bitInfo);
		m_bStreamDependenceFlag = getbits1(&bitInfo);
		m_bURLflag = getbits1(&bitInfo);
		m_bOCRStreamFlag = (getbits1(&bitInfo) != 0);
		m_uStreamPriority = (UINT8) getbits(5, &bitInfo);
		pData++;
	    
		ulSize -= 3;

		retVal = HXR_OK;
	    }
	}
    }
    
    if (retVal == HXR_OK)
    {
	if (m_bStreamDependenceFlag)
	{
	    retVal = HXR_INVALID_PARAMETER;
	    if (ulSize >= 2)
	    {
		retVal = HXR_OK;
		
		m_uDependsOn_ES_ID = GetUI16(pData);
		pData += 2;
		
		ulSize -= 2;
	    }
	}
    }
    
    if (retVal == HXR_OK)
    {
	if (m_bURLflag)
	{
	    retVal = HXR_INVALID_PARAMETER;
	    if (ulSize >= 1)
	    {
		ULONG32 ulURLLength = pData[0];
		pData++;
		ulSize--;

		if (ulSize >= ulURLLength)
		{
		    m_pURLString = new UINT8 [ulURLLength + 1];
	    
		    retVal = HXR_OUTOFMEMORY;
		    if (m_pURLString)
		    {
			retVal = HXR_OK;
		    }
	    
		    if (retVal == HXR_OK)
		    {
			memcpy(m_pURLString, pData, ulURLLength); /* Flawfinder: ignore */
			m_pURLString[ulURLLength] = '\0';

			pData += ulURLLength;
			ulSize -= ulURLLength;
		    }
		}
	    }
	}
    }
    
    do
    {
	bAttemptPreOCRSyntax = FALSE;

	if (retVal == HXR_OK)
	{
	    if (m_bOCRStreamFlag)
	    {
		pPreOCRData = pData;
		ulPreOCRSize = ulSize;
		
		retVal = HXR_INVALID_PARAMETER;
		if (ulSize >= 2)
		{
		    retVal = HXR_OK;
		    
		    m_uOCR_ES_ID = GetUI16(pData);
		    pData += 2;
		    
		    ulSize -= 2;
		}
	    }
	}
	
	while ((retVal == HXR_OK) &&
	    (ulSize > 0))
	{
	    uTag = GetTag(pData, ulSize);
	    
	    switch (GetDescType(uTag))
	    {
	    case DTYP_DECODER_CONFIG:	    
		pLastData = pData;
		ulLastSize = ulSize;
		
		HX_DELETE(m_pDecConfigDescr);
		m_pDecConfigDescr = new DecoderConfigDescriptor;
		if (bAlternateParseMode)
		{
		    m_ulFlags |= SIZE_HEADER_INCLUSIVE;
		}
		retVal = m_pDecConfigDescr->Unpack(pData, 
		    ulSize, 
		    m_ulFlags);
#ifdef _SHORTCUT_ON_DECCONFIG
		if (SUCCEEDED(retVal))
		{
		    ulSize = 0;
		}
#endif	// _SHORTCUT_ON_DECCONFIG
		break;
		
	    case DTYP_SL_CONFIG:
		HX_DELETE(m_pSLConfigDescr);
		m_pSLConfigDescr = new SLConfigDescriptor;
		retVal = m_pSLConfigDescr->Unpack(pData, ulSize);
		break;
		
	    default:
		retVal = HXR_INVALID_PARAMETER;
		break;
	    }
	    
#ifdef _ATTEMPT_ALTERNATE_PARSING_MODES
	    if (FAILED(retVal) &&
		pLastData &&
		(!bAlternateParseMode))
	    {
		bAlternateParseMode = TRUE;
		pData = pLastData;
		ulSize = ulLastSize;
		pLastData = NULL;
		ulLastSize = 0;
		retVal = HXR_OK;
	    }
#endif	// _ATTEMPT_ALTERNATE_PARSING_MODES
	}
	
	if (FAILED(retVal) && m_bOCRStreamFlag && pPreOCRData)
	{
#ifdef _ATTEMPT_PREOCR_SYNTAX
	    // OCR was introduced later - after Phillips produced its files
	    // and thus some older files have OCR flag and no OCR_ES_ID
	    // since previously the OCR flag bit was considered reserved and
	    // had no meaning.
	    pData = pPreOCRData;
	    ulSize = ulPreOCRSize;
	    m_bOCRStreamFlag = FALSE;
	    bAttemptPreOCRSyntax = TRUE;
	    retVal = HXR_OK;
#endif	// _ATTEMPT_PREOCR_SYNTAX
	}
    } while (bAttemptPreOCRSyntax);
    
    if (SUCCEEDED(retVal))
    {
	if ((ulStartSize - ulSize) == m_uLength)
	{
	    m_ulFlags |= SIZE_HEADER_INCLUSIVE;
	}
    }

    return retVal;
}