sdp.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2026 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "noncopyable.h"
#include "media/media_codec.h"
#include "media/media_attribute.h"
 
#include <dhtnet/ip_utils.h>
#include <dhtnet/ice_transport.h>
 
#include <pjmedia/sdp.h>
#include <pjmedia/sdp_neg.h>
#include <pjsip/sip_transport.h>
#include <pjlib.h>
#include <pjsip_ua.h>
#include <pjmedia/errno.h>
#include <pj/pool.h>
#include <pj/assert.h>
 
#include <vector>
#include <string>
#include <stdexcept>
 
namespace jami {
 
namespace test {
class SDPTest;
}
 
class AudioCodec;
 
class SdpException : public std::runtime_error
{
public:
    SdpException(const std::string& str = "")
        : std::runtime_error("SDP: SdpException occurred: " + str)
    {}
};
 
enum class SdpDirection : uint8_t { OFFER, ANSWER, NONE };
 
class Sdp
{
public:
    /*
     * Class Constructor.
     *
     * @param memory pool
     */
    Sdp(const std::string& id);
 
    ~Sdp();
 
    void setLocalMediaCapabilities(MediaType type, const std::vector<std::shared_ptr<SystemCodecInfo>>& selectedCodecs);
 
    pjmedia_sdp_session* getLocalSdpSession() { return localSession_; }
 
    const pjmedia_sdp_session* getActiveLocalSdpSession() const { return activeLocalSession_; }
 
    pjmedia_sdp_session* getRemoteSdpSession() { return remoteSession_; }
 
    const pjmedia_sdp_session* getActiveRemoteSdpSession() const { return activeRemoteSession_; }
 
    void setActiveLocalSdpSession(const pjmedia_sdp_session* sdp);
 
    void setActiveRemoteSdpSession(const pjmedia_sdp_session* sdp);
 
    /*
     * On building an invite outside a dialog, build the local offer and create the
     * SDP negotiator instance with it.
     * @returns true if offer was created, false otherwise
     */
    bool createOffer(const std::vector<MediaAttribute>& mediaList);
 
    void setReceivedOffer(const pjmedia_sdp_session* remote);
 
    bool processIncomingOffer(const std::vector<MediaAttribute>& mediaList);
 
    bool startNegotiation();
 
    void cleanSessionMedia();
 
    /*
     * Write accessor. Set the local IP address that will be used in the sdp session
     */
    void setPublishedIP(const std::string& addr, pj_uint16_t addr_type = pj_AF_UNSPEC());
    void setPublishedIP(const dhtnet::IpAddr& addr);
 
    /*
     * Read accessor. Get the local IP address
     */
    dhtnet::IpAddr getPublishedIPAddr() const { return std::string_view(publishedIpAddr_); }
 
    std::string_view getPublishedIP() const { return publishedIpAddr_; }
 
    void setLocalPublishedAudioPorts(uint16_t audio_port, uint16_t control_port)
    {
        localAudioRtpPort_ = audio_port;
        localAudioRtcpPort_ = control_port;
    }
 
    void setLocalPublishedVideoPorts(uint16_t video_port, uint16_t control_port)
    {
        localVideoRtpPort_ = video_port;
        localVideoRtcpPort_ = control_port;
    }
 
    uint16_t getLocalVideoPort() const { return localVideoRtpPort_; }
 
    uint16_t getLocalVideoControlPort() const { return localVideoRtcpPort_; }
 
    uint16_t getLocalAudioPort() const { return localAudioRtpPort_; }
 
    uint16_t getLocalAudioControlPort() const { return localAudioRtcpPort_; }
 
    std::vector<MediaDescription> getActiveMediaDescription(bool remote) const;
 
    std::vector<MediaDescription> getMediaDescriptions(const pjmedia_sdp_session* session, bool remote) const;
 
    static std::vector<MediaAttribute> getMediaAttributeListFromSdp(const pjmedia_sdp_session* sdpSession,
                                                                    bool ignoreDisabled = false);
 
    using MediaSlot = std::pair<MediaDescription, MediaDescription>;
    std::vector<MediaSlot> getMediaSlots() const;
 
    unsigned int getTelephoneEventType() const { return telephoneEventPayload_; }
 
    void addIceAttributes(const dhtnet::IceTransport::Attribute&& ice_attrs);
    dhtnet::IceTransport::Attribute getIceAttributes() const;
    static dhtnet::IceTransport::Attribute getIceAttributes(const pjmedia_sdp_session* session);
 
    void addIceCandidates(unsigned media_index, const std::vector<std::string>& cands);
 
    std::vector<std::string> getIceCandidates(unsigned media_index) const;
 
    void clearIce();
 
    SdpDirection getSdpDirection() const { return sdpDirection_; };
    static constexpr std::string_view getSdpDirectionStr(SdpDirection direction);
 
    static void printSession(const pjmedia_sdp_session* session, const char* header, SdpDirection direction);
 
private:
    friend class test::SDPTest;
 
    NON_COPYABLE(Sdp);
 
    void getProfileLevelID(const pjmedia_sdp_session* session, std::string& dest, int payload) const;
 
    static std::string getFilteredSdp(const pjmedia_sdp_session* session, unsigned media_keep, unsigned pt_keep);
 
    static void clearIce(pjmedia_sdp_session* session);
 
    /*
     * Build the sdp media section
     * Add rtpmap field if necessary
     */
    pjmedia_sdp_media* addMediaDescription(const MediaAttribute& mediaAttr);
 
    // Determine media direction
    char const* mediaDirection(const MediaAttribute& mediaAttr);
 
    // Get media direction
    static MediaDirection getMediaDirection(pjmedia_sdp_media* media);
 
    // Get the transport type
    static MediaTransport getMediaTransport(pjmedia_sdp_media* media);
 
    // Get the crypto materials
    static std::vector<std::string> getCrypto(pjmedia_sdp_media* media);
 
    pjmedia_sdp_attr* generateSdesAttribute();
 
    void setTelephoneEventRtpmap(pjmedia_sdp_media* med);
 
    /*
     * Create a new SDP
     */
    void createLocalSession(SdpDirection direction);
 
    /*
     * Validate SDP
     */
    int validateSession() const;
 
    /*
     * Adds a sdes attribute to the given media section.
     *
     * @param media The media to add the srtp attribute to
     * @throw SdpException
     */
    void addSdesAttribute(const std::vector<std::string>& crypto);
 
    void addRTCPAttribute(pjmedia_sdp_media* med, uint16_t port);
 
    std::shared_ptr<SystemCodecInfo> findCodecByPayload(const unsigned payloadType);
    std::shared_ptr<SystemCodecInfo> findCodecBySpec(std::string_view codecName, const unsigned clockrate = 0) const;
 
    // Data members
    std::unique_ptr<pj_pool_t, std::function<void(pj_pool_t*)>> memPool_;
    pjmedia_sdp_neg* negotiator_ {nullptr};
    pjmedia_sdp_session* localSession_ {nullptr};
    pjmedia_sdp_session* remoteSession_ {nullptr};
 
    const pjmedia_sdp_session* activeLocalSession_ {nullptr};
 
    const pjmedia_sdp_session* activeRemoteSession_ {nullptr};
 
    std::vector<std::shared_ptr<SystemCodecInfo>> audio_codec_list_;
    std::vector<std::shared_ptr<SystemCodecInfo>> video_codec_list_;
 
    std::string publishedIpAddr_;
    pj_uint16_t publishedIpAddrType_;
 
    uint16_t localAudioRtpPort_ {0};
    uint16_t localAudioRtcpPort_ {0};
    uint16_t localVideoRtpPort_ {0};
    uint16_t localVideoRtcpPort_ {0};
 
    unsigned int telephoneEventPayload_;
 
    // The call Id of the SDP owner
    std::string sessionName_ {};
 
    // Offer/Answer flag.
    SdpDirection sdpDirection_ {SdpDirection::NONE};
};
 
} // namespace jami