Select Git revision
dht_proxy_client.cpp
-
Adrien Béraud authored
Use shared flags to avoid blocking for the callback while respecting the callback return value.
Adrien Béraud authoredUse shared flags to avoid blocking for the callback while respecting the callback return value.
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
sipcall.cpp 100.93 KiB
/*
* Copyright (C) 2004-2021 Savoir-faire Linux Inc.
*
* Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
* Author: Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
* Author: Yan Morin <yan.morin@savoirfairelinux.com>
* Author: Laurielle Lea <laurielle.lea@savoirfairelinux.com>
* Author: Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
* Author: Philippe Gorley <philippe.gorley@savoirfairelinux.com>
*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "call_factory.h"
#include "sipcall.h"
#include "sipaccount.h"
#include "sipaccountbase.h"
#include "sipvoiplink.h"
#include "logger.h"
#include "sdp.h"
#include "manager.h"
#include "string_utils.h"
#include "upnp/upnp_control.h"
#include "sip_utils.h"
#include "audio/audio_rtp_session.h"
#include "system_codec_container.h"
#include "im/instant_messaging.h"
#include "jami/call_const.h"
#include "jami/media_const.h"
#include "client/ring_signal.h"
#include "ice_transport.h"
#include "pjsip-ua/sip_inv.h"
#ifdef ENABLE_PLUGIN
#include "plugin/jamipluginmanager.h"
#endif
#ifdef ENABLE_VIDEO
#include "client/videomanager.h"
#include "video/video_rtp_session.h"
#include "jami/videomanager_interface.h"
#include <chrono>
#include <libavutil/display.h>
#include <video/sinkclient.h>
#endif
#include "audio/ringbufferpool.h"
#include "jamidht/channeled_transport.h"
#include "errno.h"
#include <opendht/crypto.h>
#include <opendht/thread_pool.h>
#include <fmt/ranges.h>
namespace jami {
using sip_utils::CONST_PJ_STR;
using namespace DRing::Call;
#ifdef ENABLE_VIDEO
static DeviceParams
getVideoSettings()
{
const auto& videomon = jami::getVideoDeviceMonitor();
return videomon.getDeviceParams(videomon.getDefaultDevice());
}
#endif
static constexpr std::chrono::seconds DEFAULT_ICE_INIT_TIMEOUT {35}; // seconds
static constexpr std::chrono::milliseconds EXPECTED_ICE_INIT_MAX_TIME {5000};
static constexpr std::chrono::seconds DEFAULT_ICE_NEGO_TIMEOUT {60}; // seconds
static constexpr std::chrono::milliseconds MS_BETWEEN_2_KEYFRAME_REQUEST {1000};
static constexpr int ICE_COMP_ID_RTP {1};
static constexpr int ICE_COMP_COUNT_PER_STREAM {2};
static constexpr auto MULTISTREAM_REQUIRED_VERSION_STR = "10.0.2"sv;
static const std::vector<unsigned> MULTISTREAM_REQUIRED_VERSION
= split_string_to_unsigned(MULTISTREAM_REQUIRED_VERSION_STR, '.');
SIPCall::SIPCall(const std::shared_ptr<SIPAccountBase>& account,
const std::string& callId,
Call::CallType type,
const std::map<std::string, std::string>& details)
: Call(account, callId, type, details)
, sdp_(new Sdp(callId))
, enableIce_(account->isIceForMediaEnabled())
, srtpEnabled_(account->isSrtpEnabled())
{
if (account->getUPnPActive())
upnp_.reset(new upnp::Controller());
setCallMediaLocal();
// Set the media caps.
sdp_->setLocalMediaCapabilities(MediaType::MEDIA_AUDIO,
account->getActiveAccountCodecInfoList(MEDIA_AUDIO));
#ifdef ENABLE_VIDEO
sdp_->setLocalMediaCapabilities(MediaType::MEDIA_VIDEO,
account->getActiveAccountCodecInfoList(MEDIA_VIDEO));
#endif
auto mediaAttrList = getSIPAccount()->createDefaultMediaList(getSIPAccount()->isVideoEnabled()
and not isAudioOnly(),
getState() == CallState::HOLD);
JAMI_DBG("[call:%s] Create a new [%s] SIP call with %lu media",
getCallId().c_str(),
type == Call::CallType::INCOMING
? "INCOMING"
: (type == Call::CallType::OUTGOING ? "OUTGOING" : "MISSED"),
mediaAttrList.size());
initMediaStreams(mediaAttrList);
}
SIPCall::SIPCall(const std::shared_ptr<SIPAccountBase>& account,
const std::string& callId,
Call::CallType type,
const std::vector<DRing::MediaMap>& mediaList)
: Call(account, callId, type)
, peerSupportMultiStream_(false)
, sdp_(new Sdp(callId))
, enableIce_(account->isIceForMediaEnabled())
, srtpEnabled_(account->isSrtpEnabled())
{
if (account->getUPnPActive())
upnp_.reset(new upnp::Controller());
setCallMediaLocal();
// Set the media caps. sdp_->setLocalMediaCapabilities(MediaType::MEDIA_AUDIO,
account->getActiveAccountCodecInfoList(MEDIA_AUDIO));
#ifdef ENABLE_VIDEO
sdp_->setLocalMediaCapabilities(MediaType::MEDIA_VIDEO,
account->getActiveAccountCodecInfoList(MEDIA_VIDEO));
#endif
auto mediaAttrList = MediaAttribute::buildMediaAttributesList(mediaList, isSrtpEnabled());
if (mediaAttrList.size() == 0) {
if (type_ == Call::CallType::INCOMING) {
// Handle incoming call without media offer.
JAMI_WARN(
"[call:%s] No media offered in the incoming invite. An offer will be provided in "
"the answer",
getCallId().c_str());
mediaAttrList = getSIPAccount()->createDefaultMediaList(false,
getState() == CallState::HOLD);
} else {
JAMI_WARN("[call:%s] Creating an outgoing call with empty offer", getCallId().c_str());
}
}
JAMI_DBG("[call:%s] Create a new [%s] SIP call with %lu media",
getCallId().c_str(),
type == Call::CallType::INCOMING
? "INCOMING"
: (type == Call::CallType::OUTGOING ? "OUTGOING" : "MISSED"),
mediaList.size());
initMediaStreams(mediaAttrList);
}
SIPCall::~SIPCall()
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
setTransport({});
setInviteSession(); // prevents callback usage
}
size_t
SIPCall::findRtpStreamIndex(const std::string& label) const
{
const auto iter = std::find_if(rtpStreams_.begin(),
rtpStreams_.end(),
[&label](const RtpStream& rtp) {
return label == rtp.mediaAttribute_->label_;
});
// Return the index if there is a match.
if (iter != rtpStreams_.end())
return std::distance(rtpStreams_.begin(), iter);
// No match found.
return rtpStreams_.size();
}
void
SIPCall::createRtpSession(RtpStream& stream)
{
if (not stream.mediaAttribute_)
throw std::runtime_error("Missing media attribute");
if (stream.mediaAttribute_->type_ == MediaType::MEDIA_AUDIO) {
stream.rtpSession_ = std::make_shared<AudioRtpSession>(id_);
}
#ifdef ENABLE_VIDEO
else if (stream.mediaAttribute_->type_ == MediaType::MEDIA_VIDEO) {
stream.rtpSession_ = std::make_shared<video::VideoRtpSession>(id_, getVideoSettings()); }
#endif
else {
throw std::runtime_error("Unsupported media type");
}
// Must be valid at this point.
if (not stream.rtpSession_)
throw std::runtime_error("Failed to create RTP Session");
;
}
void
SIPCall::configureRtpSession(const std::shared_ptr<RtpSession>& rtpSession,
const std::shared_ptr<MediaAttribute>& mediaAttr,
const MediaDescription& localMedia,
const MediaDescription& remoteMedia)
{
JAMI_DBG("[call:%s] Configuring [%s] rtp session",
getCallId().c_str(),
MediaAttribute::mediaTypeToString(mediaAttr->type_));
if (not rtpSession)
throw std::runtime_error("Must have a valid RTP Session");
// Configure the media stream
auto new_mtu = transport_->getTlsMtu();
rtpSession->setMtu(new_mtu);
rtpSession->updateMedia(remoteMedia, localMedia);
// Mute/un-mute media
if (mediaAttr->muted_) {
rtpSession->setMuted(true);
// TODO. Setting mute to true should be enough to mute.
// Kept for backward compatiblity.
rtpSession->setMediaSource("");
} else {
rtpSession->setMuted(false);
rtpSession->setMediaSource(mediaAttr->sourceUri_);
}
rtpSession->setSuccessfulSetupCb([w = weak()](MediaType type, bool isRemote) {
if (auto thisPtr = w.lock())
thisPtr->rtpSetupSuccess(type, isRemote);
});
#ifdef ENABLE_VIDEO
if (localMedia.type == MediaType::MEDIA_VIDEO) {
auto videoRtp = std::dynamic_pointer_cast<video::VideoRtpSession>(rtpSession);
assert(videoRtp);
videoRtp->setRequestKeyFrameCallback([w = weak()] {
runOnMainThread([w] {
if (auto thisPtr = w.lock())
thisPtr->requestKeyframe();
});
});
videoRtp->setChangeOrientationCallback([w = weak()](int angle) {
runOnMainThread([w, angle] {
if (auto thisPtr = w.lock())
thisPtr->setVideoOrientation(angle);
});
});
}
#endif
}
std::shared_ptr<SIPAccountBase>
SIPCall::getSIPAccount() const
{
return std::static_pointer_cast<SIPAccountBase>(getAccount().lock());}
#ifdef ENABLE_PLUGIN
void
SIPCall::createCallAVStreams()
{
if (hasVideo()) {
auto videoRtp = getVideoRtp();
if (not videoRtp)
return;
if (videoRtp->hasConference()) {
clearCallAVStreams();
return;
}
}
auto baseId = getCallId();
/**
* Map: maps the AudioFrame to an AVFrame
**/
auto audioMap = [](const std::shared_ptr<jami::MediaFrame>& m) -> AVFrame* {
return std::static_pointer_cast<AudioFrame>(m)->pointer();
};
auto const& audioRtp = getAudioRtp();
if (not audioRtp) {
throw std::runtime_error("Must have a valid Audio RTP Session");
}
// Preview
if (auto& localAudio = audioRtp->getAudioLocal()) {
auto previewSubject = std::make_shared<MediaStreamSubject>(audioMap);
StreamData microStreamData {baseId, false, StreamType::audio, getPeerNumber()};
createCallAVStream(microStreamData, *localAudio, previewSubject);
}
// Receive
if (auto& audioReceive = audioRtp->getAudioReceive()) {
auto receiveSubject = std::make_shared<MediaStreamSubject>(audioMap);
StreamData phoneStreamData {baseId, true, StreamType::audio, getPeerNumber()};
createCallAVStream(phoneStreamData, (AVMediaStream&) *audioReceive, receiveSubject);
}
#ifdef ENABLE_VIDEO
if (hasVideo()) {
auto videoRtp = getVideoRtp();
if (not videoRtp)
return;
// Map: maps the VideoFrame to an AVFrame
auto map = [](const std::shared_ptr<jami::MediaFrame> m) -> AVFrame* {
return std::static_pointer_cast<VideoFrame>(m)->pointer();
};
// Preview
if (auto& videoPreview = videoRtp->getVideoLocal()) {
auto previewSubject = std::make_shared<MediaStreamSubject>(map);
StreamData previewStreamData {getCallId(), false, StreamType::video, getPeerNumber()};
createCallAVStream(previewStreamData, *videoPreview, previewSubject);
}
// Receive
if (auto& videoReceive = videoRtp->getVideoReceive()) {
auto receiveSubject = std::make_shared<MediaStreamSubject>(map);
StreamData receiveStreamData {getCallId(), true, StreamType::video, getPeerNumber()};
createCallAVStream(receiveStreamData, *videoReceive, receiveSubject);
}
}
#endif
}
voidSIPCall::createCallAVStream(const StreamData& StreamData,
AVMediaStream& streamSource,
const std::shared_ptr<MediaStreamSubject>& mediaStreamSubject)
{
const std::string AVStreamId = StreamData.id + std::to_string(static_cast<int>(StreamData.type))
+ std::to_string(StreamData.direction);
std::lock_guard<std::mutex> lk(avStreamsMtx_);
auto it = callAVStreams.find(AVStreamId);
if (it != callAVStreams.end())
return;
it = callAVStreams.insert(it, {AVStreamId, mediaStreamSubject});
streamSource.attachPriorityObserver(it->second);
jami::Manager::instance()
.getJamiPluginManager()
.getCallServicesManager()
.createAVSubject(StreamData, it->second);
}
void
SIPCall::clearCallAVStreams()
{
std::lock_guard<std::mutex> lk(avStreamsMtx_);
callAVStreams.clear();
}
#endif // ENABLE_PLUGIN
void
SIPCall::setCallMediaLocal()
{
if (localAudioPort_ == 0
#ifdef ENABLE_VIDEO
|| localVideoPort_ == 0
#endif
)
generateMediaPorts();
}
void
SIPCall::generateMediaPorts()
{
auto account = getSIPAccount();
if (!account) {
JAMI_ERR("No account detected");
return;
}
// TODO. Setting specfic range for RTP ports is obsolete, in
// particular in the context of ICE.
// Reference: http://www.cs.columbia.edu/~hgs/rtp/faq.html#ports
// We only want to set ports to new values if they haven't been set
const unsigned callLocalAudioPort = account->generateAudioPort();
if (localAudioPort_ != 0)
account->releasePort(localAudioPort_);
localAudioPort_ = callLocalAudioPort;
sdp_->setLocalPublishedAudioPorts(callLocalAudioPort,
rtcpMuxEnabled_ ? 0 : callLocalAudioPort + 1);
#ifdef ENABLE_VIDEO
// https://projects.savoirfairelinux.com/issues/17498
const unsigned int callLocalVideoPort = account->generateVideoPort();
if (localVideoPort_ != 0)
account->releasePort(localVideoPort_);
// this should already be guaranteed by SIPAccount
assert(localAudioPort_ != callLocalVideoPort);
localVideoPort_ = callLocalVideoPort;
sdp_->setLocalPublishedVideoPorts(callLocalVideoPort,
rtcpMuxEnabled_ ? 0 : callLocalVideoPort + 1);
#endif
}
void
SIPCall::setContactHeader(pj_str_t contact)
{
pj_strcpy(&contactHeader_, &contact);
}
void
SIPCall::setTransport(const std::shared_ptr<SipTransport>& t)
{
if (t != transport_) {
JAMI_WARN("[call:%s] Setting tranport to [%p]", getCallId().c_str(), t.get());
}
transport_ = t;
if (not t) {
return;
}
if (isSrtpEnabled() and not transport_->isSecure()) {
JAMI_WARN("[call:%s] Crypto (SRTP) is negotiated over an un-encrypted signaling channel",
getCallId().c_str());
}
if (not isSrtpEnabled() and transport_->isSecure()) {
JAMI_WARN("[call:%s] The signaling channel is encrypted but the media is not encrypted",
getCallId().c_str());
}
const auto list_id = reinterpret_cast<uintptr_t>(this);
transport_->removeStateListener(list_id);
// listen for transport destruction
transport_->addStateListener(
list_id, [wthis_ = weak()](pjsip_transport_state state, const pjsip_transport_state_info*) {
if (auto this_ = wthis_.lock()) {
JAMI_DBG("[call:%s] SIP transport state [%i] - connection state [%u]",
this_->getCallId().c_str(),
state,
static_cast<unsigned>(this_->getConnectionState()));
// End the call if the SIP transport was shut down
auto isAlive = SipTransport::isAlive(state);
if (not isAlive and this_->getConnectionState() != ConnectionState::DISCONNECTED) {
JAMI_WARN("[call:%s] Ending call because underlying SIP transport was closed",
this_->getCallId().c_str());
this_->stopAllMedia();
this_->onFailure(ECONNRESET);
}
}
});
}
void
SIPCall::requestReinvite()
{
JAMI_DBG("[call:%s] Sending a SIP re-invite to request media change", getCallId().c_str());
if (isWaitingForIceAndMedia_) {
remainingRequest_ = Request::SwitchInput;
} else {
auto mediaList = getMediaAttributeList();
assert(not mediaList.empty());
// TODO. We should erase existing streams only after the new
// ones were successfully negotiated, and make a live switch. But
// for now, we reset all streams before creating new ones.
rtpStreams_.clear();
initMediaStreams(mediaList);
if (SIPSessionReinvite(mediaList) == PJ_SUCCESS) {
isWaitingForIceAndMedia_ = true;
}
}
}
/**
* Send a reINVITE inside an active dialog to modify its state
* Local SDP session should be modified before calling this method
*/
int
SIPCall::SIPSessionReinvite(const std::vector<MediaAttribute>& mediaAttrList)
{
assert(not mediaAttrList.empty());
std::lock_guard<std::recursive_mutex> lk {callMutex_};
// Do nothing if no invitation processed yet
if (not inviteSession_ or inviteSession_->invite_tsx)
return PJ_SUCCESS;
JAMI_DBG("[call:%s] Preparing and sending a re-invite (state=%s)",
getCallId().c_str(),
pjsip_inv_state_name(inviteSession_->state));
// Generate new ports to receive the new media stream
// LibAV doesn't discriminate SSRCs and will be confused about Seq changes on a given port
generateMediaPorts();
sdp_->clearIce();
auto acc = getSIPAccount();
if (not acc) {
JAMI_ERR("No account detected");
return !PJ_SUCCESS;
}
if (not sdp_->createOffer(mediaAttrList))
return !PJ_SUCCESS;
if (isIceEnabled()) {
createIceMediaTransport();
if (initIceMediaTransport(true))
addLocalIceAttributes();
}
pjsip_tx_data* tdata;
auto local_sdp = sdp_->getLocalSdpSession();
auto result = pjsip_inv_reinvite(inviteSession_.get(), nullptr, local_sdp, &tdata);
if (result == PJ_SUCCESS) {
if (!tdata)
return PJ_SUCCESS;
// Add user-agent header
sip_utils::addUserAgentHeader(acc->getUserAgentName(), tdata);
result = pjsip_inv_send_msg(inviteSession_.get(), tdata);
if (result == PJ_SUCCESS)
return PJ_SUCCESS;
JAMI_ERR("[call:%s] Failed to send REINVITE msg (pjsip: %s)",
getCallId().c_str(),
sip_utils::sip_strerror(result).c_str());
// Canceling internals without sending (anyways the send has just failed!)
pjsip_inv_cancel_reinvite(inviteSession_.get(), &tdata);
} else
JAMI_ERR("[call:%s] Failed to create REINVITE msg (pjsip: %s)",
getCallId().c_str(),
sip_utils::sip_strerror(result).c_str());
return !PJ_SUCCESS;
}
int
SIPCall::SIPSessionReinvite()
{
auto mediaList = getMediaAttributeList();
return SIPSessionReinvite(mediaList);
}
void
SIPCall::sendSIPInfo(std::string_view body, std::string_view subtype)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
if (not inviteSession_ or not inviteSession_->dlg)
throw VoipLinkException("Couldn't get invite dialog");
constexpr pj_str_t methodName = CONST_PJ_STR("INFO");
constexpr pj_str_t type = CONST_PJ_STR("application");
pjsip_method method;
pjsip_method_init_np(&method, (pj_str_t*) &methodName);
/* Create request message. */
pjsip_tx_data* tdata;
if (pjsip_dlg_create_request(inviteSession_->dlg, &method, -1, &tdata) != PJ_SUCCESS) {
JAMI_ERR("[call:%s] Could not create dialog", getCallId().c_str());
return;
}
/* Create "application/<subtype>" message body. */
pj_str_t content = CONST_PJ_STR(body);
pj_str_t pj_subtype = CONST_PJ_STR(subtype);
tdata->msg->body = pjsip_msg_body_create(tdata->pool, &type, &pj_subtype, &content);
if (tdata->msg->body == NULL)
pjsip_tx_data_dec_ref(tdata);
else
pjsip_dlg_send_request(inviteSession_->dlg,
tdata,
Manager::instance().sipVoIPLink().getModId(),
NULL);
}
void
SIPCall::updateRecState(bool state)
{
std::string BODY = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<media_control><vc_primitive><to_encoder>"
"<recording_state="
+ std::to_string(state)
+ "/>"
"</to_encoder></vc_primitive></media_control>";
// see https://tools.ietf.org/html/rfc5168 for XML Schema for Media Control details
JAMI_DBG("Sending recording state via SIP INFO");
try {
sendSIPInfo(BODY, "media_control+xml");
} catch (const std::exception& e) {
JAMI_ERR("Error sending recording state: %s", e.what());
}
}
void
SIPCall::requestKeyframe()
{
auto now = clock::now();
if ((now - lastKeyFrameReq_) < MS_BETWEEN_2_KEYFRAME_REQUEST
and lastKeyFrameReq_ != time_point::min())
return;
constexpr auto BODY = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" "<media_control><vc_primitive><to_encoder>"
"<picture_fast_update/>"
"</to_encoder></vc_primitive></media_control>"sv;
JAMI_DBG("Sending video keyframe request via SIP INFO");
try {
sendSIPInfo(BODY, "media_control+xml");
} catch (const std::exception& e) {
JAMI_ERR("Error sending video keyframe request: %s", e.what());
}
lastKeyFrameReq_ = now;
}
void
SIPCall::setMute(bool state)
{
std::string BODY = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<media_control><vc_primitive><to_encoder>"
"<mute_state="
+ std::to_string(state)
+ "/>"
"</to_encoder></vc_primitive></media_control>";
// see https://tools.ietf.org/html/rfc5168 for XML Schema for Media Control details
JAMI_DBG("Sending mute state via SIP INFO");
try {
sendSIPInfo(BODY, "media_control+xml");
} catch (const std::exception& e) {
JAMI_ERR("Error sending mute state: %s", e.what());
}
}
void
SIPCall::setInviteSession(pjsip_inv_session* inviteSession)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
if (inviteSession == nullptr and inviteSession_) {
JAMI_DBG("[call:%s] Delete current invite session", getCallId().c_str());
} else if (inviteSession != nullptr) {
// NOTE: The first reference of the invite session is owned by pjsip. If
// that counter goes down to zero the invite will be destroyed, and the
// unique_ptr will point freed datas. To avoid this, we increment the
// ref counter and let our unique_ptr share the ownership of the session
// with pjsip.
if (PJ_SUCCESS != pjsip_inv_add_ref(inviteSession)) {
JAMI_WARN("[call:%s] trying to set invalid invite session [%p]",
getCallId().c_str(),
inviteSession);
inviteSession_.reset(nullptr);
return;
}
JAMI_DBG("[call:%s] Set new invite session [%p]", getCallId().c_str(), inviteSession);
} else {
// Nothing to do.
return;
}
inviteSession_.reset(inviteSession);
}
void
SIPCall::terminateSipSession(int status)
{
JAMI_DBG("[call:%s] Terminate SIP session", getCallId().c_str());
std::lock_guard<std::recursive_mutex> lk {callMutex_};
if (inviteSession_ and inviteSession_->state != PJSIP_INV_STATE_DISCONNECTED) {
pjsip_tx_data* tdata = nullptr;
auto ret = pjsip_inv_end_session(inviteSession_.get(), status, nullptr, &tdata);
if (ret == PJ_SUCCESS) { if (tdata) {
auto account = getSIPAccount();
if (account) {
sip_utils::addContactHeader(account->getContactHeader(
transport_ ? transport_->get() : nullptr),
tdata);
// Add user-agent header
sip_utils::addUserAgentHeader(account->getUserAgentName(), tdata);
} else {
JAMI_ERR("No account detected");
std::ostringstream msg;
msg << "[call:" << getCallId().c_str() << "] "
<< "The account owning this call is invalid";
throw std::runtime_error(msg.str());
}
ret = pjsip_inv_send_msg(inviteSession_.get(), tdata);
if (ret != PJ_SUCCESS)
JAMI_ERR("[call:%s] failed to send terminate msg, SIP error (%s)",
getCallId().c_str(),
sip_utils::sip_strerror(ret).c_str());
}
} else
JAMI_ERR("[call:%s] failed to terminate INVITE@%p, SIP error (%s)",
getCallId().c_str(),
inviteSession_.get(),
sip_utils::sip_strerror(ret).c_str());
}
setInviteSession();
}
void
SIPCall::answer()
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
auto account = getSIPAccount();
if (!account) {
JAMI_ERR("No account detected");
return;
}
if (not inviteSession_)
throw VoipLinkException("[call:" + getCallId()
+ "] answer: no invite session for this call");
if (!inviteSession_->neg) {
JAMI_WARN("[call:%s] Negotiator is NULL, we've received an INVITE without an SDP",
getCallId().c_str());
Manager::instance().sipVoIPLink().createSDPOffer(inviteSession_.get());
}
setContactHeader(account->getContactHeader(transport_ ? transport_->get() : nullptr));
pjsip_tx_data* tdata;
if (!inviteSession_->last_answer)
throw std::runtime_error("Should only be called for initial answer");
// answer with SDP if no SDP was given in initial invite (i.e. inv->neg is NULL)
if (pjsip_inv_answer(inviteSession_.get(),
PJSIP_SC_OK,
NULL,
!inviteSession_->neg ? sdp_->getLocalSdpSession() : NULL,
&tdata)
!= PJ_SUCCESS)
throw std::runtime_error("Could not init invite request answer (200 OK)");
// contactStr must stay in scope as long as tdata
if (contactHeader_.slen) {
JAMI_DBG("[call:%s] Answering with contact header: %.*s", getCallId().c_str(),
(int) contactHeader_.slen,
contactHeader_.ptr);
sip_utils::addContactHeader(contactHeader_, tdata);
}
// Add user-agent header
sip_utils::addUserAgentHeader(account->getUserAgentName(), tdata);
if (pjsip_inv_send_msg(inviteSession_.get(), tdata) != PJ_SUCCESS) {
setInviteSession();
throw std::runtime_error("Could not send invite request answer (200 OK)");
}
setState(CallState::ACTIVE, ConnectionState::CONNECTED);
}
void
SIPCall::answer(const std::vector<DRing::MediaMap>& mediaList)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
auto account = getSIPAccount();
if (not account) {
JAMI_ERR("No account detected");
return;
}
auto mediaAttrList = MediaAttribute::buildMediaAttributesList(mediaList, isSrtpEnabled());
if (mediaAttrList.empty()) {
JAMI_DBG("[call:%s] Media list must not be empty!", getCallId().c_str());
return;
}
if (not inviteSession_)
JAMI_DBG("[call:%s] No invite session for this call", getCallId().c_str());
JAMI_DBG("[call:%s] Answering incoming call with %lu media:",
getCallId().c_str(),
mediaAttrList.size());
if (mediaAttrList.size() != rtpStreams_.size()) {
JAMI_ERR("[call:%s] Media list size %lu in answer does not match. Expected %lu",
getCallId().c_str(),
mediaAttrList.size(),
rtpStreams_.size());
return;
}
for (size_t idx = 0; idx < mediaAttrList.size(); idx++) {
auto const& mediaAttr = mediaAttrList.at(idx);
JAMI_DBG("[call:%s] Media @%lu: %s",
getCallId().c_str(),
idx,
mediaAttr.toString(true).c_str());
}
// Apply the media attributes provided by the user.
for (size_t idx = 0; idx < mediaAttrList.size(); idx++) {
updateMediaStream(mediaAttrList[idx], idx);
}
if (not inviteSession_)
throw VoipLinkException("[call:" + getCallId()
+ "] answer: no invite session for this call");
if (not inviteSession_->neg) {
// We are answering to an INVITE that did not include a media offer (SDP).
// The SIP specification (RFCs 3261/6337) requires that if a UA wishes to
// proceed with the call, it must provide a media offer (SDP) if the initial // INVITE did not offer one. In this case, the SDP offer will be included in
// the SIP OK (200) answer. The peer UA will then include its SDP answer in
// the SIP ACK message.
// TODO. This code should be unified with the code used by accounts to create
// SDP offers.
JAMI_WARN("[call:%s] No negotiator session, peer sent an empty INVITE (without SDP)",
getCallId().c_str());
Manager::instance().sipVoIPLink().createSDPOffer(inviteSession_.get());
generateMediaPorts();
// Setup and create ICE offer
if (isIceEnabled()) {
sdp_->clearIce();
auto opts = account->getIceOptions();
auto publicAddr = account->getPublishedIpAddress();
if (publicAddr) {
opts.accountPublicAddr = publicAddr;
if (auto interfaceAddr = ip_utils::getInterfaceAddr(account->getLocalInterface(),
publicAddr.getFamily())) {
opts.accountLocalAddr = interfaceAddr;
createIceMediaTransport();
if (initIceMediaTransport(true, std::move(opts)))
addLocalIceAttributes();
} else {
JAMI_WARN("[call:%s] Cant init ICE transport, missing local address",
getCallId().c_str());
}
} else {
JAMI_WARN("[call:%s] Cant init ICE transport, missing public address",
getCallId().c_str());
}
}
}
setContactHeader(account->getContactHeader(transport_ ? transport_->get() : nullptr));
if (!inviteSession_->last_answer)
throw std::runtime_error("Should only be called for initial answer");
// Answer with an SDP offer if the initial invite was empty,
// otherwise, set the local_sdp session to null to use the
// current SDP session.
pjsip_tx_data* tdata;
if (pjsip_inv_answer(inviteSession_.get(),
PJSIP_SC_OK,
NULL,
not inviteSession_->neg ? sdp_->getLocalSdpSession() : NULL,
&tdata)
!= PJ_SUCCESS)
throw std::runtime_error("Could not init invite request answer (200 OK)");
if (contactHeader_.slen) {
JAMI_DBG("[call:%s] Answering with contact header: %.*s",
getCallId().c_str(),
(int) contactHeader_.slen,
contactHeader_.ptr);
sip_utils::addContactHeader(contactHeader_, tdata);
}
// Add user-agent header
sip_utils::addUserAgentHeader(account->getUserAgentName(), tdata);
if (pjsip_inv_send_msg(inviteSession_.get(), tdata) != PJ_SUCCESS) { setInviteSession();
throw std::runtime_error("Could not send invite request answer (200 OK)");
}
setState(CallState::ACTIVE, ConnectionState::CONNECTED);
}
void
SIPCall::answerMediaChangeRequest(const std::vector<DRing::MediaMap>& mediaList)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
auto account = getSIPAccount();
if (not account) {
JAMI_ERR("[call:%s] No account detected", getCallId().c_str());
return;
}
auto mediaAttrList = MediaAttribute::buildMediaAttributesList(mediaList, isSrtpEnabled());
if (mediaAttrList.empty()) {
JAMI_DBG("[call:%s] Media list size is empty. Ignoring the media change request",
getCallId().c_str());
return;
}
if (not sdp_) {
JAMI_ERR("[call:%s] No valid SDP session", getCallId().c_str());
return;
}
JAMI_DBG("[call:%s] Current media", getCallId().c_str());
unsigned idx = 0;
for (auto const& rtp : rtpStreams_) {
JAMI_DBG("[call:%s] Media @%u: %s",
getCallId().c_str(),
idx++,
rtp.mediaAttribute_->toString(true).c_str());
}
JAMI_DBG("[call:%s] Answering to media change request with new media", getCallId().c_str());
idx = 0;
for (auto const& newMediaAttr : mediaAttrList) {
JAMI_DBG("[call:%s] Media @%u: %s",
getCallId().c_str(),
idx++,
newMediaAttr.toString(true).c_str());
}
updateAllMediaStreams(mediaAttrList);
if (not sdp_->processIncomingOffer(mediaAttrList)) {
JAMI_WARN("[call:%s] Could not process the new offer, ignoring", getCallId().c_str());
return;
}
if (not sdp_->getRemoteSdpSession()) {
JAMI_ERR("[call:%s] No valid remote SDP session", getCallId().c_str());
return;
}
if (isIceEnabled())
setupIceResponse();
if (not sdp_->startNegotiation()) {
JAMI_ERR("[call:%s] Could not start media negotiation for a re-invite request",
getCallId().c_str());
return;
}
if (pjsip_inv_set_sdp_answer(inviteSession_.get(), sdp_->getLocalSdpSession()) != PJ_SUCCESS) {
JAMI_ERR("[call:%s] Could not start media negotiation for a re-invite request",
getCallId().c_str());
return;
}
pjsip_tx_data* tdata;
if (pjsip_inv_answer(inviteSession_.get(), PJSIP_SC_OK, NULL, NULL, &tdata) != PJ_SUCCESS) {
JAMI_ERR("[call:%s] Could not init answer to a re-invite request", getCallId().c_str());
return;
}
if (contactHeader_.slen) {
sip_utils::addContactHeader(contactHeader_, tdata);
}
// Add user-agent header
sip_utils::addUserAgentHeader(account->getUserAgentName(), tdata);
if (pjsip_inv_send_msg(inviteSession_.get(), tdata) != PJ_SUCCESS) {
JAMI_ERR("[call:%s] Could not send answer to a re-invite request", getCallId().c_str());
setInviteSession();
return;
}
JAMI_DBG("[call:%s] Successfully answered the media change request", getCallId().c_str());
}
void
SIPCall::hangup(int reason)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
pendingRecord_ = false;
if (inviteSession_ and inviteSession_->dlg) {
pjsip_route_hdr* route = inviteSession_->dlg->route_set.next;
while (route and route != &inviteSession_->dlg->route_set) {
char buf[1024];
int printed = pjsip_hdr_print_on(route, buf, sizeof(buf));
if (printed >= 0) {
buf[printed] = '\0';
JAMI_DBG("[call:%s] Route header %s", getCallId().c_str(), buf);
}
route = route->next;
}
int status = PJSIP_SC_OK;
if (reason)
status = reason;
else if (inviteSession_->state <= PJSIP_INV_STATE_EARLY
and inviteSession_->role != PJSIP_ROLE_UAC)
status = PJSIP_SC_CALL_TSX_DOES_NOT_EXIST;
else if (inviteSession_->state >= PJSIP_INV_STATE_DISCONNECTED)
status = PJSIP_SC_DECLINE;
// Notify the peer
terminateSipSession(status);
}
// Stop all RTP streams
stopAllMedia();
setState(Call::ConnectionState::DISCONNECTED, reason);
dht::ThreadPool::io().run([w = weak()] {
if (auto shared = w.lock())
shared->removeCall();
});
}
void
SIPCall::refuse()
{ if (!isIncoming() or getConnectionState() == ConnectionState::CONNECTED or !inviteSession_)
return;
stopAllMedia();
// Notify the peer
terminateSipSession(PJSIP_SC_BUSY_HERE);
setState(Call::ConnectionState::DISCONNECTED, ECONNABORTED);
removeCall();
}
static void
transfer_client_cb(pjsip_evsub* sub, pjsip_event* event)
{
auto mod_ua_id = Manager::instance().sipVoIPLink().getModId();
switch (pjsip_evsub_get_state(sub)) {
case PJSIP_EVSUB_STATE_ACCEPTED:
if (!event)
return;
pj_assert(event->type == PJSIP_EVENT_TSX_STATE
&& event->body.tsx_state.type == PJSIP_EVENT_RX_MSG);
break;
case PJSIP_EVSUB_STATE_TERMINATED:
pjsip_evsub_set_mod_data(sub, mod_ua_id, NULL);
break;
case PJSIP_EVSUB_STATE_ACTIVE: {
if (!event)
return;
pjsip_rx_data* r_data = event->body.rx_msg.rdata;
if (!r_data)
return;
std::string request(pjsip_rx_data_get_info(r_data));
pjsip_status_line status_line = {500, *pjsip_get_status_text(500)};
if (!r_data->msg_info.msg)
return;
if (r_data->msg_info.msg->line.req.method.id == PJSIP_OTHER_METHOD
and request.find("NOTIFY") != std::string::npos) {
pjsip_msg_body* body = r_data->msg_info.msg->body;
if (!body)
return;
if (pj_stricmp2(&body->content_type.type, "message")
or pj_stricmp2(&body->content_type.subtype, "sipfrag"))
return;
if (pjsip_parse_status_line((char*) body->data, body->len, &status_line) != PJ_SUCCESS)
return;
}
if (!r_data->msg_info.cid)
return;
auto call = static_cast<SIPCall*>(pjsip_evsub_get_mod_data(sub, mod_ua_id));
if (!call)
return;
if (status_line.code / 100 == 2) {
if (call->inviteSession_) call->terminateSipSession(PJSIP_SC_GONE);
Manager::instance().hangupCall(call->getCallId());
pjsip_evsub_set_mod_data(sub, mod_ua_id, NULL);
}
break;
}
case PJSIP_EVSUB_STATE_NULL:
case PJSIP_EVSUB_STATE_SENT:
case PJSIP_EVSUB_STATE_PENDING:
case PJSIP_EVSUB_STATE_UNKNOWN:
default:
break;
}
}
bool
SIPCall::transferCommon(const pj_str_t* dst)
{
if (not inviteSession_ or not inviteSession_->dlg)
return false;
pjsip_evsub_user xfer_cb;
pj_bzero(&xfer_cb, sizeof(xfer_cb));
xfer_cb.on_evsub_state = &transfer_client_cb;
pjsip_evsub* sub;
if (pjsip_xfer_create_uac(inviteSession_->dlg, &xfer_cb, &sub) != PJ_SUCCESS)
return false;
/* Associate this voiplink of call with the client subscription
* We can not just associate call with the client subscription
* because after this function, we can no find the cooresponding
* voiplink from the call any more. But the voiplink is useful!
*/
pjsip_evsub_set_mod_data(sub, Manager::instance().sipVoIPLink().getModId(), this);
/*
* Create REFER request.
*/
pjsip_tx_data* tdata;
if (pjsip_xfer_initiate(sub, dst, &tdata) != PJ_SUCCESS)
return false;
/* Send. */
if (pjsip_xfer_send_request(sub, tdata) != PJ_SUCCESS)
return false;
return true;
}
void
SIPCall::transfer(const std::string& to)
{
auto account = getSIPAccount();
if (!account) {
JAMI_ERR("No account detected");
return;
}
if (Recordable::isRecording()) {
deinitRecorder();
stopRecording();
}
std::string toUri = account->getToUri(to);
const pj_str_t dst(CONST_PJ_STR(toUri)); JAMI_DBG("[call:%s] Transferring to %.*s", getCallId().c_str(), (int) dst.slen, dst.ptr);
if (!transferCommon(&dst))
throw VoipLinkException("Couldn't transfer");
}
bool
SIPCall::attendedTransfer(const std::string& to)
{
auto toCall = Manager::instance().callFactory.getCall<SIPCall>(to);
if (!toCall)
return false;
if (not toCall->inviteSession_ or not toCall->inviteSession_->dlg)
return false;
pjsip_dialog* target_dlg = toCall->inviteSession_->dlg;
pjsip_uri* uri = (pjsip_uri*) pjsip_uri_get_uri(target_dlg->remote.info->uri);
char str_dest_buf[PJSIP_MAX_URL_SIZE * 2] = {'<'};
pj_str_t dst = {str_dest_buf, 1};
dst.slen += pjsip_uri_print(PJSIP_URI_IN_REQ_URI,
uri,
str_dest_buf + 1,
sizeof(str_dest_buf) - 1);
dst.slen += pj_ansi_snprintf(str_dest_buf + dst.slen,
sizeof(str_dest_buf) - dst.slen,
"?"
"Replaces=%.*s"
"%%3Bto-tag%%3D%.*s"
"%%3Bfrom-tag%%3D%.*s>",
(int) target_dlg->call_id->id.slen,
target_dlg->call_id->id.ptr,
(int) target_dlg->remote.info->tag.slen,
target_dlg->remote.info->tag.ptr,
(int) target_dlg->local.info->tag.slen,
target_dlg->local.info->tag.ptr);
return transferCommon(&dst);
}
bool
SIPCall::onhold(OnReadyCb&& cb)
{
// If ICE is currently negotiating, we must wait before hold the call
if (isWaitingForIceAndMedia_) {
holdCb_ = std::move(cb);
remainingRequest_ = Request::HoldingOn;
return false;
}
auto result = hold();
if (cb)
cb(result);
return result;
}
bool
SIPCall::hold()
{
if (not setState(CallState::HOLD))
return false;
stopAllMedia();
if (getConnectionState() == ConnectionState::CONNECTED) {
if (SIPSessionReinvite() != PJ_SUCCESS) { JAMI_WARN("[call:%s] Reinvite failed", getCallId().c_str());
return true;
}
}
isWaitingForIceAndMedia_ = true;
return true;
}
bool
SIPCall::offhold(OnReadyCb&& cb)
{
// If ICE is currently negotiating, we must wait before unhold the call
if (isWaitingForIceAndMedia_) {
offHoldCb_ = std::move(cb);
remainingRequest_ = Request::HoldingOff;
return false;
}
auto result = unhold();
if (cb)
cb(result);
return result;
}
bool
SIPCall::unhold()
{
auto account = getSIPAccount();
if (!account) {
JAMI_ERR("No account detected");
return false;
}
bool success = false;
try {
success = internalOffHold([] {});
} catch (const SdpException& e) {
JAMI_ERR("[call:%s] %s", getCallId().c_str(), e.what());
throw VoipLinkException("SDP issue in offhold");
}
if (success)
isWaitingForIceAndMedia_ = true;
return success;
}
bool
SIPCall::internalOffHold(const std::function<void()>& sdp_cb)
{
if (not setState(CallState::ACTIVE))
return false;
sdp_cb();
if (getConnectionState() == ConnectionState::CONNECTED) {
if (SIPSessionReinvite() != PJ_SUCCESS) {
JAMI_WARN("[call:%s] resuming hold", getCallId().c_str());
if (isWaitingForIceAndMedia_) {
remainingRequest_ = Request::HoldingOn;
} else {
hold();
}
return false;
}
}
return true;
}
void
SIPCall::switchInput(const std::string& source)
{
JAMI_DBG("[call:%s] Set selected source to %s", getCallId().c_str(), source.c_str());
for (auto const& stream : rtpStreams_) {
auto mediaAttr = stream.mediaAttribute_;
mediaAttr->sourceUri_ = source;
}
// Check if the call is being recorded in order to continue
// ... the recording after the switch
bool isRec = Call::isRecording();
if (isWaitingForIceAndMedia_) {
remainingRequest_ = Request::SwitchInput;
} else {
if (SIPSessionReinvite() == PJ_SUCCESS) {
isWaitingForIceAndMedia_ = true;
}
}
if (isRec) {
readyToRecord_ = false;
resetMediaReady();
pendingRecord_ = true;
}
}
void
SIPCall::peerHungup()
{
pendingRecord_ = false;
// Stop all RTP streams
stopAllMedia();
if (inviteSession_)
terminateSipSession(PJSIP_SC_NOT_FOUND);
Call::peerHungup();
}
void
SIPCall::carryingDTMFdigits(char code)
{
int duration = Manager::instance().voipPreferences.getPulseLength();
char dtmf_body[1000];
int ret;
// handle flash code
if (code == '!') {
ret = snprintf(dtmf_body, sizeof dtmf_body - 1, "Signal=16\r\nDuration=%d\r\n", duration);
} else {
ret = snprintf(dtmf_body,
sizeof dtmf_body - 1,
"Signal=%c\r\nDuration=%d\r\n",
code,
duration);
}
try {
sendSIPInfo({dtmf_body, (size_t) ret}, "dtmf-relay");
} catch (const std::exception& e) {
JAMI_ERR("Error sending DTMF: %s", e.what());
}
}
voidSIPCall::setVideoOrientation(int rotation)
{
std::string sip_body = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<media_control><vc_primitive><to_encoder>"
"<device_orientation="
+ std::to_string(-rotation)
+ "/>"
"</to_encoder></vc_primitive></media_control>";
JAMI_DBG("Sending device orientation via SIP INFO %d", rotation);
sendSIPInfo(sip_body, "media_control+xml");
}
void
SIPCall::sendTextMessage(const std::map<std::string, std::string>& messages, const std::string& from)
{
std::lock_guard<std::recursive_mutex> lk {callMutex_};
// TODO: for now we ignore the "from" (the previous implementation for sending this info was
// buggy and verbose), another way to send the original message sender will be implemented
// in the future
if (not subcalls_.empty()) {
pendingOutMessages_.emplace_back(messages, from);
for (auto& c : subcalls_)
c->sendTextMessage(messages, from);
} else {
if (inviteSession_) {
try {
im::sendSipMessage(inviteSession_.get(), messages);
} catch (...) {
}
} else {
pendingOutMessages_.emplace_back(messages, from);
JAMI_ERR("[call:%s] sendTextMessage: no invite session for this call",
getCallId().c_str());
}
}
}
void
SIPCall::removeCall()
{
#ifdef ENABLE_PLUGIN
jami::Manager::instance().getJamiPluginManager().getCallServicesManager().clearCallHandlerMaps(
getCallId());
#endif
std::lock_guard<std::recursive_mutex> lk {callMutex_};
JAMI_DBG("[call:%s] removeCall()", getCallId().c_str());
if (sdp_) {
sdp_->setActiveLocalSdpSession(nullptr);
sdp_->setActiveRemoteSdpSession(nullptr);
}
Call::removeCall();
{
std::lock_guard<std::mutex> lk(transportMtx_);
resetTransport(std::move(mediaTransport_));
}
setInviteSession();
setTransport({});
}
void
SIPCall::onFailure(signed cause)
{
if (setState(CallState::MERROR, ConnectionState::DISCONNECTED, cause)) {
runOnMainThread([w = weak()] {
if (auto shared = w.lock()) {
auto& call = *shared; Manager::instance().callFailure(call);
call.removeCall();
}
});
}
}
void
SIPCall::onBusyHere()
{
if (getCallType() == CallType::OUTGOING)
setState(CallState::PEER_BUSY, ConnectionState::DISCONNECTED);
else
setState(CallState::BUSY, ConnectionState::DISCONNECTED);
runOnMainThread([w = weak()] {
if (auto shared = w.lock()) {
auto& call = *shared;
Manager::instance().callBusy(call);
call.removeCall();
}
});
}
void
SIPCall::onClosed()
{
runOnMainThread([w = weak()] {
if (auto shared = w.lock()) {
auto& call = *shared;
Manager::instance().peerHungupCall(call);
call.removeCall();
}
});
}
void
SIPCall::onAnswered()
{
JAMI_WARN("[call:%s] onAnswered()", getCallId().c_str());
runOnMainThread([w = weak()] {
if (auto shared = w.lock()) {
if (shared->getConnectionState() != ConnectionState::CONNECTED) {
shared->setState(CallState::ACTIVE, ConnectionState::CONNECTED);
if (not shared->isSubcall()) {
Manager::instance().peerAnsweredCall(*shared);
}
}
}
});
}
void
SIPCall::sendKeyframe()
{
#ifdef ENABLE_VIDEO
dht::ThreadPool::computation().run([w = weak()] {
if (auto sthis = w.lock()) {
JAMI_DBG("handling picture fast update request");
if (auto const& videoRtp = sthis->getVideoRtp()) {
videoRtp->forceKeyFrame();
}
}
});
#endif
}
bool
SIPCall::isIceEnabled() const
{ return enableIce_;
}
void
SIPCall::setPeerUaVersion(std::string_view ua)
{
if (peerUserAgent_ == ua or ua.empty()) {
// Silently ignore if it did not change or empty.
return;
}
if (peerUserAgent_.empty()) {
JAMI_DBG("[call:%s] Set peer's User-Agent to [%.*s]",
getCallId().c_str(),
(int) ua.size(),
ua.data());
} else if (not peerUserAgent_.empty()) {
// Unlikely, but should be handled since we dont have control over the peer.
// Even if it's unexpected, we still try to parse the UA version.
JAMI_WARN("[call:%s] Peer's User-Agent unexpectedly changed from [%s] to [%.*s]",
getCallId().c_str(),
peerUserAgent_.c_str(),
(int) ua.size(),
ua.data());
}
peerUserAgent_ = ua;
// User-agent parsing
constexpr std::string_view PACK_NAME(PACKAGE_NAME " ");
auto pos = ua.find(PACK_NAME);
if (pos == std::string_view::npos) {
// Must have the expected package name.
JAMI_WARN("Could not find the expected package name in peer's User-Agent");
return;
}
ua = ua.substr(pos + PACK_NAME.length());
std::string_view version;
// Unstable (un-released) versions has a hiphen + commit Id after
// the version number. Find the commit Id if any, and ignore it.
pos = ua.find('-');
if (pos != std::string_view::npos) {
// Get the version and ignore the commit ID.
version = ua.substr(0, pos);
} else {
// Extract the version number.
pos = ua.find(' ');
if (pos != std::string_view::npos) {
version = ua.substr(0, pos);
}
}
if (version.empty()) {
JAMI_DBG("[call:%s] Could not parse peer's version", getCallId().c_str());
return;
}
auto peerVersion = split_string_to_unsigned(version, '.');
if (peerVersion.size() > 4u) {
JAMI_WARN("[call:%s] Could not parse peer's version", getCallId().c_str());
return;
}
// Check if peer's version is at least 10.0.2 to enable multi-stream.
peerSupportMultiStream_ = Account::meetMinimumRequiredVersion(peerVersion,
MULTISTREAM_REQUIRED_VERSION);
if (not peerSupportMultiStream_) {
JAMI_DBG( "Peer's version [%.*s] does not support multi-stream. Min required version: [%.*s]",
(int) version.size(),
version.data(),
(int) MULTISTREAM_REQUIRED_VERSION_STR.size(),
MULTISTREAM_REQUIRED_VERSION_STR.data());
}
}
void
SIPCall::onPeerRinging()
{
JAMI_DBG("[call:%s] Peer ringing", getCallId().c_str());
setState(ConnectionState::RINGING);
}
void
SIPCall::addLocalIceAttributes()
{
if (not isIceEnabled())
return;
auto mediaTransport = getIceMedia();
if (not mediaTransport) {
JAMI_ERR("[call:%s] Invalid ICE instance", getCallId().c_str());
return;
}
auto start = std::chrono::steady_clock::now();
if (not mediaTransport->isInitialized()) {
JAMI_DBG("[call:%s] Waiting for ICE initialization", getCallId().c_str());
// we need an initialized ICE to progress further
if (mediaTransport->waitForInitialization(DEFAULT_ICE_INIT_TIMEOUT) <= 0) {
JAMI_ERR("[call:%s] ICE initialization timed out", getCallId().c_str());
return;
}
// ICE initialization may take longer than usual in some cases,
// for instance when TURN servers do not respond in time (DNS
// resolution or other issues).
auto duration = std::chrono::steady_clock::now() - start;
if (duration > EXPECTED_ICE_INIT_MAX_TIME) {
JAMI_WARN("[call:%s] ICE initialization time was unexpectedly high (%ld ms)",
getCallId().c_str(),
std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
}
}
// Check the state of ICE instance, the initialization may have failed.
if (not mediaTransport->isInitialized()) {
JAMI_ERR("[call:%s] ICE session is not initialized", getCallId().c_str());
return;
}
// Check the state, the call might have been canceled while waiting.
// for initialization.
if (getState() == Call::CallState::OVER) {
JAMI_WARN("[call:%s] The call was terminated while waiting for ICE initialization",
getCallId().c_str());
return;
}
auto account = getSIPAccount();
if (not account) {
JAMI_ERR("No account detected");
return;
}
if (not sdp_) {
JAMI_ERR("No sdp detected");
return;
}
JAMI_DBG("[call:%s] Add local attributes for ICE instance [%p]",
getCallId().c_str(),
mediaTransport.get());
sdp_->addIceAttributes(mediaTransport->getLocalAttributes());
if (account->isIceCompIdRfc5245Compliant()) {
unsigned streamIdx = 0;
for (auto const& stream : rtpStreams_) {
if (not stream.mediaAttribute_->enabled_) {
// Dont add ICE candidates if the media is disabled
JAMI_DBG("[call:%s] media [%s] @ %u is disabled, dont add local candidates",
getCallId().c_str(),
stream.mediaAttribute_->toString().c_str(),
streamIdx);
continue;
}
JAMI_DBG("[call:%s] add ICE local candidates for media [%s] @ %u",
getCallId().c_str(),
stream.mediaAttribute_->toString().c_str(),
streamIdx);
// RTP
sdp_->addIceCandidates(streamIdx,
mediaTransport->getLocalCandidates(streamIdx, ICE_COMP_ID_RTP));
// RTCP if it has its own port
if (not rtcpMuxEnabled_) {
sdp_->addIceCandidates(streamIdx,
mediaTransport->getLocalCandidates(streamIdx,
ICE_COMP_ID_RTP + 1));
}
streamIdx++;
}
} else {
unsigned idx = 0;
unsigned compId = 1;
for (auto const& stream : rtpStreams_) {
if (not stream.mediaAttribute_->enabled_) {
// Skipping local ICE candidates if the media is disabled
continue;
}
JAMI_DBG("[call:%s] add ICE local candidates for media [%s] @ %u",
getCallId().c_str(),
stream.mediaAttribute_->toString().c_str(),
idx);
// RTP
sdp_->addIceCandidates(idx, mediaTransport->getLocalCandidates(compId));
compId++;
// RTCP if it has its own port
if (not rtcpMuxEnabled_) {
sdp_->addIceCandidates(idx, mediaTransport->getLocalCandidates(compId));
compId++;
}
idx++;
}
}
}
std::vector<IceCandidate>
SIPCall::getAllRemoteCandidates(IceTransport& transport) const
{
std::vector<IceCandidate> rem_candidates;
for (unsigned mediaIdx = 0; mediaIdx < static_cast<unsigned>(rtpStreams_.size()); mediaIdx++) {
IceCandidate cand;
for (auto& line : sdp_->getIceCandidates(mediaIdx)) {
if (transport.parseIceAttributeLine(mediaIdx, line, cand)) {
JAMI_DBG("[call:%s] Add remote ICE candidate: %s", getCallId().c_str(),
line.c_str());
rem_candidates.emplace_back(std::move(cand));
}
}
}
return rem_candidates;
}
std::shared_ptr<AccountCodecInfo>
SIPCall::getVideoCodec() const
{
#ifdef ENABLE_VIDEO
if (auto const& videoRtp = getVideoRtp())
return videoRtp->getCodec();
#endif
return {};
}
std::shared_ptr<AccountCodecInfo>
SIPCall::getAudioCodec() const
{
if (auto const& audioRtp = getAudioRtp())
return audioRtp->getCodec();
return {};
}
void
SIPCall::addMediaStream(const MediaAttribute& mediaAttr)
{
// Create and add the media stream with the provided attribute.
// Do not create the RTP sessions yet.
RtpStream stream;
stream.mediaAttribute_ = std::make_shared<MediaAttribute>(mediaAttr);
// Set default media source if empty. Kept for backward compatibility.
#ifdef ENABLE_VIDEO
if (stream.mediaAttribute_->sourceUri_.empty()) {
stream.mediaAttribute_->sourceUri_
= Manager::instance().getVideoManager().videoDeviceMonitor.getMRLForDefaultDevice();
}
#endif
if (stream.mediaAttribute_->sourceType_ == MediaSourceType::NONE) {
stream.mediaAttribute_->sourceType_ = MediaSourceType::CAPTURE_DEVICE;
}
rtpStreams_.emplace_back(std::move(stream));
}
size_t
SIPCall::initMediaStreams(const std::vector<MediaAttribute>& mediaAttrList)
{
for (size_t idx = 0; idx < mediaAttrList.size(); idx++) {
auto const& mediaAttr = mediaAttrList.at(idx);
if (mediaAttr.type_ != MEDIA_AUDIO && mediaAttr.type_ != MEDIA_VIDEO) {
JAMI_ERR("[call:%s] Unexpected media type %u", getCallId().c_str(), mediaAttr.type_);
assert(false);
}
addMediaStream(mediaAttr);
auto& stream = rtpStreams_.back();
createRtpSession(stream);
JAMI_DBG("[call:%s] Added media @%lu: %s",
getCallId().c_str(),
idx,
stream.mediaAttribute_->toString(true).c_str());
}
JAMI_DBG("[call:%s] Created %lu Media streams", getCallId().c_str(), rtpStreams_.size());
return rtpStreams_.size();
}
bool
SIPCall::hasVideo() const
{
#ifdef ENABLE_VIDEO
std::function<bool(const RtpStream& stream)> videoCheck = [](auto const& stream) {
return stream.mediaAttribute_->type_ == MediaType::MEDIA_VIDEO;
};
const auto iter = std::find_if(rtpStreams_.begin(), rtpStreams_.end(), videoCheck);
return iter != rtpStreams_.end();
#else
return false;
#endif
}
bool
SIPCall::isCaptureDeviceMuted(const MediaType& mediaType) const
{
// Return true only if all media of type 'mediaType' that use capture devices
// source, are muted.
std::function<bool(const RtpStream& stream)> mutedCheck = [&mediaType](auto const& stream) {
return (stream.mediaAttribute_->type_ == mediaType
and stream.mediaAttribute_->sourceType_ == MediaSourceType::CAPTURE_DEVICE
and not stream.mediaAttribute_->muted_);
};
const auto iter = std::find_if(rtpStreams_.begin(), rtpStreams_.end(), mutedCheck);
return iter == rtpStreams_.end();
}
void
SIPCall::updateNegotiatedMedia()
{
JAMI_DBG("[call:%s] updating negotiated media", getCallId().c_str());
if (not transport_ or not sdp_) {
JAMI_ERR("[call:%s] the call is in invalid state", getCallId().c_str());
return;
}
auto slots = sdp_->getMediaSlots();
bool peer_holding {true};
int streamIdx = -1;
for (const auto& slot : slots) {
streamIdx++;
const auto& local = slot.first;
const auto& remote = slot.second;
// Skip disabled media
if (not local.enabled) {
JAMI_DBG("[call:%s] [SDP:slot#%u] The media is disabled, skipping",
getCallId().c_str(),
streamIdx);
continue;
}
if (static_cast<size_t>(streamIdx) >= rtpStreams_.size()) {
throw std::runtime_error("Stream index is out-of-range");
}
auto const& rtpStream = rtpStreams_[streamIdx];
if (not rtpStream.mediaAttribute_) {
throw std::runtime_error("Missing media attribute"); }
// To enable a media, it must be enabled on both sides.
rtpStream.mediaAttribute_->enabled_ = local.enabled and remote.enabled;
if (not rtpStream.rtpSession_)
throw std::runtime_error("Must have a valid RTP Session");
if (local.type != MEDIA_AUDIO && local.type != MEDIA_VIDEO) {
JAMI_ERR("[call:%s] Unexpected media type %u", getCallId().c_str(), local.type);
throw std::runtime_error("Invalid media attribute");
}
if (local.type != remote.type) {
JAMI_ERR("[call:%s] [SDP:slot#%u] Inconsistent media type between local and remote",
getCallId().c_str(),
streamIdx);
continue;
}
if (local.enabled and not local.codec) {
JAMI_WARN("[call:%s] [SDP:slot#%u] Missing local codec", getCallId().c_str(), streamIdx);
continue;
}
if (remote.enabled and not remote.codec) {
JAMI_WARN("[call:%s] [SDP:slot#%u] Missing remote codec",
getCallId().c_str(),
streamIdx);
continue;
}
if (isSrtpEnabled() and local.enabled and not local.crypto) {
JAMI_WARN("[call:%s] [SDP:slot#%u] Secure mode but no local crypto attributes. "
"Ignoring the media",
getCallId().c_str(),
streamIdx);
continue;
}
if (isSrtpEnabled() and remote.enabled and not remote.crypto) {
JAMI_WARN("[call:%s] [SDP:slot#%u] Secure mode but no crypto remote attributes. "
"Ignoring the media",
getCallId().c_str(),
streamIdx);
continue;
}
// Aggregate holding info over all remote streams
peer_holding &= remote.onHold;
configureRtpSession(rtpStream.rtpSession_, rtpStream.mediaAttribute_, local, remote);
}
if (not isSubcall() and peerHolding_ != peer_holding) {
peerHolding_ = peer_holding;
emitSignal<DRing::CallSignal::PeerHold>(getCallId(), peerHolding_);
}
// Notify using the parent Id if it's a subcall.
auto callId = isSubcall() ? parent_->getCallId() : getCallId();
emitSignal<DRing::CallSignal::MediaNegotiationStatus>(
callId,
DRing::Media::MediaNegotiationStatusEvents::NEGOTIATION_SUCCESS,
MediaAttribute::mediaAttributesToMediaMaps(getMediaAttributeList()));
}
void
SIPCall::startAllMedia()
{ JAMI_DBG("[call:%s] starting the media", getCallId().c_str());
if (not transport_ or not sdp_) {
JAMI_ERR("[call:%s] the call is in invalid state", getCallId().c_str());
return;
}
if (isSrtpEnabled() && not transport_->isSecure()) {
JAMI_WARN("[call:%s] Crypto (SRTP) is negotiated over an insecure signaling transport",
getCallId().c_str());
}
// reset
readyToRecord_ = false;
resetMediaReady();
#ifdef ENABLE_VIDEO
bool isVideoEnabled = false;
#endif
int currentCompId = 1;
for (auto iter = rtpStreams_.begin(); iter != rtpStreams_.end(); iter++) {
if (not iter->mediaAttribute_) {
throw std::runtime_error("Missing media attribute");
}
#ifdef ENABLE_VIDEO
if (iter->mediaAttribute_->type_ == MEDIA_VIDEO)
isVideoEnabled |= iter->mediaAttribute_->enabled_;
#endif
// Not restarting media loop on hold as it's a huge waste of CPU ressources
// because of the audio loop
if (getState() != CallState::HOLD) {
if (isIceRunning()) {
// Create sockets for RTP and RTCP, and start the session.
auto iceRtpSocket = newIceSocket(currentCompId++);
std::unique_ptr<IceSocket> iceRtcpSocket;
if (not rtcpMuxEnabled_) {
iceRtcpSocket = newIceSocket(currentCompId++);
}
iter->rtpSession_->start(std::move(iceRtpSocket), std::move(iceRtcpSocket));
} else {
iter->rtpSession_->start(nullptr, nullptr);
}
}
}
#ifdef ENABLE_VIDEO
// TODO. Move this elsewhere (when adding participant to conf?)
if (!isVideoEnabled && !getConfId().empty()) {
auto conference = Manager::instance().getConferenceFromID(getConfId());
conference->attachVideo(getReceiveVideoFrameActiveWriter().get(), getCallId());
}
#endif
// Media is restarted, we can process the last holding request.
isWaitingForIceAndMedia_ = false;
if (remainingRequest_ != Request::NoRequest) {
bool result = true;
switch (remainingRequest_) {
case Request::HoldingOn:
result = hold();
if (holdCb_) {
holdCb_(result);
holdCb_ = nullptr;
}
break;
case Request::HoldingOff: result = unhold();
if (offHoldCb_) {
offHoldCb_(result);
offHoldCb_ = nullptr;
}
break;
case Request::SwitchInput:
SIPSessionReinvite();
break;
default:
break;
}
remainingRequest_ = Request::NoRequest;
}
#ifdef ENABLE_PLUGIN
// Create AVStreams associated with the call
createCallAVStreams();
#endif
}
void
SIPCall::restartMediaSender()
{
JAMI_DBG("[call:%s] restarting TX media streams", getCallId().c_str());
auto const& audioRtp = getAudioRtp();
if (audioRtp)
audioRtp->restartSender();
#ifdef ENABLE_VIDEO
if (hasVideo()) {
auto const& videoRtp = getVideoRtp();
if (videoRtp)
videoRtp->restartSender();
}
#endif
}
void
SIPCall::stopAllMedia()
{
JAMI_DBG("[call:%s] stopping all medias", getCallId().c_str());
if (Recordable::isRecording()) {
deinitRecorder();
stopRecording(); // if call stops, finish recording
}
auto const& audioRtp = getAudioRtp();
if (audioRtp)
audioRtp->stop();
#ifdef ENABLE_VIDEO
auto const& videoRtp = getVideoRtp();
{
std::lock_guard<std::mutex> lk(sinksMtx_);
for (auto it = callSinksMap_.begin(); it != callSinksMap_.end();) {
auto& videoReceive = videoRtp->getVideoReceive();
if (videoReceive) {
videoReceive->detach(it->second.get());
}
it->second->stop();
it = callSinksMap_.erase(it);
}
}
if (videoRtp)
videoRtp->stop();
#endif
#ifdef ENABLE_PLUGIN {
clearCallAVStreams();
std::lock_guard<std::mutex> lk(avStreamsMtx_);
Manager::instance().getJamiPluginManager().getCallServicesManager().clearAVSubject(
getCallId());
}
#endif
}
void
SIPCall::muteMedia(const std::string& mediaType, bool mute)
{
auto type = MediaAttribute::stringToMediaType(mediaType);
if (type == MediaType::MEDIA_AUDIO) {
JAMI_WARN("[call:%s] %s all audio medias",
getCallId().c_str(),
mute ? "muting " : "un-muting ");
} else if (type == MediaType::MEDIA_VIDEO) {
JAMI_WARN("[call:%s] %s all video medias",
getCallId().c_str(),
mute ? "muting" : "un-muting");
} else {
JAMI_ERR("[call:%s] invalid media type %s", getCallId().c_str(), mediaType.c_str());
assert(false);
}
// Get the current media attributes.
auto mediaList = getMediaAttributeList();
// Mute/Un-mute all medias with matching type.
for (auto& mediaAttr : mediaList) {
if (mediaAttr.type_ == type) {
mediaAttr.muted_ = mute;
}
}
// Apply
requestMediaChange(MediaAttribute::mediaAttributesToMediaMaps(mediaList));
}
void
SIPCall::updateMediaStream(const MediaAttribute& newMediaAttr, size_t streamIdx)
{
assert(streamIdx < rtpStreams_.size());
auto const& rtpStream = rtpStreams_[streamIdx];
assert(rtpStream.rtpSession_);
auto const& mediaAttr = rtpStream.mediaAttribute_;
assert(mediaAttr);
bool notify = false;
if (newMediaAttr.muted_ == mediaAttr->muted_) {
// Nothing to do. Already in the desired state.
JAMI_DBG("[call:%s] [%s] already %s",
getCallId().c_str(),
mediaAttr->label_.c_str(),
mediaAttr->muted_ ? "muted " : "un-muted ");
} else {
notify = true;
}
// Update
mediaAttr->muted_ = newMediaAttr.muted_;
// Only update source and type if actually set.
if (not newMediaAttr.sourceUri_.empty()) mediaAttr->sourceUri_ = newMediaAttr.sourceUri_;
if (newMediaAttr.sourceType_ != MediaSourceType::NONE)
mediaAttr->sourceType_ = newMediaAttr.sourceType_;
JAMI_DBG("[call:%s] %s [%s]",
getCallId().c_str(),
mediaAttr->muted_ ? "muting" : "un-muting",
mediaAttr->label_.c_str());
if (notify and mediaAttr->type_ == MediaType::MEDIA_AUDIO) {
rtpStream.rtpSession_->setMuted(mediaAttr->muted_);
setMute(mediaAttr->muted_);
if (not isSubcall())
emitSignal<DRing::CallSignal::AudioMuted>(getCallId(), mediaAttr->muted_);
return;
}
#ifdef ENABLE_VIDEO
if (notify and mediaAttr->type_ == MediaType::MEDIA_VIDEO and not isSubcall()) {
emitSignal<DRing::CallSignal::VideoMuted>(getCallId(), mediaAttr->muted_);
}
#endif
}
void
SIPCall::updateAllMediaStreams(const std::vector<MediaAttribute>& mediaAttrList)
{
JAMI_DBG("[call:%s] New local medias", getCallId().c_str());
unsigned idx = 0;
for (auto const& newMediaAttr : mediaAttrList) {
JAMI_DBG("[call:%s] Media @%u: %s",
getCallId().c_str(),
idx++,
newMediaAttr.toString(true).c_str());
}
JAMI_DBG("[call:%s] Updating local media streams", getCallId().c_str());
for (auto const& newAttr : mediaAttrList) {
auto streamIdx = findRtpStreamIndex(newAttr.label_);
if (streamIdx == rtpStreams_.size()) {
// Media does not exist, add a new one.
addMediaStream(newAttr);
auto& stream = rtpStreams_.back();
createRtpSession(stream);
JAMI_DBG("[call:%s] Added a new media stream [%s] @ index %lu",
getCallId().c_str(),
stream.mediaAttribute_->label_.c_str(),
streamIdx);
} else {
updateMediaStream(newAttr, streamIdx);
}
}
}
bool
SIPCall::isReinviteRequired(const std::vector<MediaAttribute>& mediaAttrList)
{
if (mediaAttrList.size() != rtpStreams_.size())
return true;
for (auto const& newAttr : mediaAttrList) {
auto streamIdx = findRtpStreamIndex(newAttr.label_);
if (streamIdx == rtpStreams_.size()) {
// Always needs a reinvite when a new media is added.
return true;
}
#ifdef ENABLE_VIDEO
if (newAttr.type_ == MediaType::MEDIA_VIDEO) {
assert(rtpStreams_[streamIdx].mediaAttribute_);
// Changes in video attributes always trigger a re-invite.
return newAttr.muted_ != rtpStreams_[streamIdx].mediaAttribute_->muted_;
}
#endif
}
return false;
}
bool
SIPCall::requestMediaChange(const std::vector<DRing::MediaMap>& mediaList)
{
auto mediaAttrList = MediaAttribute::buildMediaAttributesList(mediaList, isSrtpEnabled());
// If the peer does not support multi-stream and the size of the new
// media list is different from the current media list, the media
// change request will be ignored.
if (not peerSupportMultiStream_ and rtpStreams_.size() != mediaAttrList.size()) {
JAMI_WARN("[call:%s] Peer does not support multi-stream. Media change request ignored",
getCallId().c_str());
return false;
}
JAMI_DBG("[call:%s] Requesting media change. List of new media:", getCallId().c_str());
unsigned idx = 0;
for (auto const& newMediaAttr : mediaAttrList) {
JAMI_DBG("[call:%s] Media @%u: %s",
getCallId().c_str(),
idx++,
newMediaAttr.toString(true).c_str());
}
auto needReinvite = isReinviteRequired(mediaAttrList);
updateAllMediaStreams(mediaAttrList);
if (needReinvite) {
JAMI_DBG("[call:%s] Media change requires a new negotiation (re-invite)",
getCallId().c_str());
requestReinvite();
}
return true;
}
std::vector<MediaAttribute>
SIPCall::getMediaAttributeList() const
{
std::vector<MediaAttribute> mediaList;
mediaList.reserve(rtpStreams_.size());
for (auto const& stream : rtpStreams_) {
mediaList.emplace_back(*stream.mediaAttribute_);
}
return mediaList;
}
/// \brief Prepare media transport and launch media stream based on negotiated SDP
///
/// This method has to be called by link (ie SipVoIpLink) when SDP is negotiated and
/// media streams structures are knows.
/// In case of ICE transport used, the medias streams are launched asynchronously when
/// the transport is negotiated.
void
SIPCall::onMediaNegotiationComplete()
{ JAMI_WARN("[call:%s] Media negotiation complete", getCallId().c_str());
// Main call (no subcalls) must wait for ICE now, the rest of code needs to access
// to a negotiated transport.
runOnMainThread([w = weak()] {
if (auto this_ = w.lock()) {
std::lock_guard<std::recursive_mutex> lk {this_->callMutex_};
JAMI_WARN("[call:%s] media changed", this_->getCallId().c_str());
// The call is already ended, so we don't need to restart medias
if (not this_->inviteSession_
or this_->inviteSession_->state == PJSIP_INV_STATE_DISCONNECTED
or not this_->sdp_) {
return;
}
bool hasIce = this_->isIceEnabled();
if (hasIce) {
// If ICE is not used, start medias now
auto rem_ice_attrs = this_->sdp_->getIceAttributes();
hasIce = not rem_ice_attrs.ufrag.empty() and not rem_ice_attrs.pwd.empty();
}
if (hasIce) {
if (not this_->isSubcall()) {
// Start ICE checks. Media will be started once ICE checks complete.
this_->startIceMedia();
}
} else {
// No ICE, start media now.
JAMI_WARN("[call:%s] ICE media disabled, using default media ports",
this_->getCallId().c_str());
// Update the negotiated media.
this_->updateNegotiatedMedia();
// Start the media.
this_->stopAllMedia();
this_->startAllMedia();
}
}
});
}
void
SIPCall::startIceMedia()
{
JAMI_DBG("[call:%s] Starting ICE", getCallId().c_str());
auto mediaTransport = getIceMedia();
if (not mediaTransport or mediaTransport->isFailed()) {
JAMI_ERR("[call:%s] Media ICE init failed", getCallId().c_str());
onFailure(EIO);
return;
}
if (mediaTransport->isStarted()) {
// NOTE: for incoming calls, the ice is already there and running
if (mediaTransport->isRunning())
onIceNegoSucceed();
return;
}
if (not mediaTransport->isInitialized()) {
// In this case, onInitDone will occurs after the startIceMedia
waitForIceInit_ = true;
return;
}
// Start transport on SDP data and wait for negotiation
if (!sdp_)
return;
auto rem_ice_attrs = sdp_->getIceAttributes(); if (rem_ice_attrs.ufrag.empty() or rem_ice_attrs.pwd.empty()) {
JAMI_ERR("[call:%s] Media ICE attributes empty", getCallId().c_str());
onFailure(EIO);
return;
}
if (not mediaTransport->startIce(rem_ice_attrs, getAllRemoteCandidates(*mediaTransport))) {
JAMI_ERR("[call:%s] Media ICE start failed", getCallId().c_str());
onFailure(EIO);
}
}
void
SIPCall::onIceNegoSucceed()
{
JAMI_DBG("[call:%s] ICE negotiation succeeded", getCallId().c_str());
// Check if the call is already ended, so we don't need to restart medias
// This is typically the case in a multi-device context where one device
// can stop a call. So do not start medias
if (not inviteSession_ or inviteSession_->state == PJSIP_INV_STATE_DISCONNECTED or not sdp_) {
JAMI_ERR("[call:%s] ICE negotiation succeeded, but call is in invalid state",
getCallId().c_str());
return;
}
// Update the negotiated media.
updateNegotiatedMedia();
// Nego succeed: move to the new media transport
stopAllMedia();
startAllMedia();
}
pj_status_t
SIPCall::onReceiveReinvite(const pjmedia_sdp_session* offer, pjsip_rx_data* rdata)
{
JAMI_DBG("[call:%s] Received a re-invite", getCallId().c_str());
pj_status_t res = PJ_SUCCESS;
if (not sdp_) {
JAMI_ERR("SDP session is invalid");
return res;
}
sdp_->clearIce();
auto acc = getSIPAccount();
if (not acc) {
JAMI_ERR("No account detected");
return res;
}
Sdp::printSession(offer, "Remote session (media change request)", SdpDirection::OFFER);
sdp_->setReceivedOffer(offer);
auto const& mediaAttrList = Sdp::getMediaAttributeListFromSdp(offer);
if (mediaAttrList.empty()) {
JAMI_WARN("[call:%s] Media list is empty, ignoring", getCallId().c_str());
return res;
}
if (upnp_) {
openPortsUPnP();
}
pjsip_tx_data* tdata = nullptr;
if (pjsip_inv_initial_answer(inviteSession_.get(), rdata, PJSIP_SC_TRYING, NULL, NULL, &tdata)
!= PJ_SUCCESS) { JAMI_ERR("Could not create answer TRYING");
return res;
}
// Report the change request.
auto const& remoteMediaList = MediaAttribute::mediaAttributesToMediaMaps(mediaAttrList);
// TODO_MC. Validate this assessment.
// Report re-invites only if the number of media changed, otherwise answer
// using the current local attributes.
if (acc->isMultiStreamEnabled() and remoteMediaList.size() != rtpStreams_.size()) {
Manager::instance().mediaChangeRequested(getCallId(), getAccountId(), remoteMediaList);
} else {
auto localMediaList = MediaAttribute::mediaAttributesToMediaMaps(getMediaAttributeList());
answerMediaChangeRequest(localMediaList);
}
return res;
}
int
SIPCall::onReceiveOffer(const pjmedia_sdp_session* offer, const pjsip_rx_data* rdata)
{
if (!sdp_)
return !PJ_SUCCESS;
sdp_->clearIce();
auto acc = getSIPAccount();
if (!acc) {
JAMI_ERR("No account detected");
return !PJ_SUCCESS;
}
JAMI_DBG("[call:%s] Received a new offer (re-invite)", getCallId().c_str());
sdp_->setReceivedOffer(offer);
// Use current media list.
sdp_->processIncomingOffer(getMediaAttributeList());
if (isIceEnabled() and offer != nullptr) {
setupIceResponse();
}
sdp_->startNegotiation();
pjsip_tx_data* tdata = nullptr;
if (pjsip_inv_initial_answer(inviteSession_.get(),
const_cast<pjsip_rx_data*>(rdata),
PJSIP_SC_OK,
NULL,
NULL,
&tdata)
!= PJ_SUCCESS) {
JAMI_ERR("Could not create initial answer OK");
return !PJ_SUCCESS;
}
// Add user-agent header
sip_utils::addUserAgentHeader(getSIPAccount()->getUserAgentName(), tdata);
if (pjsip_inv_answer(inviteSession_.get(), PJSIP_SC_OK, NULL, sdp_->getLocalSdpSession(), &tdata)
!= PJ_SUCCESS) {
JAMI_ERR("Could not create answer OK");
return !PJ_SUCCESS;
}
// ContactStr must stay in scope as long as tdata
sip_utils::addContactHeader(getSIPAccount()->getContactHeader(getTransport()->get()), tdata);
if (pjsip_inv_send_msg(inviteSession_.get(), tdata) != PJ_SUCCESS) { JAMI_ERR("Could not send msg OK");
return !PJ_SUCCESS;
}
if (upnp_) {
openPortsUPnP();
}
return PJ_SUCCESS;
}
void
SIPCall::onReceiveOfferIn200OK(const pjmedia_sdp_session* offer)
{
if (not rtpStreams_.empty()) {
JAMI_ERR("[call:%s] Unexpected offer in '200 OK' answer", getCallId().c_str());
return;
}
auto acc = getSIPAccount();
if (not acc) {
JAMI_ERR("No account detected");
return;
}
if (not sdp_) {
JAMI_ERR("invalid SDP session");
return;
}
JAMI_DBG("[call:%s] Received an offer in '200 OK' answer", getCallId().c_str());
auto mediaList = Sdp::getMediaAttributeListFromSdp(offer);
// If this method is called, it means we are expecting an offer
// in the 200OK answer.
if (mediaList.empty()) {
JAMI_WARN("[call:%s] Remote media list is empty, ignoring", getCallId().c_str());
return;
}
Sdp::printSession(offer, "Remote session (offer in 200 OK answer)", SdpDirection::OFFER);
sdp_->clearIce();
sdp_->setReceivedOffer(offer);
// If we send an empty offer, video will be accepted only if locally
// enabled by the user.
for (auto& mediaAttr : mediaList) {
if (mediaAttr.type_ == MediaType::MEDIA_VIDEO and not acc->isVideoEnabled()) {
mediaAttr.enabled_ = false;
}
}
initMediaStreams(mediaList);
sdp_->processIncomingOffer(mediaList);
if (upnp_) {
openPortsUPnP();
}
if (isIceEnabled()) {
setupIceResponse();
}
sdp_->startNegotiation();
if (pjsip_inv_set_sdp_answer(inviteSession_.get(), sdp_->getLocalSdpSession()) != PJ_SUCCESS) {
JAMI_ERR("[call:%s] Could not start media negotiation for a re-invite request",
getCallId().c_str());
}}
void
SIPCall::openPortsUPnP()
{
if (not sdp_) {
JAMI_ERR("[call:%s] Current SDP instance is invalid", getCallId().c_str());
return;
}
/**
* Try to open the desired ports with UPnP,
* if they are used, use the alternative port and update the SDP session with the newly
* chosen port(s)
*
* TODO:
* No need to request mappings for specfic port numbers. Set the port to '0' to
* request the first available port (faster and more likely to succeed).
*/
JAMI_DBG("[call:%s] opening ports via UPNP for SDP session", getCallId().c_str());
// RTP port.
upnp_->reserveMapping(sdp_->getLocalAudioPort(), upnp::PortType::UDP);
// RTCP port.
upnp_->reserveMapping(sdp_->getLocalAudioControlPort(), upnp::PortType::UDP);
#ifdef ENABLE_VIDEO
// RTP port.
upnp_->reserveMapping(sdp_->getLocalVideoPort(), upnp::PortType::UDP);
// RTCP port.
upnp_->reserveMapping(sdp_->getLocalVideoControlPort(), upnp::PortType::UDP);
#endif
}
std::map<std::string, std::string>
SIPCall::getDetails() const
{
auto acc = getSIPAccount();
if (!acc) {
JAMI_ERR("No account detected");
return {};
}
auto details = Call::getDetails();
details.emplace(DRing::Call::Details::PEER_HOLDING, peerHolding_ ? TRUE_STR : FALSE_STR);
#ifdef ENABLE_VIDEO
for (auto const& stream : rtpStreams_) {
if (stream.mediaAttribute_->type_ != MediaType::MEDIA_VIDEO)
continue;
details.emplace(DRing::Call::Details::VIDEO_SOURCE, stream.mediaAttribute_->sourceUri_);
if (auto const& rtpSession = stream.rtpSession_) {
if (auto codec = rtpSession->getCodec())
details.emplace(DRing::Call::Details::VIDEO_CODEC, codec->systemCodecInfo.name);
else
details.emplace(DRing::Call::Details::VIDEO_CODEC, "");
}
}
#endif
#if HAVE_RINGNS
if (not peerRegisteredName_.empty())
details.emplace(DRing::Call::Details::REGISTERED_NAME, peerRegisteredName_);
#endif
#ifdef ENABLE_CLIENT_CERT
std::lock_guard<std::recursive_mutex> lk {callMutex_};
if (transport_ and transport_->isSecure()) {
const auto& tlsInfos = transport_->getTlsInfos(); if (tlsInfos.cipher != PJ_TLS_UNKNOWN_CIPHER) {
const auto& cipher = pj_ssl_cipher_name(tlsInfos.cipher);
details.emplace(DRing::TlsTransport::TLS_CIPHER, cipher ? cipher : "");
} else {
details.emplace(DRing::TlsTransport::TLS_CIPHER, "");
}
if (tlsInfos.peerCert) {
details.emplace(DRing::TlsTransport::TLS_PEER_CERT, tlsInfos.peerCert->toString());
auto ca = tlsInfos.peerCert->issuer;
unsigned n = 0;
while (ca) {
std::ostringstream name_str;
name_str << DRing::TlsTransport::TLS_PEER_CA_ << n++;
details.emplace(name_str.str(), ca->toString());
ca = ca->issuer;
}
details.emplace(DRing::TlsTransport::TLS_PEER_CA_NUM, std::to_string(n));
} else {
details.emplace(DRing::TlsTransport::TLS_PEER_CERT, "");
details.emplace(DRing::TlsTransport::TLS_PEER_CA_NUM, "");
}
}
#endif
return details;
}
void
SIPCall::enterConference(const std::string& confId)
{
#ifdef ENABLE_VIDEO
auto conf = Manager::instance().getConferenceFromID(confId);
if (conf == nullptr) {
JAMI_ERR("Unknown conference [%s]", confId.c_str());
return;
}
auto videoRtp = getVideoRtp();
if (not videoRtp) {
// In conference, we need to have a video RTP session even
// if it's an audio only call
videoRtp = addDummyVideoRtpSession();
if (not videoRtp) {
throw std::runtime_error("Failed to create dummy RTP video session");
}
}
videoRtp->enterConference(conf.get());
#endif
#ifdef ENABLE_PLUGIN
clearCallAVStreams();
#endif
}
void
SIPCall::exitConference()
{
auto const& audioRtp = getAudioRtp();
if (audioRtp && !isCaptureDeviceMuted(MediaType::MEDIA_AUDIO)) {
auto& rbPool = Manager::instance().getRingBufferPool();
rbPool.bindCallID(getCallId(), RingBufferPool::DEFAULT_ID);
rbPool.flush(RingBufferPool::DEFAULT_ID);
}
#ifdef ENABLE_VIDEO
auto const& videoRtp = getVideoRtp();
if (videoRtp)
videoRtp->exitConference();
#endif
#ifdef ENABLE_PLUGIN
createCallAVStreams();#endif
}
std::shared_ptr<Observable<std::shared_ptr<MediaFrame>>>
SIPCall::getReceiveVideoFrameActiveWriter()
{
#ifdef ENABLE_VIDEO
auto videoRtp = getVideoRtp();
if (videoRtp)
return videoRtp->getReceiveVideoFrameActiveWriter();
#endif
return {};
}
std::shared_ptr<video::VideoRtpSession>
SIPCall::addDummyVideoRtpSession()
{
#ifdef ENABLE_VIDEO
MediaAttribute mediaAttr(MediaType::MEDIA_VIDEO, true, true, false, "", "dummy video session");
addMediaStream(mediaAttr);
auto& stream = rtpStreams_.back();
createRtpSession(stream);
if (stream.rtpSession_) {
return std::dynamic_pointer_cast<video::VideoRtpSession>(stream.rtpSession_);
}
#endif
return {};
}
void
SIPCall::createSinks(const ConfInfo& infos)
{
#ifdef ENABLE_VIDEO
if (!hasVideo())
return;
std::lock_guard<std::mutex> lk(sinksMtx_);
auto videoRtp = getVideoRtp();
auto& videoReceive = videoRtp->getVideoReceive();
if (!videoReceive)
return;
auto id = getConfId().empty() ? getCallId() : getConfId();
Manager::instance().createSinkClients(id,
infos,
std::static_pointer_cast<video::VideoGenerator>(
videoReceive),
callSinksMap_);
#endif
}
std::shared_ptr<AudioRtpSession>
SIPCall::getAudioRtp() const
{
// For the moment, the clients support only one audio stream, so we
// return the first audio stream.
for (auto const& stream : rtpStreams_) {
auto rtp = stream.rtpSession_;
if (rtp->getMediaType() == MediaType::MEDIA_AUDIO) {
return std::dynamic_pointer_cast<AudioRtpSession>(rtp);
}
}
return nullptr;
}
#ifdef ENABLE_VIDEO
std::shared_ptr<video::VideoRtpSession>
SIPCall::getVideoRtp() const{
for (auto const& stream : rtpStreams_) {
auto rtp = stream.rtpSession_;
if (rtp->getMediaType() == MediaType::MEDIA_VIDEO) {
return std::dynamic_pointer_cast<video::VideoRtpSession>(rtp);
}
}
return nullptr;
}
#endif
std::vector<std::shared_ptr<RtpSession>>
SIPCall::getRtpSessionList() const
{
std::vector<std::shared_ptr<RtpSession>> rtpList;
rtpList.reserve(rtpStreams_.size());
for (auto const& stream : rtpStreams_) {
rtpList.emplace_back(stream.rtpSession_);
}
return rtpList;
}
void
SIPCall::monitor() const
{
if (isSubcall())
return;
auto acc = getSIPAccount();
if (!acc) {
JAMI_ERR("No account detected");
return;
}
JAMI_DBG("- Call %s with %s:", getCallId().c_str(), getPeerNumber().c_str());
JAMI_DBG("\t- Duration: %s", dht::print_duration(getCallDuration()).c_str());
for (const auto& stream : rtpStreams_)
JAMI_DBG("\t- Media: %s", stream.mediaAttribute_->toString(true).c_str());
#ifdef ENABLE_VIDEO
if (auto codec = getVideoCodec())
JAMI_DBG("\t- Video codec: %s", codec->systemCodecInfo.name.c_str());
#endif
if (auto transport = getIceMedia()) {
JAMI_DBG("\t- Medias: %s", transport->link().c_str());
}
}
bool
SIPCall::toggleRecording()
{
pendingRecord_ = true;
if (not readyToRecord_)
return true;
// add streams to recorder before starting the record
if (not Call::isRecording()) {
updateRecState(true);
auto account = getSIPAccount();
if (!account) {
JAMI_ERR("No account detected");
return false;
}
auto title = fmt::format("Conversation at %TIMESTAMP between {} and {}",
account->getUserUri(),
peerUri_);
recorder_->setMetadata(title, ""); // use default description
auto const& audioRtp = getAudioRtp();
if (audioRtp)
audioRtp->initRecorder(recorder_);
#ifdef ENABLE_VIDEO
if (hasVideo()) {
auto const& videoRtp = getVideoRtp(); if (videoRtp)
videoRtp->initRecorder(recorder_);
}
#endif
} else {
updateRecState(false);
deinitRecorder();
}
pendingRecord_ = false;
return Call::toggleRecording();
}
void
SIPCall::deinitRecorder()
{
if (Call::isRecording()) {
auto const& audioRtp = getAudioRtp();
if (audioRtp)
audioRtp->deinitRecorder(recorder_);
#ifdef ENABLE_VIDEO
if (hasVideo()) {
auto const& videoRtp = getVideoRtp();
if (videoRtp)
videoRtp->deinitRecorder(recorder_);
}
#endif
}
}
void
SIPCall::InvSessionDeleter::operator()(pjsip_inv_session* inv) const noexcept
{
// prevent this from getting accessed in callbacks
// JAMI_WARN: this is not thread-safe!
if (!inv)
return;
inv->mod_data[Manager::instance().sipVoIPLink().getModId()] = nullptr;
// NOTE: the counter is incremented by sipvoiplink (transaction_request_cb)
pjsip_inv_dec_ref(inv);
}
void
SIPCall::createIceMediaTransport()
{
auto& iceTransportFactory = Manager::instance().getIceTransportFactory();
std::lock_guard<std::mutex> lk(transportMtx_);
resetTransport(std::move(mediaTransport_));
mediaTransport_ = iceTransportFactory.createTransport(getCallId().c_str());
if (mediaTransport_) {
JAMI_DBG("[call:%s] Successfully created media ICE transport [ice:%p]",
getCallId().c_str(),
mediaTransport_.get());
} else {
JAMI_ERR("[call:%s] Failed to create media ICE transport", getCallId().c_str());
}
}
bool
SIPCall::initIceMediaTransport(bool master, std::optional<IceTransportOptions> options)
{
auto acc = getSIPAccount();
if (!acc) {
JAMI_ERR("No account detected");
return false;
}
JAMI_DBG("[call:%s] Init media ICE transport", getCallId().c_str());
auto mediaTransport = getIceMedia();
if (not mediaTransport) {
JAMI_ERR("[call:%s] Failed to create media ICE transport", getCallId().c_str()); return false;
}
auto iceOptions = options == std::nullopt ? acc->getIceOptions() : *options;
auto optOnInitDone = std::move(iceOptions.onInitDone);
auto optOnNegoDone = std::move(iceOptions.onNegoDone);
iceOptions.onInitDone = [w = weak(), cb = std::move(optOnInitDone)](bool ok) {
runOnMainThread([w = std::move(w), cb = std::move(cb), ok] {
auto call = w.lock();
if (cb)
cb(ok);
if (!ok or !call or !call->waitForIceInit_.exchange(false))
return;
std::lock_guard<std::recursive_mutex> lk {call->callMutex_};
auto rem_ice_attrs = call->sdp_->getIceAttributes();
// Init done but no remote_ice_attributes, the ice->start will be triggered later
if (rem_ice_attrs.ufrag.empty() or rem_ice_attrs.pwd.empty())
return;
call->startIceMedia();
});
};
iceOptions.onNegoDone = [w = weak(), cb = std::move(optOnNegoDone)](bool ok) {
runOnMainThread([w = std::move(w), cb = std::move(cb), ok] {
if (cb)
cb(ok);
if (auto call = w.lock()) {
// The ICE is related to subcalls, but medias are handled by parent call
std::lock_guard<std::recursive_mutex> lk {call->callMutex_};
call = call->isSubcall() ? std::dynamic_pointer_cast<SIPCall>(call->parent_) : call;
if (!ok) {
JAMI_ERR("[call:%s] Media ICE negotiation failed", call->getCallId().c_str());
call->onFailure(EIO);
return;
}
call->onIceNegoSucceed();
}
});
};
iceOptions.master = master;
iceOptions.streamsCount = static_cast<unsigned>(rtpStreams_.size());
// Each RTP stream requires a pair of ICE components (RTP + RTCP).
iceOptions.compCountPerStream = ICE_COMP_COUNT_PER_STREAM;
// Init ICE.
mediaTransport->initIceInstance(iceOptions);
return true;
}
std::vector<std::string>
SIPCall::getLocalIceCandidates(unsigned compId) const
{
std::lock_guard<std::mutex> lk(transportMtx_);
if (not mediaTransport_) {
JAMI_WARN("[call:%s] no media ICE transport", getCallId().c_str());
return {};
}
return mediaTransport_->getLocalCandidates(compId);
}
void
SIPCall::resetTransport(std::shared_ptr<IceTransport>&& transport)
{
// Move the transport to another thread and destroy it there if possible
if (transport) {
dht::ThreadPool::io().run(
[transport = std::move(transport)]() mutable { transport.reset(); }); }
}
void
SIPCall::merge(Call& call)
{
JAMI_DBG("[call:%s] merge subcall %s", getCallId().c_str(), call.getCallId().c_str());
// This static cast is safe as this method is private and overload Call::merge
auto& subcall = static_cast<SIPCall&>(call);
std::lock(callMutex_, subcall.callMutex_);
std::lock_guard<std::recursive_mutex> lk1 {callMutex_, std::adopt_lock};
std::lock_guard<std::recursive_mutex> lk2 {subcall.callMutex_, std::adopt_lock};
inviteSession_ = std::move(subcall.inviteSession_);
if (inviteSession_)
inviteSession_->mod_data[Manager::instance().sipVoIPLink().getModId()] = this;
setTransport(std::move(subcall.transport_));
sdp_ = std::move(subcall.sdp_);
peerHolding_ = subcall.peerHolding_;
upnp_ = std::move(subcall.upnp_);
std::copy_n(subcall.contactBuffer_, PJSIP_MAX_URL_SIZE, contactBuffer_);
pj_strcpy(&contactHeader_, &subcall.contactHeader_);
localAudioPort_ = subcall.localAudioPort_;
localVideoPort_ = subcall.localVideoPort_;
peerUserAgent_ = subcall.peerUserAgent_;
peerSupportMultiStream_ = subcall.peerSupportMultiStream_;
Call::merge(subcall);
if (isIceEnabled())
startIceMedia();
}
bool
SIPCall::remoteHasValidIceAttributes()
{
if (not sdp_) {
throw std::runtime_error("Must have a valid SDP Session");
}
auto rem_ice_attrs = sdp_->getIceAttributes();
if (rem_ice_attrs.ufrag.empty()) {
JAMI_WARN("[call:%s] Missing ICE username fragment attribute in remote SDP",
getCallId().c_str());
return false;
}
if (rem_ice_attrs.pwd.empty()) {
JAMI_WARN("[call:%s] Missing ICE password attribute in remote SDP", getCallId().c_str());
return false;
}
return true;
}
void
SIPCall::setIceMedia(std::shared_ptr<IceTransport> ice)
{
JAMI_DBG("[call:%s] Setting ICE session [%p]", getCallId().c_str(), ice.get());
std::lock_guard<std::mutex> lk(transportMtx_);
if (not isSubcall()) {
JAMI_ERR("[call:%s] The call is expected to be a sub-call", getCallId().c_str());
}
mediaTransport_ = std::move(ice);
}
void
SIPCall::setupIceResponse()
{ JAMI_DBG("[call:%s] Setup ICE response", getCallId().c_str());
auto account = getSIPAccount();
if (not account) {
JAMI_ERR("No account detected");
}
if (not remoteHasValidIceAttributes()) {
// If ICE attributes are not present, skip the ICE initialization
// step (most likely ICE is not used).
JAMI_ERR("[call:%s] no ICE data in remote SDP", getCallId().c_str());
return;
}
auto opt = account->getIceOptions();
// Try to use the discovered public address. If not available,
// fallback on local address.
opt.accountPublicAddr = account->getPublishedIpAddress();
if (opt.accountLocalAddr) {
opt.accountLocalAddr = ip_utils::getInterfaceAddr(account->getLocalInterface(),
opt.accountPublicAddr.getFamily());
} else {
// Just set the local address for both, most likely the account is not
// registered.
opt.accountLocalAddr = ip_utils::getInterfaceAddr(account->getLocalInterface(), AF_INET);
opt.accountPublicAddr = opt.accountLocalAddr;
}
if (not opt.accountLocalAddr) {
JAMI_ERR("[call:%s] No local address, ICE can't be initialized", getCallId().c_str());
onFailure(EIO);
return;
}
createIceMediaTransport();
if (not initIceMediaTransport(false, opt)) {
JAMI_ERR("[call:%s] ICE initialization failed", getCallId().c_str());
// Fatal condition
// TODO: what's SIP rfc says about that?
// (same question in startIceMedia)
onFailure(EIO);
return;
}
// WARNING: This call blocks! (need ice init done)
addLocalIceAttributes();
}
bool
SIPCall::isIceRunning() const
{
std::lock_guard<std::mutex> lk(transportMtx_);
return mediaTransport_ and mediaTransport_->isRunning();
}
std::unique_ptr<IceSocket>
SIPCall::newIceSocket(unsigned compId)
{
return std::unique_ptr<IceSocket> {new IceSocket(mediaTransport_, compId)};
}
void
SIPCall::rtpSetupSuccess(MediaType type, bool isRemote)
{
std::lock_guard<std::mutex> lk {setupSuccessMutex_};
if (type == MEDIA_AUDIO) {
if (isRemote)
mediaReady_.at("a:remote") = true;
else
mediaReady_.at("a:local") = true; } else {
if (isRemote)
mediaReady_.at("v:remote") = true;
else
mediaReady_.at("v:local") = true;
}
if (mediaReady_.at("a:local") and mediaReady_.at("a:remote") and mediaReady_.at("v:remote")) {
if (Manager::instance().videoPreferences.getRecordPreview() or mediaReady_.at("v:local"))
readyToRecord_ = true;
}
if (pendingRecord_ && readyToRecord_)
toggleRecording();
}
void
SIPCall::peerRecording(bool state)
{
const std::string& id = getConfId().empty() ? getCallId() : getConfId();
if (state) {
JAMI_WARN("Peer is recording");
emitSignal<DRing::CallSignal::RemoteRecordingChanged>(id, getPeerNumber(), true);
} else {
JAMI_WARN("Peer stopped recording");
emitSignal<DRing::CallSignal::RemoteRecordingChanged>(id, getPeerNumber(), false);
}
peerRecording_ = state;
}
void
SIPCall::peerMuted(bool muted)
{
if (muted) {
JAMI_WARN("Peer muted");
} else {
JAMI_WARN("Peer un-muted");
}
peerMuted_ = muted;
if (auto conf = Manager::instance().getConferenceFromID(getConfId())) {
conf->updateMuted();
}
}
void
SIPCall::resetMediaReady()
{
for (auto& m : mediaReady_)
m.second = false;
}
} // namespace jami