流媒体/Mpeg4/MP4

开发平台：
C/C++

SdpMedia.hxx：源码内容
							#ifndef _SDPMEDIA_H
#define _SDPMEDIA_H
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */
static const char* const SdpMediaVersion =
    "$Id: SdpMedia.hxx,v 1.22 2001/06/15 00:28:46 chok Exp $";
#include <vector>
#include <strstream>
#include <cassert>
#include "SdpExterns.hxx"
#include "SdpConnection.hxx"
#include "SdpBandwidth.hxx"
#include "SdpAttributes.hxx"
#include "SdpEncryptkey.hxx"
#include "cpLog.h"
#include "support.hxx"
///
enum SdpMediaType
{
    MediaTypeUnknown,
    MediaTypeAudio,
    MediaTypeVideo
};
/** Session Media
  * m=<media> <port> <transport> <fmt list> 
  * 
  * Besides the fields above, this class really holds the media block,
  * i.e. not just the "m=" line but all lines followed until next "m=" line
  */
class SdpMedia
{
    public:
        ///
        SdpMedia();
        ///
        SdpMedia(split_t& mediaDetails);
        ///
        SdpMediaType getMediaType()
        {
            return mediaType;
        }
        ///
        string getMediaTypeString()
        {
            return mediaTypeString;
        }
        ///
        void setMediaType( SdpMediaType newType );
        ///
        void setMediaType( string newType );
        ///
        int getPort()
        {
            return port;
        }
        ///
        void setPort(int newport)
        {
            port = newport;
        }
        ///
        int getNumPorts()
        {
            return numPorts;
        }
        ///
        void setNumPorts(int newnumPorts)
        {
            numPorts = newnumPorts;
        }
        ///
        TransportType getTransportType()
        {
            return transportType;
        }
        ///
        void setTransportType(TransportType newtransport);
        ///
        void addFormat( string fmt )
        {
            formatList.push_back( fmt );
            char format[ MaxFormatIntValue+1 ];
            format[ MaxFormatIntValue ] = '';
            strncpy( format, fmt.c_str(), MaxFormatIntValue );
            char* endPtr = 0;
            int formatInt = 0;
            formatInt = strtol( format, &endPtr, 10 );
            if( endPtr != format )    // Format is an integer
            {
                formatListInt.push_back( formatInt );
            }
        }
        /// deprecated
        void addFormat(int fmt)
        {
            formatList.push_back( itos( fmt ) );
            formatListInt.push_back( fmt );
        }
        ///
        vector < string > * getStringFormatList()
        {
            if (formatList.size() > 0) return &formatList;
            else return 0;
        }
        /// deprecated
        vector < int > * getFormatList()
        {
            if (formatListInt.size() > 0) return &formatListInt;
            else return 0;
        }
        ///
        void clearFormatList()
        {
            formatList.clear();
            formatListInt.clear();
        }
        ///
        MediaAttributes* getMediaAttributes()
        {
            return mediaAttrib;
        }
        ///
        void setMediaAttributes(MediaAttributes* attributes)
        {
            mediaAttrib = attributes;
        };
        ///
        SdpConnection* getConnection()
        {
            return connection;
        }
        ///
        void setConnection(const SdpConnection& conn) 
        { 
            if (!connection)
            {
                connection = new SdpConnection;
            }
            *connection = conn;
        }
        ///
        SdpBandwidth* getBandwidth()
        {
            return bandwidth;
        }
        ///
        SdpEncryptkey* getEncryptkey()
        {
            return encryptkey;
        }
        ///
        string getMediaInfo()
        {
            return mediaInfo;
        }
        ///
        void setMediaInfo(const string& info)
        {
            mediaInfo = info;
        }
        ///
        const SdpMedia& operator=(SdpMedia& media);
        ~SdpMedia()
        {
            if (mediaAttrib)
            {
                delete mediaAttrib;
            }
            if (connection)
            {
                delete connection;
            }
            if (bandwidth)
            {
                delete bandwidth;
            }
            if (encryptkey)
            {
                delete encryptkey;
            }
        }
        ///
        void encode (ostrstream& s);
    private:
	/// disable copy constructor
	SdpMedia(const SdpMedia&);
        ///
        string transportTypeString();
        ///
        void encodeMediaAnnouncement (ostrstream& s);
        SdpMediaType mediaType;
        string mediaTypeString;
        int port;
        int numPorts;
        TransportType transportType;     // RTP/AVP or UDP
        vector < string > formatList;
        vector < int > formatListInt;    // deprecated
        //maintain the MediaAttribute.
        MediaAttributes* mediaAttrib;
        //maintain the connection address in the c line.
        SdpConnection* connection;
        //maintain the bandwidth
        SdpBandwidth* bandwidth;
        //maintain the encryption key
        SdpEncryptkey* encryptkey;
        //maintain the media information
        string mediaInfo;
        ///
        static const int MaxFormatIntValue = 15;
};
#endif

						