sdp2media.hxx

Vovida 社区开源的 SIP 协议源码

#ifndef SDP2MEDIA_HXX_
#define SDP2MEDIA_HXX_

/* ====================================================================
 * 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 [e-mail].
 *
 * 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 Sdp2Media_hxx_Version =
    "$Id: Sdp2Media.hxx,v 1.4.2.1 2003/02/08 04:20:23 bko Exp $";

#include <strstream>
#include <cassert>
#include <list>
#include "Sdp2Externs.hxx"
#include "Sdp2Connection.hxx"
#include "Sdp2Bandwidth.hxx"
#include "Sdp2Attributes.hxx"
#include "Sdp2Encryptkey.hxx"

#include "cpLog.h"
#include "support.hxx"


/** Infrastructure common to VOCAL.
 */
namespace Vocal 
{


/** Infrastructure in VOCAL related to logging.<br><br>
 */
namespace SDP
{


///
enum SdpMediaType
{
    MediaTypeUnknown,
    MediaTypeAudio,
    MediaTypeVideo
};


/** 
    SdpMedia describes the media lines in an SDP.
    <p>
    <b>Example</b>
    <pre>
    m=&lt;media> &lt;port> &lt;transport> &lt;fmt list> 
    </pre>
    In addition to the m= lines, this class holds the entire media block, 
    i.e. not just the "m=" line but all lines followed until next "m=" line.
    <p>

    A complete example of usage is available in the SdpSession class
    description.<p>

    @see SdpSession

  */
class SdpMedia
{

    public:
        ///
        SdpMedia();
        ///
        SdpMedia(list<Data>& mediaDetails);

        ///
        SdpMediaType getMediaType()
        {
            return mediaType;
        }
        ///
        Data getMediaTypeString()
        {
            return mediaTypeString;
        }
        ///
        void setMediaType( SdpMediaType newType );
        ///
        void setMediaType( Data 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( Data fmt );
        /// deprecated
        void addFormat(int fmt)
        {
            formatList.push_back( itos( fmt ) );
            formatListInt.push_back( fmt );
        }
        ///
        vector < Data > * 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;
        }

        ///
        void setBandwidth(SdpBandwidth& bWidth)
        {
            delete bandwidth;
            Data aVal = bWidth.modifierString();
            aVal += ":";
            aVal += Data(bWidth.getValue());
            bandwidth = new SdpBandwidth(aVal);
        }
        ///
        SdpEncryptkey* getEncryptkey()
        {
            return encryptkey;
        }
        ///
        Data getMediaInfo()
        {
            return mediaInfo;
        }
        ///
        void setMediaInfo(const Data& 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&);
        ///
        Data transportTypeString();
        ///
        void encodeMediaAnnouncement (ostrstream& s);

        SdpMediaType mediaType;
        Data mediaTypeString;
        int port;
        int numPorts;
        TransportType transportType;     // RTP/AVP or UDP
        vector < Data > 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
        Data mediaInfo;

        ///
        static const int MaxFormatIntValue;
};


}


}


/* Local Variables: */
/* c-file-style: "stroustrup" */
/* indent-tabs-mode: nil */
/* c-file-offsets: ((access-label . -) (inclass . ++)) */
/* c-basic-offset: 4 */
/* End: */


#endif