sdpchunk.cpp

linux下的一款播放器

        if (SUCCEEDED(retVal))
        {
            retVal = HXR_FAIL;
            ulPatternLength = pPatternEnd - pPattern;
            if (ulPatternLength > 0)
            {
                retVal = HXR_OK;
            }
        }

        if (SUCCEEDED(retVal))
        {
            retVal = HXR_OUTOFMEMORY;
            pParmName = new char [ulPatternLength + FMPT_PREFIX_SIZE + 1];
            if (pParmName)
            {
                retVal = HXR_OK;
            }
        }

        if (SUCCEEDED(retVal))
        {
            memcpy(pParmName, /* Flawfinder: ignore */
                   FMPT_PREFIX,
                   FMPT_PREFIX_SIZE);
            memcpy(pParmName + FMPT_PREFIX_SIZE, /* Flawfinder: ignore */
                   pPattern, 
                   ulPatternLength);
            pParmName[ulPatternLength + FMPT_PREFIX_SIZE] = '\0';

            pPattern = pPatternEnd;
            ulPatternLength = (ulLength - ((++pPattern) - pData));
        }

        // Parse the tuple value
        if (SUCCEEDED(retVal))
        {
            retVal = HXR_FAIL;

            pPatternEnd = StrNChr(pPattern, ';', ulPatternLength);

            if (!pPatternEnd)
            {
                pPatternEnd = FindSDPFieldEnd(pPattern, ulPatternLength);
            }

            if (pPatternEnd)
            {
                ulPatternLength = pPatternEnd - pPattern;
            }

            if (ulPatternLength > 0)
            {
                retVal = HXR_OK;
            }
        }

        bParmNumeric = FALSE;

        if (SUCCEEDED(retVal) && (ulPatternLength <= (MAX_INT_TEXT_LENGTH - 1)))
        {
            char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
            char* pNumEnd = NULL;

            memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
            pNumBuffer[ulPatternLength] = '\0';

            ulParmValue = strtol(pNumBuffer, &pNumEnd, 10);
            if (pNumEnd && (pNumEnd == (pNumBuffer + ulPatternLength)))
            {
                bParmNumeric = TRUE;
            }
        }

        if (bParmNumeric)
        {
            if (SUCCEEDED(retVal))
            {
                retVal = pSDPValues->SetPropertyULONG32(pParmName, 
                                                        ulParmValue);
            }
        }
        else
        {
            if (SUCCEEDED(retVal))
            {
                retVal = pClassFactory->CreateInstance(CLSID_IHXBuffer,
                    (void**) &pParmValue);
            }
            
            if (SUCCEEDED(retVal))
            {
                retVal = pParmValue->SetSize(ulPatternLength + 1);
            }
            
            if (SUCCEEDED(retVal))
            {
                UINT8* pBufferData = pParmValue->GetBuffer();
                memcpy(pBufferData, pPattern, ulPatternLength); /* Flawfinder: ignore */
                pBufferData[ulPatternLength] = '\0';
                
                retVal = pSDPValues->SetPropertyCString(pParmName, pParmValue);
            }
        }

        if (SUCCEEDED(retVal))
        {
            ulPatternLength = 0;
            pPattern = pPatternEnd;
            if (pPattern)
            {
                ulPatternLength = (ulLength - ((++pPattern) - pData));
            }
        }

        HX_VECTOR_DELETE(pParmName);
        HX_RELEASE(pParmValue);
    } while (SUCCEEDED(retVal) && (ulPatternLength != 0));

    return retVal;
}


static HX_RESULT PullBufferDelay(char* pData, 
                                 ULONG32 ulLength, 
                                 IHXValues* pSDPValues,
                                 IHXCommonClassFactory* pClassFactory)
{
    char* pPattern;
    ULONG32 ulPatternLength;
    char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
    char* pNumEnd;
    ULONG32 ulPreroll;
    double fPreroll;
    HX_RESULT retVal = HXR_FAIL;

    if (pSDPValues->GetPropertyULONG32("Preroll", ulPreroll) != HXR_OK)
    {
        pPattern = StrNChr((char *) pData, ':', ulLength);

        if (pPattern)
        {
            ulPatternLength = (ulLength - ((++pPattern) - pData));
            
            if (ulPatternLength > MAX_INT_TEXT_LENGTH)
            {
                ulPatternLength = MAX_INT_TEXT_LENGTH;
            }
            
            memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
            pNumBuffer[ulPatternLength] = '\0';
            
            fPreroll = strtod(pNumBuffer, &pNumEnd);
            
            if (pNumEnd > pNumBuffer)
            {
                retVal = pSDPValues->SetPropertyULONG32(
                    "Preroll", 
                    (ULONG32) (fPreroll * 1000.0 + 0.5));
            }
        }
    }

    return retVal;
}

static HX_RESULT PullGroupID(char* pData, 
                             ULONG32 ulLength, 
                             IHXValues* pSDPValues,
                             IHXCommonClassFactory* pClassFactory)
{
    char* pPattern;
    ULONG32 ulPatternLength;
    char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
    char* pNumEnd;
    ULONG32 ulGroupID;
    HX_RESULT retVal = HXR_FAIL;

    pPattern = StrNChr((char *) pData, ':', ulLength);

    if (pPattern)
    {
        ulPatternLength = (ulLength - ((++pPattern) - pData));

        pPattern = StrNChr((char *) pPattern, '=', ulPatternLength);
    }
    
    if (pPattern)
    {
        ulPatternLength = (ulLength - ((++pPattern) - pData));
        
        if (ulPatternLength > MAX_INT_TEXT_LENGTH)
        {
            ulPatternLength = MAX_INT_TEXT_LENGTH;
        }
        
        memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
        pNumBuffer[ulPatternLength] = '\0';
        
        ulGroupID = strtol(pNumBuffer, &pNumEnd, 10);
                
        if (pNumEnd > pNumBuffer)
        {
            retVal = pSDPValues->SetPropertyULONG32(
                "AlternateGroupID",
                ulGroupID);
        }
    }

    return retVal;
}

static HX_RESULT PullGroupBitrate(char* pData, 
                                  ULONG32 ulLength, 
                                  IHXValues* pSDPValues,
                                  IHXCommonClassFactory* pClassFactory)
{
    char* pPattern;
    ULONG32 ulPatternLength;
    char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
    char* pNumEnd;
    ULONG32 ulGroupBitrate;
    HX_RESULT retVal = HXR_FAIL;

    pPattern = StrNChr((char *) pData, ':', ulLength);
   
    if (pPattern)
    {
        ulPatternLength = (ulLength - ((++pPattern) - pData));
        
        pPattern = StrNChr((char *) pPattern, '=', ulPatternLength);
    }

    if (pPattern)
    {
        ulPatternLength = (ulLength - ((++pPattern) - pData));
        
        if (ulPatternLength > MAX_INT_TEXT_LENGTH)
        {
            ulPatternLength = MAX_INT_TEXT_LENGTH;
        }
        
        memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
        pNumBuffer[ulPatternLength] = '\0';
        
        ulGroupBitrate = strtol(pNumBuffer, &pNumEnd, 10);
                
        if (pNumEnd > pNumBuffer)
        {
            retVal = pSDPValues->SetPropertyULONG32(
                "AlternateGroupBitrate",
                ulGroupBitrate);
        }
    }

    return retVal;
}


static HX_RESULT PullBandwidth	(char* pData,
                                 ULONG32 ulLength, 
                                 IHXValues* pSDPValues,
                                 IHXCommonClassFactory* pClassFactory)
{        
    char* pPattern;
    ULONG32 ulPatternLength;
    char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
    char* pNumEnd;
    HX_RESULT retVal = HXR_FAIL;

    char* pPropName = NULL;
    ULONG32 ulBandwidth = 0;
    
    pPattern = StrNChr((char *) pData, ':', ulLength);           
    if (pPattern)
    {
        ulPatternLength = (ulLength - ((++pPattern) - pData));
        
        if (ulPatternLength > MAX_INT_TEXT_LENGTH)
        {
            ulPatternLength = MAX_INT_TEXT_LENGTH;
        }
        
        memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
        pNumBuffer[ulPatternLength] = '\0';
        
        ulBandwidth = strtol(pNumBuffer, &pNumEnd, 10);

        if (pNumEnd > pNumBuffer)
        {	    
	    // skip b=
	    pData += 2;
	    ulLength -= 2;
	    if (StrNStr((char*)pData, "AS:", ulLength, 3))
	    {        
		pPropName = "AvgBitRate";
		ulBandwidth *= 1000;
	    }
	    else if (StrNStr((char*)pData, "RR:", ulLength, 3))
	    {        
		pPropName = "RtcpRRRate";
	    }
	    else if (StrNStr((char*)pData, "RS:", ulLength, 3))
	    {        
		pPropName = "RtcpRSRate";
	    }
	    else
	    {
		// fine, ignore
		retVal = HXR_OK;
	    }	   
        }

	if (pPropName)
	{
	    retVal = pSDPValues->SetPropertyULONG32(pPropName, ulBandwidth);	    
	}
    }

    return retVal;
}

/****************************************************************************
 *  Local Utilities
 */
inline static ULONG32 GetPullTableIdx(const SDPRecordPuller* pTable,
                                      char* pData, 
                                      ULONG32 ulRecordSize)
{
    ULONG32 ulIdx = 0;

    HX_ASSERT(pTable);

    while (pTable->pSDPMatch != NULL)
    {
        if (pTable->ulSDPMatchSize <= ulRecordSize)
        {
            if (!strncmp(pTable->pSDPMatch, 
                         pData, 
                         pTable->ulSDPMatchSize))
            {
                return ulIdx;
            }
        }

        pTable++;
        ulIdx++;
    }

    return BAD_PULL_TABLE_IDX;
}


inline static char* FindSDPFieldByIdx(char* pData, 
                                       ULONG32 ulLength, 
                                       ULONG32 ulIdx)
{
    char* pField;

    while((ulIdx != 0) && (pData != NULL))
    {
        pField = StrNChr((char *) pData, ' ', ulLength);
        if (pField)
        {
            ulLength -= ((++pField) - pData);  
            ulIdx--;
        }
        pData = pField;
    } 

    if (ulLength == 0)
    {
        pData = NULL;
    }

    return pData;
}

inline static char* FindSDPFieldEnd(char* pData, 
                                     ULONG32 ulLength)
{
    while((ulLength != 0) &&
          (*pData != ' ') &&
          (*pData != CHAR_CR) &&
          (*pData != CHAR_LF))
    {
        pData++;
        ulLength--;
    } 

    return pData;
}

inline static char* FindCRLF(char* pData, 
                             ULONG32 ulLength)
{
    HX_ASSERT(pData && ulLength);
    
    while((0 != ulLength) &&
          (CHAR_CR != *pData))
    {
        pData++;
        ulLength--;
    } 

    if (ulLength)
    {	
        if (*(pData+1) == CHAR_LF)
        {
            // found it
            return pData;
        }	
        else
        {
            pData++;
            ulLength--;
            return FindCRLF(pData, ulLength);
        }
    }

    return NULL;
}

/*
 * saves what pData points to upto CRLF sequence in pLine ('\0' terminated)
 */
inline static HX_RESULT PullLine(char* pData, 
                             ULONG32 ulLength,
                             REF(IHXBuffer*) pLine,
                             IHXCommonClassFactory* pClassFactory)
{
    HX_ASSERT(pData && ulLength);
    
    char* pc = NULL;
    HX_RESULT retVal = HXR_FAIL;

    pc = FindCRLF((char*)pData, ulLength);
    if (pc)
    {
        HX_ASSERT((pc > pData) && (ulLength > (ULONG32)(pc - pData)));
        ulLength = pc - pData;
        retVal = HXR_OK;
    }

    if (SUCCEEDED(retVal))
    {
        retVal = pClassFactory->CreateInstance
            (CLSID_IHXBuffer, (void**) &pLine);
    }	

    if (SUCCEEDED(retVal))
    {
        retVal = pLine->SetSize(ulLength + 1);	
        BYTE* pcLine = pLine->GetBuffer();
        memcpy(pcLine, pData, ulLength); /* Flawfinder: ignore */
        pcLine[ulLength] = '\0';
    }

    return retVal;            
}


inline static char* SkipSDPFieldEnd(char* pData, ULONG32 ulSize)
{
    while((ulSize > 0) &&
          ((*pData == CHAR_CR) ||
           (*pData == CHAR_LF) ||
           (*pData == ' ')))
    {
        pData++;
        ulSize--;
    } 

    return pData;
}

inline static void OrderUp(LONG32 &l1, LONG32 &l2)
{
    LONG32 temp;

    if (l1 > l2)
    {
        temp = l1;
        l1 = l2;
        l2 = temp;
    }
}