sdpmdgen.cpp

linux下的一款播放器

                    // don't use if 0 ( XXXJC we used to assert if the 
                    // prop was not present).
                    if (0 != propValue)
                    {
                        duration = propValue;
                        bDurationFound = TRUE;
                    }
                }
                else if(strcasecmp(pPropName, "RTPPayloadType") == 0)
                {
                    rtpPayloadType = propValue;
                    bRtpPayloadTypeFound = TRUE;
                }
                else if(strcasecmp(pPropName, "SamplesPerSecond") == 0)
                {
                    samplesPerSecond = propValue;
                    bSamplesPerSecondFound = TRUE;
                }
                else if(strcasecmp(pPropName, "Channels") == 0)
                {
                    nChannels = propValue;
                    bChannelsFound = TRUE;
                }
                else if(strcasecmp(pPropName, "MulticastTTL") == 0)
                {
                    connTTL = propValue;
                    bFoundTTL = TRUE;
                }
                else if(strcasecmp(pPropName, "MulticastRange") == 0)
                {
                    connRange = propValue;
                    bFoundRange = TRUE;
                }
                else if(strcasecmp(pPropName, "Port") == 0)
                {
                    port = propValue;
                }
                else if(strcasecmp(pPropName, "ptime") == 0)
                {
                    ptime = propValue;
                    bPtimeFound = TRUE;
                }   
                else if(strcasecmp(pPropName, "AvgBitRate") == 0)
                {
                    avgBitRate = propValue;
                    
                    // we need this in kbps
                    avgBitRate = (UINT32)((double)avgBitRate / 1000.0 + 0.5);
                    bFoundAvgBitRate = TRUE;
                    // add it to attribute as well.         
                    bAddToHeader = TRUE;    
                }
                else if(strcasecmp(pPropName, "RtcpRRRate") == 0)
                {
                    bFoundRTCPRR = TRUE;
                    ulRTCPRR = propValue;
                }
                else if(strcasecmp(pPropName, "RtcpRSRate") == 0)
                {
                    bFoundRTCPSR = TRUE;
                    ulRTCPSR = propValue;
                }
                else if(strcasecmp(pPropName, "PreDecBufSize") == 0)
                {
                    bFoundPreDecBufSize = TRUE;
                    ulPreDecBufSize = propValue;
                }
                else if(strcasecmp(pPropName, "InitPreDecBufPeriod") == 0)
                {
                    bFoundPreDecBufPeriod = TRUE;
                    ulPreDecBufPeriod = propValue;
                }
                else if(strcasecmp(pPropName, "InitPostDecBufPeriod") == 0)
                {
                    bFoundPostDecBufPeriod = TRUE;
                    ulPostDecBufPeriod = propValue;
                }
                else if(strcasecmp(pPropName, "DecByteRate") == 0)
                {
                    bFoundDecByteRate = TRUE;
                    ulDecByteRate = propValue;
                }

                else
                {
                    bAddToHeader = TRUE;                    
                }
        

                if (bAddToHeader)
                {
                    NEW_FAST_TEMP_STR(pszAttBuf, 4096, strlen(pPropName) + 64);
                    SafeSprintf(pszAttBuf, 4096, "a=%s:integer;%d%s", pPropName, 
                                                            propValue, pszEOL);
                    streamAttributes += pszAttBuf;
                    DELETE_FAST_TEMP_STR(pszAttBuf);
                }
                
                /* make sure to reset SdpFileType header */
                if (strncasecmp(pPropName, "SdpFileType", 11) == 0)
                {
                    pValueArray[i]->SetPropertyULONG32(pPropName, NONE_SDP);
                }
                rc = pValueArray[i]->GetNextPropertyULONG32(pPropName,
                    propValue);
            }
            rc = pValueArray[i]->GetFirstPropertyBuffer(pPropName, pPropBuffer);
            while(rc == HXR_OK)
            {
                INT32 dataSize = pPropBuffer->GetSize();

                NEW_FAST_TEMP_STR(pszAttBuf, 4096, dataSize * 2 +
                                                   strlen(pPropName) + 64);
                NEW_FAST_TEMP_STR(pszPropString, 4096, dataSize * 2 + 64);

                (void)BinTo64((const BYTE*)pPropBuffer->GetBuffer(),
                    dataSize, pszPropString);

                SafeSprintf(pszAttBuf, 4096, "a=%s:buffer;\"%s\"%s", pPropName, 
                                                      pszPropString, pszEOL);

                streamAttributes += pszAttBuf;
                DELETE_FAST_TEMP_STR(pszPropString);
                DELETE_FAST_TEMP_STR(pszAttBuf);

                HX_RELEASE(pPropBuffer);

                rc = pValueArray[i]->GetNextPropertyBuffer(pPropName,
                    pPropBuffer);
            }

            rc = pValueArray[i]->GetFirstPropertyCString(pPropName,
                pPropBuffer);
            while(rc == HXR_OK)
            {
                char* pString = (char*) pPropBuffer->GetBuffer();
                char* pszData=NULL;
                BOOL bDeleteString = FALSE;
                int len = pPropBuffer->GetSize();

                bAddToHeader = FALSE;

                if(strcasecmp(pPropName, "MimeType") == 0)
                {
                    pszMimeType = EscapeBuffer(pString, pPropBuffer->GetSize());

                    pszMimeLast = strchr(pszMimeType, '/');
                    if(pszMimeLast)
                    {
                        int MFLen = pszMimeLast-pszMimeType;
                        pszMimeLast++;
                        pszMimeFirst = new char [ MFLen+1 ];
                        ulMimeFirstBufLen = MFLen + 1;
                        memcpy(pszMimeFirst, pszMimeType, MFLen); /* Flawfinder: ignore */
                        pszMimeFirst[MFLen] = '\0';
                    }
                    else
                    {
                        // mimetype is not in the right format...
                    }
                }
                else if(strcasecmp(pPropName, "MulticastAddress") == 0)
                {
                    pszConnAddr = EscapeBuffer(pString, pPropBuffer->GetSize());
                }
                else if(strcasecmp(pPropName, "Control") == 0)
                {
                    if (pControlStringBuff)
                    {
                        HX_RELEASE(pControlStringBuff);
                        pControlStringBuff = pPropBuffer;
                        pControlStringBuff->AddRef(); 
                    }
                }
                else if(strcasecmp(pPropName, "PayloadParameters") == 0)
                {
                    pszFmtp = EscapeBuffer(pString, pPropBuffer->GetSize());
                }               
                else if(strcasecmp(pPropName, "SDPData") == 0)
                {
                    pszSDPData = new char [ len + 1 ];
                    memcpy(pszSDPData, (const char*)pPropBuffer->GetBuffer(), len); /* Flawfinder: ignore */
                    pszSDPData[len] = '\0';
		    RemoveASLine(pszSDPData, len);
                }
                else if(strcasecmp(pPropName, "Information") == 0)
                {
                    // "i="
                    HX_ASSERT(!pszInfo);
                    pszInfo = EscapeBuffer(pString, pPropBuffer->GetSize());
                }
                else
                {
                    pszData = EscapeBuffer(pString, pPropBuffer->GetSize());
                    bDeleteString = TRUE;
                    bAddToHeader = TRUE;                
                }
                
                if(bAddToHeader)
                {
                    NEW_FAST_TEMP_STR(pszAttBuf, 4096, strlen(pszData) +
                                                       strlen(pPropName) + 64);
                    SafeSprintf(pszAttBuf, 4096,"a=%s:string;\"%s\"%s", pPropName, 
                                                              pszData, pszEOL);
                    streamAttributes += pszAttBuf;
                    DELETE_FAST_TEMP_STR(pszAttBuf);
                }

                if (bDeleteString)
                {
                    HX_VECTOR_DELETE(pszData);
                }

                HX_RELEASE(pPropBuffer);

                rc = pValueArray[i]->GetNextPropertyCString(pPropName,
                                                            pPropBuffer);
            }

            if(!bRtpPayloadTypeFound)
            {
                ulPayloadType = RTP_PAYLOAD_RTSP;
            }
            else
            {
                ulPayloadType = rtpPayloadType;
            }

            if (bUseOldSdp)
            {   
                // our old sdpplin expects m= to have either "audio", 
                // "video", or "data", and anything else would be BAD!
                if (strcmp(pszMimeFirst, "audio") && strcmp(pszMimeFirst, "video"))
                {
                    SafeStrCpy(pszMimeFirst, "data", ulMimeFirstBufLen);
                }
            }
            else if (!pszMimeFirst)
            {
                pszMimeFirst = new char [ 5 ];
                strcpy(pszMimeFirst, "data"); /* Flawfinder: ignore */
            }

            // m=
            NEW_FAST_TEMP_STR(pszTmpString, 256, strlen(pszMimeFirst) + 128);
            SafeSprintf(pszTmpString, 256, "m=%s %d RTP/AVP %d%s", 
                pszMimeFirst, port, ulPayloadType, pszEOL);
            mDesc += pszTmpString;
            DELETE_FAST_TEMP_STR(pszTmpString);

            // i= 
            if (pszInfo)
            {
                NEW_FAST_TEMP_STR(pszTmpStr, 256, strlen(pszInfo) + 64);
                SafeSprintf(pszTmpStr, 256,"i=%s%s", pszInfo, pszEOL);
                mDesc += pszTmpStr;
                DELETE_FAST_TEMP_STR(pszTmpStr);

                HX_VECTOR_DELETE(pszInfo);
                pszInfo = NULL;
            }

            /* Format the connection line only if MulticastAddress and 
             * MulticastTTL exist in the stream header
             */
            if (pszConnAddr && strlen(pszConnAddr) && bFoundTTL)
            {
                NEW_FAST_TEMP_STR(pszTmpString, 256, strlen(pszConnAddr) + 128);
                if (bFoundRange)
                {
                    SafeSprintf(pszTmpString, 256,"c=IN IP4 %s/%d/%d%s", 
                        pszConnAddr, connTTL, connRange, pszEOL);
                }
                else
                {
                    SafeSprintf(pszTmpString, 256,"c=IN IP4 %s/%d%s", 
                        pszConnAddr, connTTL, pszEOL);
                }

                mDesc += pszTmpString;

                DELETE_FAST_TEMP_STR(pszTmpString);
            }

            // b=
            if (bFoundAvgBitRate)
            {
                SafeSprintf(psz256, 256,"b=AS:%u%s", avgBitRate, pszEOL); 
                mDesc += psz256;
                bFoundAvgBitRate = FALSE;
            }

            if (bFoundRTCPRR)
            {
                SafeSprintf(psz256, 256,"b=RR:%u%s", ulRTCPRR, pszEOL); 
                mDesc += psz256;
                bFoundRTCPRR = FALSE;
            }
            
            if (bFoundRTCPSR)
            {
                SafeSprintf(psz256, 256,"b=RS:%u%s", ulRTCPSR, pszEOL); 
                mDesc += psz256;
                bFoundRTCPSR = FALSE;
            }
                    
            // a=control
            if (pControlStringBuff)
            {
                char* pString = (char*) pControlStringBuff->GetBuffer();
                char* pszData=NULL;

                pszData = EscapeBuffer(pString, pControlStringBuff->GetSize());

                if (pContentBase || pQueryParams)
                {
                    UINT32 ulBuffLen = strlen(pszData);
                    ulBuffLen += (pContentBase) ? pContentBase->GetSize() : 0;
                    ulBuffLen += (pQueryParams) ? pQueryParams->GetSize() : 0;
                    ulBuffLen +=64;

                    NEW_FAST_TEMP_STR(pszControlString, 512, ulBuffLen); 
                    SafeSprintf(pszControlString, 512, "a=control:%s%s%s%s",
                    (pContentBase)? ((char*)pContentBase->GetBuffer()) : "",
                    pControlStringBuff->GetBuffer(),
                    (pQueryParams)?((char*)pQueryParams->GetBuffer()) : "",
                    pszEOL);
                    
                    mDesc += pszControlString;
                    DELETE_FAST_TEMP_STR(pszControlString);
                }
                else 
                {
                    UINT32 ulBuffLen = strlen(pszData) + 64;
                    NEW_FAST_TEMP_STR(pszControlString, 512, ulBuffLen); 
                    SafeSprintf(pszControlString,512,"a=control:%s%s", pszData,
                            pszEOL);
                
                    mDesc += pszControlString;
                    DELETE_FAST_TEMP_STR(pszControlString);
                }

                HX_VECTOR_DELETE(pszData);
            }
            else if (bStreamNumberFound)
            {
                if (pContentBase || pQueryParams)
                {
                    const char* pszFieldPrefix = "a=control:";
                    const char* pszStreamLabel = "streamid=";

                    UINT32 ulBuffLen = strlen(pszFieldPrefix) + 
                                       strlen(pszStreamLabel);
                    ulBuffLen += (pContentBase) ? (pContentBase->GetSize()) : 0;
                    ulBuffLen += (pQueryParams) ? (pQueryParams->GetSize()) : 0;
                    ulBuffLen += 1;

                    NEW_FAST_TEMP_STR(pszControlField, 256, ulBuffLen);
                    SafeSprintf(pszControlField, 256,"%s%s%s%d%s%s", 
                            pszFieldPrefix, 
                            (pContentBase)? ((char*)pContentBase->GetBuffer()) : "",
                            pszStreamLabel, streamNumber, 
                            (pQueryParams)? ((char*)pQueryParams->GetBuffer()) : "",
                            pszEOL);

                    mDesc += pszControlField;
                    DELETE_FAST_TEMP_STR(pszControlField);
                }
                else
                {
                    SafeSprintf(psz256, 256,"a=control:streamid=%d%s", streamNumber, pszEOL); 
                    mDesc += psz256;
                }
            }

            // a=length && a=range
            if (bDurationFound)
            {
                NPTime npTime(duration);

                if (!bIsLive)
                {
                    SafeSprintf(psz256,256, "a=range:npt=0-%s%s", (const char*)npTime, pszEOL);
                    mDesc += psz256;
                }
                
                SafeSprintf(psz256, 256, "a=length:npt=%s%s", (const char*)npTime, pszEOL);
                mDesc += psz256;
            }
            else if (bDefaultDurationFound)
            {
                // take it from file header
                NPTime npTime(ulDefaultDuration);

                if (!bIsLive)
                {
                    SafeSprintf(psz256, 256,"a=range:npt=0-%s%s", (const char*)npTime, pszEOL);