sdpchunk.cpp

linux下的一款播放器

        {
            if (SDPMapPayloadToEncodingName(ulId) &&
                !strcasecmp(SDPMapPayloadToEncodingName(ulId),
                            pEncodingName))
            {
                ulPayload = ulId;
                retVal = HXR_OK;
                break;
            }
        }
    }

    return retVal;
}


/****************************************************************************
 *  Pull Functions
 */
/****************************************************************************
 *  Pull Functions
 */
/*
 * "s=" text CRLF
 */
static HX_RESULT PullSessionName(char* pData,
                                 ULONG32 ulLength,
                                 IHXValues* pSDPValues,
                                 IHXCommonClassFactory* pClassFactory)
{
    HX_ASSERT(pData && !strncmp(pData, "s=", 2));

    HX_RESULT retVal = HXR_FAIL;
    IHXBuffer* pSessionName = NULL;

    retVal = PullLine(pData + 2, ulLength - 2, pSessionName, pClassFactory);
    if (SUCCEEDED(retVal))
    {
      retVal = pSDPValues->SetPropertyCString("Title", pSessionName);
    }
    HX_RELEASE(pSessionName);
    return retVal;
}
static HX_RESULT PullMediaDesc	(char* pData, 
                                 ULONG32 ulLength, 
                                 IHXValues* pSDPValues,
                                 IHXCommonClassFactory* pClassFactory)
{
    char* pPattern;
    ULONG32 ulPayloadType = 0;
    IHXBuffer* pMimeType = NULL;
    HX_RESULT retVal = HXR_FAIL;

    // Extract Payload Type
    pPattern = FindSDPFieldByIdx(pData, ulLength, 3);
    if (pPattern != NULL)
    {
        char pNumBuffer[MAX_INT_TEXT_LENGTH + 1]; /* Flawfinder: ignore */
        char* pNumEnd;

        ULONG32 ulNumTextLength = (ulLength - (pPattern - pData));

        if (ulNumTextLength > MAX_INT_TEXT_LENGTH)
        {
            ulNumTextLength = MAX_INT_TEXT_LENGTH;
        }

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

        ulPayloadType = strtol(pNumBuffer, &pNumEnd, 10);

        if (pNumEnd > pNumBuffer)
        {
            retVal = HXR_OK;
        }
    }

    // Prepare Mime Type
    if (SUCCEEDED(retVal))
    {
        const char* pPayloadMime = NULL;
        ULONG32 ulPayloadMimeLength = 0;
        char* pMimeStart = NULL;
        ULONG32 ulMimeLength = 0;

        if (SDPIsStaticPayload(ulPayloadType))
        {
            pPayloadMime = SDPMapPayloadToEncodingName(ulPayloadType);

            retVal = HXR_FAIL;
            if (pPayloadMime != NULL)
            {
                ulPayloadMimeLength = strlen(pPayloadMime) + 1;

                pSDPValues->SetPropertyULONG32(
                    "SamplesPerSecond",
                    SDPMapPayloadToSamplesPerSecond(ulPayloadType));

                UINT16 uChannels = 
                    SDPMapPayloadToChannels(ulPayloadType);
                if (uChannels > 0)
                {
                    pSDPValues->SetPropertyULONG32(
                        "Channels",
                        uChannels);
                }

                retVal = HXR_OK;
            }
        }

        if (SUCCEEDED(retVal))
        {
            // extract portion of mime type
            // - will be completed when rtp map encountered
            // if this is not a static payload
            pPattern = StrNChr((char *) pData, ' ', ulLength);
            pMimeStart = pData + 2;
            
            retVal = HXR_FAIL;
            
            if ((pPattern != NULL) &&
                ((pPattern - pData) > 2))
            {
                ulMimeLength = pPattern - pData - 2;
                
                retVal = pClassFactory->CreateInstance(
                    CLSID_IHXBuffer,
                    (void**) &pMimeType);
            }
            
            if (SUCCEEDED(retVal))
            {
                retVal = pMimeType->SetSize(ulMimeLength + 
                                            ulPayloadMimeLength + 
                                            1);
            }
            
            if (SUCCEEDED(retVal))
            {
                memcpy(pMimeType->GetBuffer(), /* Flawfinder: ignore */
                       pMimeStart, 
                       ulMimeLength);

                if (ulPayloadMimeLength > 0)
                {
                    memcpy(pMimeType->GetBuffer() + ulMimeLength + 1, /* Flawfinder: ignore */
                           pPayloadMime, 
                           ulPayloadMimeLength - 1);

                    pMimeType->GetBuffer()[ulMimeLength] = '/';
                }
                
                pMimeType->GetBuffer()[ulMimeLength + 
                                       ulPayloadMimeLength] = '\0';
            }
        }
    }

    if (SUCCEEDED(retVal))
    {
        pSDPValues->SetPropertyULONG32("RTPPayloadType", ulPayloadType);
        pSDPValues->SetPropertyCString("MimeType", pMimeType);
    }

    HX_RELEASE(pMimeType);

    return retVal;
}


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

    // Extract the Payload Type
    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';

        ulPayloadType = strtol(pNumBuffer, &pNumEnd, 10);
        
        if (pNumEnd > pNumBuffer)
        {
            retVal = pSDPValues->GetPropertyULONG32(
                "RTPPayloadType", ulMediaPayloadType);
        }
    }

    // Check if this is the payload type entry we are looking for
    if (SUCCEEDED(retVal) && 
        (ulMediaPayloadType == ulPayloadType))
    {
        IHXBuffer* pMimeType = NULL;
        ULONG32 ulOldMimeTextLength;
        BOOL bHasParams = TRUE;

        // Locate New and Old Mime Name Section
        pPattern = StrNChr((char *) pData, ' ',  ulLength);
        retVal = HXR_FAIL;

        if (pPattern)
        {
            pPattern++;
            
            pPatternEnd = StrNChr(pPattern, 
                                  '/',
                                  ulLength - (pPattern - pData));
            if (pPatternEnd == NULL)
            {
                bHasParams = FALSE;
                pPatternEnd = FindSDPFieldEnd(pPattern,
                                              ulLength - (pPattern - pData));
            }
            
            ulPatternLength = pPatternEnd - pPattern;
            
            if (ulPatternLength != 0)
            {
                retVal = pSDPValues->GetPropertyCString(
                    "MimeType", pMimeType);
            }
        }

        // Realocate memory for combined name
        if (SUCCEEDED(retVal))
        {
            pMimeType->Release();   // OK since pSDPValues has ref.
            ulOldMimeTextLength = pMimeType->GetSize() - 1;
            retVal = pMimeType->SetSize(
                ulOldMimeTextLength + ulPatternLength + 2);
        }

        // Copy in new Mime Name section
        if (SUCCEEDED(retVal))
        {
            char *pMimeData = (char*) pMimeType->GetBuffer();

            memcpy(pMimeData + ulOldMimeTextLength + 1, /* Flawfinder: ignore */
                   pPattern,
                   ulPatternLength);

            pMimeData[ulOldMimeTextLength] = '/';
            pMimeData[pMimeType->GetSize() - 1] = '\0';
        }

        // Check for parameters following mime type
        if (SUCCEEDED(retVal))
        {
            ULONG32 ulParamIdx = 0;

            while (bHasParams)
            {
                pPattern += ulPatternLength + 1;
                 
                pPatternEnd = StrNChr(pPattern, 
                                      '/',
                                      ulLength - (pPattern - pData));
                if (pPatternEnd == NULL)
                {
                    bHasParams = FALSE;
                    pPatternEnd = FindSDPFieldEnd(
                                    pPattern,
                                    ulLength - (pPattern - pData));
                }

                ulPatternLength = pPatternEnd - pPattern;
            
                if (ulPatternLength != 0)
                {
                    LONG32 lValue;

                    if (ulPatternLength > MAX_INT_TEXT_LENGTH)
                    {
                        ulPatternLength = MAX_INT_TEXT_LENGTH;
                    }
                    
                    memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
                    pNumBuffer[ulPatternLength] = '\0';
                    
                    lValue = strtol(pNumBuffer, &pNumEnd, 10);

                    if (pNumEnd > pNumBuffer)
                    {
                        switch (ulParamIdx)
                        {
                        case 0:
                            pSDPValues->SetPropertyULONG32(
                                "SamplesPerSecond", (ULONG32) lValue);
                            break;
                        case 1:
                            pSDPValues->SetPropertyULONG32(
                                "Channels", (ULONG32) lValue);
                            break;
                        default:
                            // do nothing
                            break;
                        }
                    }
                }

                ulParamIdx++;
            }
        }
    }

    return retVal;
}


static HX_RESULT PullControl(char* pData, 
                             ULONG32 ulLength, 
                             IHXValues* pSDPValues,
                             IHXCommonClassFactory* pClassFactory)
{
    char* pPattern = NULL;
    char* pPatternEnd = NULL;
    ULONG32 ulPatternLength = 0;
    IHXBuffer* pControl = NULL;
    HX_RESULT retVal = HXR_FAIL;

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

    if (pPattern)
    {
        pPattern++;
        pPatternEnd = FindSDPFieldEnd(
            pPattern, ulLength - (pPattern - pData));

        ulPatternLength = pPatternEnd - pPattern;

        if (ulPatternLength > 0)
        {
            retVal = pClassFactory->CreateInstance(
                CLSID_IHXBuffer,
                (void**) &pControl);
        }
    }

    if (SUCCEEDED(retVal))
    {
        retVal = pControl->SetSize(ulPatternLength + 1);
        memcpy(pControl->GetBuffer(), /* Flawfinder: ignore */
               pPattern, 
               ulPatternLength);
        (pControl->GetBuffer())[ulPatternLength] = '\0';

        pSDPValues->SetPropertyCString("Control", pControl);

        HX_RELEASE(pControl);
    }

    return retVal;
}


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

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

    if (pPattern)
    {
        do
        {
            ulPatternLength = (ulLength - ((++pPattern) - pData));
            
            if (ulPatternLength > MAX_INT_TEXT_LENGTH)
            {
                ulPatternLength = MAX_INT_TEXT_LENGTH;
            }
            
            memcpy(pNumBuffer, pPattern, ulPatternLength); /* Flawfinder: ignore */
            pNumBuffer[ulPatternLength] = '\0';
            
            lCoord[ulIdx] = strtol(pNumBuffer, &pNumEnd, 10);

            if (pNumEnd == pNumBuffer)
            {
                break;
            }
        } while (((++ulIdx) < N_CLIPRECT_COORDS) &&
                 (pPattern = StrNChr((char *) pPattern, ',', ulLength)));

        if (ulIdx == N_CLIPRECT_COORDS)
        {
            retVal = HXR_OK;
        }
    }

    if (SUCCEEDED(retVal))
    {
        OrderUp(lCoord[0], lCoord[2]);
        OrderUp(lCoord[1], lCoord[3]);

        pSDPValues->SetPropertyULONG32("ClipFrameLeft", lCoord[1]);
        pSDPValues->SetPropertyULONG32("ClipFrameRight", lCoord[3]);
        pSDPValues->SetPropertyULONG32("ClipFrameTop", lCoord[0]);
        pSDPValues->SetPropertyULONG32("ClipFrameBottom", lCoord[2]);
    }

    return retVal;
}


static HX_RESULT PullFormatParams(char* pData, 
                                  ULONG32 ulLength, 
                                  IHXValues* pSDPValues,
                                  IHXCommonClassFactory* pClassFactory)
{
    char* pPattern = NULL;
    char* pPatternEnd = NULL;
    BOOL bParmNumeric = FALSE;
    ULONG32 ulParmValue = 0;
    ULONG32 ulPatternLength = 0;
    char* pParmName = NULL;
    IHXBuffer* pParmValue = NULL;
    HX_RESULT retVal = HXR_FAIL;

    // Find the start of name-value tuple
    pPattern = FindSDPFieldEnd((char*) pData, ulLength);
    if (pPattern)
    {
        ulPatternLength = (ulLength - (pPattern - pData));
        retVal = HXR_OK;
    }

    do
    {
        // Find the start of name-value tuple
        if (SUCCEEDED(retVal))
        {
            retVal = HXR_FAIL;
            
            pPattern = SkipSDPFieldEnd(pPattern, ulPatternLength);
            if (pPattern)
            {
                ulPatternLength = (ulLength - (pPattern - pData));
                retVal = HXR_OK;
            }
        }

        if (SUCCEEDED(retVal))
        {
            if (ulPatternLength == 0)
            {
                // Done: no more tuples
                break;
            }
        }

        // Parse the tuple name
        if (SUCCEEDED(retVal))
        {
            retVal = HXR_FAIL;
            pPatternEnd = StrNChr((char*) pPattern, '=', ulPatternLength);
            if (pPatternEnd)
            {
                retVal = HXR_OK;
            }
        }