/*
* sipsdp_write_to_buf()
*
* This function builds the specified SDP in a text buffer and returns
* a pointer to this buffer.
*
* Returns: pointer to buffer - no errors
* NULL - errors were encountered while building
* the SDP. The details of the build failure
* can be determined by enabling SDP debugs
* and by examining SDP library error counters.
*/
char *
sipsdp_write_to_buf (cc_sdp_t *sdp_info, uint32_t *retbytes)
{
flex_string fs;
// uint32_t sdp_len;
sdp_result_e rc;
flex_string_init(&fs);
if (!sdp_info || !sdp_info->src_sdp) {
CCSIP_DEBUG_ERROR(SIP_F_PREFIX"NULL sdp_info or src_sdp\n", __FUNCTION__);
return (NULL);
}
if ((rc = sdp_build(sdp_info->src_sdp, &fs))
!= SDP_SUCCESS) {
CCSIP_DEBUG_TASK(DEB_F_PREFIX"sdp_build rc=%s\n", DEB_F_PREFIX_ARGS(SIP_SDP, __FUNCTION__),
sdp_get_result_name(rc));
flex_string_free(&fs);
*retbytes = 0;
return (NULL);
}
*retbytes = fs.string_length;
/* We are not calling flex_string_free on this, instead returning the buffer
* caller's responsibility to free
*/
return fs.buffer;
}
std::string SerializeSdp() {
flex_string fs;
flex_string_init(&fs);
EXPECT_EQ(sdp_build(sdp_ptr_, &fs), SDP_SUCCESS);
std::string body(fs.buffer);
flex_string_free(&fs);
return body;
}
/*
* sdp_parse_error
* Send SDP parsing errors to log and up to peerconnection
*/
void sdp_parse_error(const char *peerconnection, const char *format, ...) {
flex_string fs;
va_list ap;
flex_string_init(&fs);
va_start(ap, format);
flex_string_vsprintf(&fs, format, ap);
va_end(ap);
CSFLogError("SDP Parse", "SDP Parse Error %s, pc %s", fs.buffer, peerconnection);
vcmOnSdpParseError(peerconnection, fs.buffer);
flex_string_free(&fs);
}
/*
* sdp_parse_error
* Send SDP parsing errors to log and up to peerconnection
*/
void sdp_parse_error(sdp_t* sdp, const char *format, ...) {
flex_string fs;
va_list ap;
flex_string_init(&fs);
va_start(ap, format);
flex_string_vsprintf(&fs, format, ap);
va_end(ap);
CSFLogError("SDP Parse", "SDP Parse Error %s, line %u", fs.buffer,
sdp->parse_line);
if (sdp->conf_p->error_handler) {
sdp->conf_p->error_handler(sdp->conf_p->error_handler_context,
sdp->parse_line,
fs.buffer);
}
flex_string_free(&fs);
}
void
SipccSdpAttributeList::LoadFmtp(sdp_t* sdp, uint16_t level)
{
auto fmtps = MakeUnique<SdpFmtpAttributeList>();
for (uint16_t i = 1; i < UINT16_MAX; ++i) {
sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_FMTP, i);
if (!attr) {
break;
}
sdp_fmtp_t* fmtp = &(attr->attr.fmtp);
// Get the payload type
std::stringstream osPayloadType;
// payload_num is the number in the fmtp attribute, verbatim
osPayloadType << fmtp->payload_num;
// Get the serialized form of the parameters
flex_string fs;
flex_string_init(&fs);
// Very lame, but we need direct access so we can get the serialized form
sdp_result_e sdpres = sdp_build_attr_fmtp_params(sdp, fmtp, &fs);
if (sdpres != SDP_SUCCESS) {
flex_string_free(&fs);
continue;
}
std::string paramsString(fs.buffer);
flex_string_free(&fs);
// Get parsed form of parameters, if supported
UniquePtr<SdpFmtpAttributeList::Parameters> parameters;
rtp_ptype codec = sdp_get_known_payload_type(sdp, level, fmtp->payload_num);
switch (codec) {
case RTP_H264_P0:
case RTP_H264_P1: {
SdpFmtpAttributeList::H264Parameters* h264Parameters(
new SdpFmtpAttributeList::H264Parameters);
sstrncpy(h264Parameters->sprop_parameter_sets, fmtp->parameter_sets,
sizeof(h264Parameters->sprop_parameter_sets));
h264Parameters->level_asymmetry_allowed =
!!(fmtp->level_asymmetry_allowed);
h264Parameters->packetization_mode = fmtp->packetization_mode;
// Copied from VcmSIPCCBinding
#ifdef _WIN32
sscanf_s(fmtp->profile_level_id, "%x",
&h264Parameters->profile_level_id, sizeof(unsigned*));
#else
sscanf(fmtp->profile_level_id, "%xu",
&h264Parameters->profile_level_id);
#endif
h264Parameters->max_mbps = fmtp->max_mbps;
h264Parameters->max_fs = fmtp->max_fs;
h264Parameters->max_cpb = fmtp->max_cpb;
h264Parameters->max_dpb = fmtp->max_dpb;
h264Parameters->max_br = fmtp->max_br;
parameters.reset(h264Parameters);
} break;
case RTP_VP9: {
SdpFmtpAttributeList::VP8Parameters* vp9Parameters(
new SdpFmtpAttributeList::VP8Parameters(
SdpRtpmapAttributeList::kVP9));
vp9Parameters->max_fs = fmtp->max_fs;
vp9Parameters->max_fr = fmtp->max_fr;
parameters.reset(vp9Parameters);
} break;
case RTP_VP8: {
SdpFmtpAttributeList::VP8Parameters* vp8Parameters(
new SdpFmtpAttributeList::VP8Parameters(
SdpRtpmapAttributeList::kVP8));
vp8Parameters->max_fs = fmtp->max_fs;
vp8Parameters->max_fr = fmtp->max_fr;
parameters.reset(vp8Parameters);
} break;
default: {
}
}
fmtps->PushEntry(osPayloadType.str(), paramsString, Move(parameters));
}
if (!fmtps->mFmtps.empty()) {
SetAttribute(fmtps.release());
}
}
