static bool_t is_rtcp_fb_trr_int_the_same_for_all_payloads(const SalStreamDescription *stream, uint8_t *trr_int) {
MSList *pt_it;
bool_t first = TRUE;
for (pt_it = stream->payloads; pt_it != NULL; pt_it = pt_it->next) {
PayloadType *pt = (PayloadType *)pt_it->data;
if (payload_type_get_flags(pt) & PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED) {
if (first == TRUE) {
*trr_int = payload_type_get_avpf_params(pt).trr_interval;
first = FALSE;
} else if (payload_type_get_avpf_params(pt).trr_interval != *trr_int) {
return FALSE;
}
}
}
return TRUE;
}
static void add_rtcp_fb_attributes(belle_sdp_media_description_t *media_desc, const SalMediaDescription *md, const SalStreamDescription *stream) {
MSList *pt_it;
PayloadType *pt;
PayloadTypeAvpfParams avpf_params;
bool_t general_trr_int;
uint8_t trr_int = 0;
general_trr_int = is_rtcp_fb_trr_int_the_same_for_all_payloads(stream, &trr_int);
if (general_trr_int == TRUE) {
add_rtcp_fb_trr_int_attribute(media_desc, -1, trr_int);
}
for (pt_it = stream->payloads; pt_it != NULL; pt_it = pt_it->next) {
pt = (PayloadType *)pt_it->data;
/* AVPF/SAVPF profile is used so enable AVPF for all paylad types. */
payload_type_set_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
avpf_params = payload_type_get_avpf_params(pt);
/* Add rtcp-fb attributes according to the AVPF features of the payload types. */
if (avpf_params.features & PAYLOAD_TYPE_AVPF_PLI) {
add_rtcp_fb_nack_attribute(media_desc, payload_type_get_number(pt), BELLE_SDP_RTCP_FB_PLI);
}
if (avpf_params.features & PAYLOAD_TYPE_AVPF_SLI) {
add_rtcp_fb_nack_attribute(media_desc, payload_type_get_number(pt), BELLE_SDP_RTCP_FB_SLI);
}
if (avpf_params.features & PAYLOAD_TYPE_AVPF_RPSI) {
add_rtcp_fb_nack_attribute(media_desc, payload_type_get_number(pt), BELLE_SDP_RTCP_FB_RPSI);
}
}
}
static void apply_rtcp_fb_attribute_to_payload(belle_sdp_rtcp_fb_attribute_t *fb_attribute, PayloadType *pt) {
PayloadTypeAvpfParams avpf_params = payload_type_get_avpf_params(pt);
switch (belle_sdp_rtcp_fb_attribute_get_type(fb_attribute)) {
case BELLE_SDP_RTCP_FB_NACK:
switch (belle_sdp_rtcp_fb_attribute_get_param(fb_attribute)) {
case BELLE_SDP_RTCP_FB_PLI:
avpf_params.features |= PAYLOAD_TYPE_AVPF_PLI;
break;
case BELLE_SDP_RTCP_FB_SLI:
avpf_params.features |= PAYLOAD_TYPE_AVPF_SLI;
break;
case BELLE_SDP_RTCP_FB_RPSI:
avpf_params.features |= PAYLOAD_TYPE_AVPF_RPSI;
break;
default:
break;
}
break;
case BELLE_SDP_RTCP_FB_TRR_INT:
avpf_params.trr_interval = (unsigned char)belle_sdp_rtcp_fb_attribute_get_trr_int(fb_attribute);
break;
case BELLE_SDP_RTCP_FB_ACK:
default:
break;
}
payload_type_set_avpf_params(pt, avpf_params);
}
uint16_t rtp_session_get_avpf_rr_interval(RtpSession *session) {
PayloadType *pt = rtp_profile_get_payload(session->rcv.profile, session->rcv.pt);
PayloadTypeAvpfParams params;
if (!pt) return RTCP_DEFAULT_REPORT_INTERVAL;
params=payload_type_get_avpf_params(pt);
return (uint16_t)params.trr_interval;
}
bool_t rtp_session_avpf_payload_type_feature_enabled(RtpSession *session, unsigned char feature) {
PayloadType *pt = rtp_profile_get_payload(session->rcv.profile, session->rcv.pt);
PayloadTypeAvpfParams params;
if (!pt) return FALSE;
params = payload_type_get_avpf_params(pt);
if (params.features & feature) return TRUE;
return FALSE;
}
static void apply_rtcp_fb_attribute_to_payload(belle_sdp_rtcp_fb_attribute_t *fb_attribute, SalStreamDescription *stream, PayloadType *pt) {
PayloadTypeAvpfParams avpf_params = payload_type_get_avpf_params(pt);
switch (belle_sdp_rtcp_fb_attribute_get_type(fb_attribute)) {
case BELLE_SDP_RTCP_FB_ACK:
if (belle_sdp_rtcp_fb_attribute_get_param(fb_attribute) == BELLE_SDP_RTCP_FB_RPSI) {
avpf_params.features |= PAYLOAD_TYPE_AVPF_RPSI;
}
break;
case BELLE_SDP_RTCP_FB_NACK:
switch (belle_sdp_rtcp_fb_attribute_get_param(fb_attribute)) {
case BELLE_SDP_RTCP_FB_PLI:
avpf_params.features |= PAYLOAD_TYPE_AVPF_PLI;
break;
case BELLE_SDP_RTCP_FB_SLI:
avpf_params.features |= PAYLOAD_TYPE_AVPF_SLI;
break;
case BELLE_SDP_RTCP_FB_RPSI:
/* Linphone uses positive feeback for RPSI. However first versions handling
* AVPF wrongly declared RPSI as negative feedback, so this is kept for compatibility
* with these versions but will probably be removed at some point in time. */
avpf_params.features |= PAYLOAD_TYPE_AVPF_RPSI;
avpf_params.rpsi_compatibility = TRUE;
break;
case BELLE_SDP_RTCP_FB_NONE:
stream->rtcp_fb.generic_nack_enabled = TRUE;
break;
default:
break;
}
break;
case BELLE_SDP_RTCP_FB_TRR_INT:
avpf_params.trr_interval = belle_sdp_rtcp_fb_attribute_get_trr_int(fb_attribute);
break;
case BELLE_SDP_RTCP_FB_CCM:
switch (belle_sdp_rtcp_fb_attribute_get_param(fb_attribute)) {
case BELLE_SDP_RTCP_FB_FIR:
avpf_params.features |= PAYLOAD_TYPE_AVPF_FIR;
break;
case BELLE_SDP_RTCP_FB_TMMBR:
stream->rtcp_fb.tmmbr_enabled = TRUE;
break;
default:
break;
}
break;
default:
break;
}
payload_type_set_avpf_params(pt, avpf_params);
}
static void enable_avpf_for_stream(SalStreamDescription *stream) {
MSList *pt_it;
PayloadType *pt;
PayloadTypeAvpfParams avpf_params;
for (pt_it = stream->payloads; pt_it != NULL; pt_it = pt_it->next) {
pt = (PayloadType *)pt_it->data;
avpf_params = payload_type_get_avpf_params(pt);
payload_type_set_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
if (stream->type == SalVideo) {
avpf_params.features |= PAYLOAD_TYPE_AVPF_FIR;
}
avpf_params.trr_interval = 0;
payload_type_set_avpf_params(pt, avpf_params);
}
}
static MSList *match_payloads(const MSList *local, const MSList *remote, bool_t reading_response, bool_t one_matching_codec) {
const MSList *e2,*e1;
MSList *res=NULL;
PayloadType *matched;
bool_t found_codec=FALSE;
for(e2=remote; e2!=NULL; e2=e2->next) {
PayloadType *p2=(PayloadType*)e2->data;
matched=find_payload_type_best_match(local,p2);
if (matched) {
PayloadType *newp;
int local_number=payload_type_get_number(matched);
int remote_number=payload_type_get_number(p2);
if (one_matching_codec) {
if (strcasecmp(matched->mime_type,"telephone-event")!=0) {
if (found_codec) { /* we have found a real codec already*/
continue; /*this codec won't be added*/
} else found_codec=TRUE;
}
}
newp=payload_type_clone(matched);
if (p2->send_fmtp)
payload_type_set_send_fmtp(newp,p2->send_fmtp);
newp->flags|=PAYLOAD_TYPE_FLAG_CAN_RECV|PAYLOAD_TYPE_FLAG_CAN_SEND;
if (p2->flags & PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED) {
newp->flags |= PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED;
newp->avpf = payload_type_get_avpf_params(p2);
}
res=ms_list_append(res,newp);
/* we should use the remote numbering even when parsing a response */
payload_type_set_number(newp,remote_number);
if (reading_response && remote_number!=local_number) {
ms_warning("For payload type %s, proposed number was %i but the remote phone answered %i",
newp->mime_type, local_number, remote_number);
/*
We must add this payload type with our local numbering in order to be able to receive it.
Indeed despite we must sent with the remote numbering, we must be able to receive with
our local one.
*/
newp=payload_type_clone(newp);
payload_type_set_number(newp,local_number);
res=ms_list_append(res,newp);
}
} else {
if (p2->channels>0)
ms_message("No match for %s/%i/%i",p2->mime_type,p2->clock_rate,p2->channels);
else ms_message("No match for %s/%i",p2->mime_type,p2->clock_rate);
}
}
if (reading_response) {
/* add remaning local payload as CAN_RECV only so that if we are in front of a non-compliant equipment we are still able to decode the RTP stream*/
for(e1=local; e1!=NULL; e1=e1->next) {
PayloadType *p1=(PayloadType*)e1->data;
bool_t found=FALSE;
for(e2=res; e2!=NULL; e2=e2->next) {
PayloadType *p2=(PayloadType*)e2->data;
if (payload_type_get_number(p2)==payload_type_get_number(p1)) {
found=TRUE;
break;
}
}
if (!found) {
ms_message("Adding %s/%i for compatibility, just in case.",p1->mime_type,p1->clock_rate);
p1=payload_type_clone(p1);
p1->flags|=PAYLOAD_TYPE_FLAG_CAN_RECV;
res=ms_list_append(res,p1);
}
}
}
return res;
}
