Changeset 5820

Timestamp:

Jul 12, 2018 8:22:31 AM (6 years ago)

Author:

nanang

Message:

Close #2126: Initial implementation of RTCP Feedback.

Location:

pjproject/trunk

Files:

• pjmedia/build/pjmedia.vcproj (modified) (2 diffs)
• pjmedia/include/pjmedia/config.h (modified) (1 diff)
• pjmedia/include/pjmedia/rtcp_fb.h (added)
• pjmedia/include/pjmedia/sdp.h (modified) (1 diff)
• pjmedia/include/pjmedia/stream.h (modified) (2 diffs)
• pjmedia/include/pjmedia/types.h (modified) (1 diff)
• pjmedia/src/pjmedia/rtcp_fb.c (added)
• pjmedia/src/pjmedia/sdp.c (modified) (2 diffs)
• pjmedia/src/pjmedia/stream.c (modified) (17 diffs)
• pjmedia/src/pjmedia/stream_info.c (modified) (4 diffs)
• pjmedia/src/pjmedia/transport_ice.c (modified) (3 diffs)
• pjmedia/src/pjmedia/transport_srtp_dtls.c (modified) (1 diff)
• pjmedia/src/pjmedia/transport_srtp_sdes.c (modified) (11 diffs)
• pjmedia/src/pjmedia/transport_udp.c (modified) (2 diffs)
• pjmedia/src/pjmedia/vid_stream_info.c (modified) (2 diffs)
• pjsip-apps/src/swig/symbols.i (modified) (1 diff)
• pjsip-apps/src/swig/symbols.lst (modified) (1 diff)
• pjsip/include/pjsua-lib/pjsua.h (modified) (1 diff)
• pjsip/include/pjsua2/account.hpp (modified) (3 diffs)
• pjsip/src/pjsua-lib/pjsua_acc.c (modified) (2 diffs)
• pjsip/src/pjsua-lib/pjsua_core.c (modified) (1 diff)
• pjsip/src/pjsua-lib/pjsua_media.c (modified) (5 diffs)
• pjsip/src/pjsua2/account.cpp (modified) (1 diff)

pjproject/trunk/pjmedia/build/pjmedia.vcproj

@@ -5636 +5636 @@
                         </File>
                         <File
+                                RelativePath="..\src\pjmedia\rtcp_fb.c"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\src\pjmedia\rtcp_xr.c"
                                 >
@@ -7601 +7605 @@
                         </File>
                         <File
+                                RelativePath="..\include\pjmedia\rtcp_fb.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\include\pjmedia\rtcp_xr.h"
                                 >

pjproject/trunk/pjmedia/include/pjmedia/config.h

@@ -568 +568 @@
 
 /**
+ * Specify the maximum number of RTCP Feedback capability definition.
+ * 
+ * Default: 16
+ */
+#ifndef PJMEDIA_RTCP_FB_MAX_CAP
+#   define PJMEDIA_RTCP_FB_MAX_CAP              16
+#endif
+
+
+/**
  * Specify how long (in miliseconds) the stream should suspend the
  * silence detector/voice activity detector (VAD) during the initial

pjproject/trunk/pjmedia/include/pjmedia/sdp.h

@@ -603 +603 @@
 
 /**
+ * Get media transport protocol info, i.e: base transport and profiles,
+ * from the provided SDP media transport name string.
+ *
+ * @param tp        The SDP media transport name.
+ *
+ * @return          Media transport info, combination of transport protocol
+ *                  and profile bit flag defined in pjmedia_tp_proto.
+ */
+PJ_DECL(pj_uint32_t) pjmedia_sdp_transport_get_proto(const pj_str_t *tp);
+
+
+/**
  * Deactivate SDP media.
  *

pjproject/trunk/pjmedia/include/pjmedia/stream.h

@@ -32 +32 @@
 #include <pjmedia/port.h>
 #include <pjmedia/rtcp.h>
+#include <pjmedia/rtcp_fb.h>
 #include <pjmedia/transport.h>
 #include <pjmedia/vid_codec.h>
@@ -110 +111 @@
                                          this will be ignored.              */
 #endif
+    pjmedia_rtcp_fb_info loc_rtcp_fb; /**< Local RTCP-FB info.              */
+    pjmedia_rtcp_fb_info rem_rtcp_fb; /**< Remote RTCP-FB info.             */
     pjmedia_codec_info  fmt;        /**< Incoming codec format info.        */
     pjmedia_codec_param *param;     /**< Optional codec param.              */

pjproject/trunk/pjmedia/include/pjmedia/types.h

@@ -73 +73 @@
 
 /**
- * Media transport protocol.
+ * Media transport protocol and profile.
  */
 typedef enum pjmedia_tp_proto
 {
+    /* Basic transports */
+
     /** No transport type */
-    PJMEDIA_TP_PROTO_NONE = 0,
+    PJMEDIA_TP_PROTO_NONE           = 0,
+
+    /** Transport unknown */
+    PJMEDIA_TP_PROTO_UNKNOWN        = (1 << 0),
+
+    /** UDP transport */
+    PJMEDIA_TP_PROTO_UDP            = (1 << 1),
+
+    /** RTP transport */
+    PJMEDIA_TP_PROTO_RTP            = (1 << 2),
+
+    /** DTLS transport */
+    PJMEDIA_TP_PROTO_DTLS           = (1 << 3),
+
+
+    /* Basic profiles */
+    
+    /** RTCP Feedback profile */
+    PJMEDIA_TP_PROFILE_RTCP_FB      = (1 << 13),
+
+    /** Secure RTP profile */
+    PJMEDIA_TP_PROFILE_SRTP         = (1 << 14),
+
+    /** Audio/video profile */
+    PJMEDIA_TP_PROFILE_AVP          = (1 << 15),
+
+
+    /* Predefined transport profiles (commonly used) */
 
     /** RTP using A/V profile */
-    PJMEDIA_TP_PROTO_RTP_AVP,
-
-    /** Secure RTP */
-    PJMEDIA_TP_PROTO_RTP_SAVP,
-
-    /** Unknown */
-    PJMEDIA_TP_PROTO_UNKNOWN
+    PJMEDIA_TP_PROTO_RTP_AVP        = (PJMEDIA_TP_PROTO_RTP |
+                                       PJMEDIA_TP_PROFILE_AVP),
+
+    /** Secure RTP using A/V profile */
+    PJMEDIA_TP_PROTO_RTP_SAVP       = (PJMEDIA_TP_PROTO_RTP_AVP |
+                                       PJMEDIA_TP_PROFILE_SRTP),
+
+    /** Secure RTP using A/V profile and DTLS-SRTP keying */
+    PJMEDIA_TP_PROTO_DTLS_SRTP      = (PJMEDIA_TP_PROTO_DTLS |
+                                       PJMEDIA_TP_PROTO_RTP_SAVP),
+
+    /** RTP using A/V and RTCP feedback profile */
+    PJMEDIA_TP_PROTO_RTP_AVPF       = (PJMEDIA_TP_PROTO_RTP_AVP |
+                                       PJMEDIA_TP_PROFILE_RTCP_FB),
+
+    /** Secure RTP using A/V and RTCP feedback profile */
+    PJMEDIA_TP_PROTO_RTP_SAVPF      = (PJMEDIA_TP_PROTO_RTP_SAVP |
+                                       PJMEDIA_TP_PROFILE_RTCP_FB),
+
+    /** Secure RTP using A/V and RTCP feedback profile and DTLS-SRTP keying */
+    PJMEDIA_TP_PROTO_DTLS_SRTPF     = (PJMEDIA_TP_PROTO_DTLS_SRTP |
+                                       PJMEDIA_TP_PROFILE_RTCP_FB),
 
 } pjmedia_tp_proto;
 
+/**
+ * Macro helper for checking if a transport protocol contains specific
+ * transport and profile flags.
+ */
+#define PJMEDIA_TP_PROTO_HAS_FLAG(TP_PROTO, FLAGS) \
+                                    (((TP_PROTO) & (FLAGS)) == (FLAGS))
+
+/**
+ * Macro helper for excluding specific flags in transport protocol.
+ */
+#define PJMEDIA_TP_PROTO_TRIM_FLAG(TP_PROTO, FLAGS) ((TP_PROTO) &= ~(FLAGS))
 
 /**

pjproject/trunk/pjmedia/src/pjmedia/sdp.c

@@ -1642 +1642 @@
                                                const pj_str_t *t2)
 {
-    static const pj_str_t ID_RTP_AVP  = { "RTP/AVP", 7 };
-    static const pj_str_t ID_RTP_SAVP = { "RTP/SAVP", 8 };
+    pj_uint32_t t1_proto, t2_proto;
 
     /* Exactly equal? */
@@ -1649 +1648 @@
         return PJ_SUCCESS;
 
+    /* Check if boths are RTP/AVP based */
+    t1_proto = pjmedia_sdp_transport_get_proto(t1);
+    t2_proto = pjmedia_sdp_transport_get_proto(t2);
+    if (PJMEDIA_TP_PROTO_HAS_FLAG(t1_proto, PJMEDIA_TP_PROTO_RTP_AVP) && 
+        PJMEDIA_TP_PROTO_HAS_FLAG(t2_proto, PJMEDIA_TP_PROTO_RTP_AVP))
+    {
+        return PJ_SUCCESS;
+    }
+
     /* Compatible? */
-    if ((!pj_stricmp(t1, &ID_RTP_AVP) || !pj_stricmp(t1, &ID_RTP_SAVP)) &&
-        (!pj_stricmp(t2, &ID_RTP_AVP) || !pj_stricmp(t2, &ID_RTP_SAVP)))
-        return PJ_SUCCESS;
+    //{
+    //  static const pj_str_t ID_RTP_AVP  = { "RTP/AVP", 7 };
+    //  static const pj_str_t ID_RTP_SAVP = { "RTP/SAVP", 8 };
+    //  if ((!pj_stricmp(t1, &ID_RTP_AVP) || !pj_stricmp(t1, &ID_RTP_SAVP)) &&
+    //      (!pj_stricmp(t2, &ID_RTP_AVP) || !pj_stricmp(t2, &ID_RTP_SAVP)))
+    //      return PJ_SUCCESS;
+    //}
 
     return PJMEDIA_SDP_ETPORTNOTEQUAL;
+}
+
+
+/*
+ * Get media transport info, e.g: protocol and profile.
+ */
+PJ_DEF(pj_uint32_t) pjmedia_sdp_transport_get_proto(const pj_str_t *tp)
+{
+    pj_str_t token, rest = {0};
+    pj_ssize_t idx;
+
+    PJ_ASSERT_RETURN(tp, PJMEDIA_TP_PROTO_NONE);
+
+    idx = pj_strtok2(tp, "/", &token, 0);
+    if (idx != tp->slen)
+        pj_strset(&rest, tp->ptr + token.slen + 1, tp->slen - token.slen - 1);
+
+    if (pj_stricmp2(&token, "RTP") == 0) {
+        /* Starts with "RTP" */
+
+        /* RTP/AVP */
+        if (pj_stricmp2(&rest, "AVP") == 0)
+            return PJMEDIA_TP_PROTO_RTP_AVP;
+
+        /* RTP/SAVP */
+        if (pj_stricmp2(&rest, "SAVP") == 0)
+            return PJMEDIA_TP_PROTO_RTP_SAVP;
+
+        /* RTP/AVPF */
+        if (pj_stricmp2(&rest, "AVPF") == 0)
+            return PJMEDIA_TP_PROTO_RTP_AVPF;
+
+        /* RTP/SAVPF */
+        if (pj_stricmp2(&rest, "SAVPF") == 0)
+            return PJMEDIA_TP_PROTO_RTP_SAVPF;
+
+    } else if (pj_stricmp2(&token, "UDP") == 0) {
+        /* Starts with "UDP" */
+
+        /* Plain UDP */
+        if (rest.slen == 0)
+            return PJMEDIA_TP_PROTO_UDP;
+
+        /* DTLS-SRTP */
+        if (pj_stricmp2(&rest, "TLS/RTP/SAVP") == 0)
+            return PJMEDIA_TP_PROTO_DTLS_SRTP;
+
+        /* DTLS-SRTP with RTCP-FB */
+        if (pj_stricmp2(&rest, "TLS/RTP/SAVPF") == 0)
+            return PJMEDIA_TP_PROTO_DTLS_SRTPF;
+    }
+
+    /* Unknown transport */
+    return PJMEDIA_TP_PROTO_UNKNOWN;
 }
 

pjproject/trunk/pjmedia/src/pjmedia/stream.c

@@ -97 +97 @@
     int             ebit_cnt;               /**< # of E bit transmissions   */
 };
+
 
 /**
@@ -246 +247 @@
     pj_uint32_t              rtp_rx_last_ts;        /**< Last received RTP timestamp*/
     pj_status_t              rtp_rx_last_err;       /**< Last RTP recv() error */
+
+    /* RTCP Feedback */
+    pj_bool_t                send_rtcp_fb_nack;/**< Should we send NACK?    */
+    pjmedia_rtcp_fb_nack     rtcp_fb_nack;     /**< NACK state.             */
+
+
 };
 
@@ -278 +285 @@
                              pj_bool_t with_sdes,
                              pj_bool_t with_bye,
-                             pj_bool_t with_xr);
+                             pj_bool_t with_xr,
+                             pj_bool_t with_fb);
 
 
@@ -461 +469 @@
 
     /* Send RTCP */
-    send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE);
+    send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE, PJ_FALSE);
     
     /* Update stats in case the stream is paused */
@@ -992 +1000 @@
 
 
+static pj_status_t build_rtcp_fb(pjmedia_stream *stream, void *buf,
+                                 pj_size_t *length)
+{
+    pj_status_t status;
+
+    /* Generic NACK */
+    if (stream->send_rtcp_fb_nack && stream->rtcp_fb_nack.pid >= 0)
+    {
+        status = pjmedia_rtcp_fb_build_nack(&stream->rtcp, buf, length, 1,
+                                            &stream->rtcp_fb_nack);
+        if (status != PJ_SUCCESS)
+            return status;
+
+        /* Reset Packet ID */
+        stream->rtcp_fb_nack.pid = -1;
+    }
+
+    return PJ_SUCCESS;
+}
+
+
 static pj_status_t send_rtcp(pjmedia_stream *stream,
                              pj_bool_t with_sdes,
                              pj_bool_t with_bye,
-                             pj_bool_t with_xr)
+                             pj_bool_t with_xr,
+                             pj_bool_t with_fb)
 {
     void *sr_rr_pkt;
@@ -1009 +1039 @@
 #endif
 
-    if (with_sdes || with_bye || with_xr) {
+    if (with_sdes || with_bye || with_xr || with_fb) {
         pkt = (pj_uint8_t*) stream->out_rtcp_pkt;
         pj_memcpy(pkt, sr_rr_pkt, len);
@@ -1017 +1047 @@
         max_len = len;
     }
+
+    /* RTCP FB must be sent in compound (i.e: with RR/SR and SDES) */
+    if (with_fb)
+        with_sdes = PJ_TRUE;
 
     /* Build RTCP SDES packet */
@@ -1036 +1070 @@
     }
 
+    if (with_fb) {
+        pj_size_t fb_len = max_len - len;
+        status = build_rtcp_fb(stream, pkt+len, &fb_len);
+        if (status != PJ_SUCCESS) {
+            PJ_PERROR(4,(stream->port.info.name.ptr, status,
+                                     "Error generating RTCP FB"));
+        } else {
+            len += (int)fb_len;
+        }
+    }
+
     /* Build RTCP XR packet */
 #if defined(PJMEDIA_HAS_RTCP_XR) && (PJMEDIA_HAS_RTCP_XR != 0)
@@ -1137 +1182 @@
 
         status = send_rtcp(stream, !stream->rtcp_sdes_bye_disabled, PJ_FALSE,
-                           with_xr);
+                           with_xr, PJ_FALSE);
         if (status != PJ_SUCCESS) {
             PJ_PERROR(4,(stream->port.info.name.ptr, status,
@@ -1680 +1725 @@
     const void *payload;
     unsigned payloadlen;
-    pjmedia_rtp_status seq_st;
+    pjmedia_rtp_status seq_st = {0};
     pj_status_t status;
     pj_bool_t pkt_discarded = PJ_FALSE;
@@ -2006 +2051 @@
                          pj_ntohl(hdr->ts), payloadlen, pkt_discarded);
 
+    /* RTCP-FB generic NACK */
+    if (stream->rtcp.received >= 10 && seq_st.diff > 1 &&
+        stream->send_rtcp_fb_nack && pj_ntohs(hdr->seq) >= seq_st.diff)
+    {
+        int i;
+        pj_bzero(&stream->rtcp_fb_nack, sizeof(stream->rtcp_fb_nack));
+        stream->rtcp_fb_nack.pid = pj_ntohs(hdr->seq) - seq_st.diff + 1;
+        for (i = 0; i < (seq_st.diff - 1); ++i) {
+            stream->rtcp_fb_nack.blp <<= 1;
+            stream->rtcp_fb_nack.blp |= 1;
+        }
+
+        /* Send it immediately */
+        status = send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE, PJ_TRUE);
+        if (status != PJ_SUCCESS) {
+            PJ_PERROR(4,(stream->port.info.name.ptr, status,
+                      "Error sending RTCP FB generic NACK"));
+        } else {
+            stream->initial_rr = PJ_TRUE;
+        }
+    }
+
     /* Send RTCP RR and SDES after we receive some RTP packets */
     if (stream->rtcp.received >= 10 && !stream->initial_rr) {
         status = send_rtcp(stream, !stream->rtcp_sdes_bye_disabled,
-                           PJ_FALSE, PJ_FALSE);
+                           PJ_FALSE, PJ_FALSE, PJ_FALSE);
         if (status != PJ_SUCCESS) {
             PJ_PERROR(4,(stream->port.info.name.ptr, status,
@@ -2161 +2228 @@
     PJ_ASSERT_RETURN(stream != NULL, PJ_ENOMEM);
     stream->own_pool = own_pool;
+
+    /* Duplicate stream info */
     pj_memcpy(&stream->si, info, sizeof(*info));
     pj_strdup(pool, &stream->si.fmt.encoding_name, &info->fmt.encoding_name);
     if (info->param)
         stream->si.param = pjmedia_codec_param_clone(pool, info->param);
+    pjmedia_rtcp_fb_info_dup(pool, &stream->si.loc_rtcp_fb,
+                             &info->loc_rtcp_fb);
+    pjmedia_rtcp_fb_info_dup(pool, &stream->si.rem_rtcp_fb,
+                             &info->rem_rtcp_fb);
 
     /* Init stream/port name */
@@ -2200 +2273 @@
     stream->last_dtmf = -1;
     stream->jb_last_frm = PJMEDIA_JB_NORMAL_FRAME;
+    stream->rtcp_fb_nack.pid = -1;
 
 #if defined(PJMEDIA_STREAM_ENABLE_KA) && PJMEDIA_STREAM_ENABLE_KA!=0
@@ -2591 +2665 @@
 #endif
 
+    /* Check if RTCP-FB generic NACK is enabled for this codec */
+    if (stream->si.rem_rtcp_fb.cap_count) {
+        pjmedia_rtcp_fb_info *rfi = &stream->si.rem_rtcp_fb;
+        char cid[32];
+        unsigned i;
+
+        pjmedia_codec_info_to_id(&stream->si.fmt, cid, sizeof(cid));
+
+        for (i = 0; i < rfi->cap_count; ++i) {
+            if (rfi->caps[i].type == PJMEDIA_RTCP_FB_NACK &&
+                (!pj_strcmp2( &rfi->caps[i].codec_id, "*") ||
+                 !pj_stricmp2(&rfi->caps[i].codec_id, cid)))
+            {
+                stream->send_rtcp_fb_nack = PJ_TRUE;
+                break;
+            }
+        }
+    }
+
     /* Update the stream info's codec param */
     stream->si.param = &stream->codec_param;
@@ -2659 +2752 @@
     /* Send RTCP BYE (also SDES & XR) */
     if (!stream->rtcp_sdes_bye_disabled) {
-        send_rtcp(stream, PJ_TRUE, PJ_TRUE, PJ_TRUE);
+        send_rtcp(stream, PJ_TRUE, PJ_TRUE, PJ_TRUE, PJ_FALSE);
     }
 
@@ -3074 +3167 @@
     PJ_ASSERT_RETURN(stream, PJ_EINVAL);
 
-    return send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE);
+    return send_rtcp(stream, PJ_TRUE, PJ_FALSE, PJ_FALSE, PJ_FALSE);
 }
 
@@ -3086 +3179 @@
 
     if (stream->enc && stream->transport) {
-        return send_rtcp(stream, PJ_TRUE, PJ_TRUE, PJ_FALSE);
+        return send_rtcp(stream, PJ_TRUE, PJ_TRUE, PJ_FALSE, PJ_FALSE);
     }
 

pjproject/trunk/pjmedia/src/pjmedia/stream_info.c

@@ -28 +28 @@
 static const pj_str_t ID_IP4 = { "IP4", 3};
 static const pj_str_t ID_IP6 = { "IP6", 3};
-static const pj_str_t ID_RTP_AVP = { "RTP/AVP", 7 };
-static const pj_str_t ID_RTP_SAVP = { "RTP/SAVP", 8 };
 //static const pj_str_t ID_SDP_NAME = { "pjmedia", 7 };
 static const pj_str_t ID_RTPMAP = { "rtpmap", 6 };
@@ -417 +415 @@
         return PJMEDIA_SDPNEG_EINVANSTP;
 
-    if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
-
-        si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
-
-    } else if (pj_stristr(&local_m->desc.transport, &ID_RTP_SAVP)) {
-
-        si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
-
-    } else {
-
-        si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
+    /* Get the transport protocol */
+    si->proto = pjmedia_sdp_transport_get_proto(&local_m->desc.transport);
+
+    /* Just return success if stream is not RTP/AVP compatible */
+    if (!PJMEDIA_TP_PROTO_HAS_FLAG(si->proto, PJMEDIA_TP_PROTO_RTP_AVP))
         return PJ_SUCCESS;
-    }
-
 
     /* Check address family in remote SDP */
@@ -602 +592 @@
     /* Get codec info and param */
     status = get_audio_codec_info_param(si, pool, mgr, local_m, rem_m);
+    if (status != PJ_SUCCESS)
+        return status;
 
     /* Leave SSRC to random. */
@@ -609 +601 @@
     si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
 
+    /* Get local RTCP-FB info */
+    status = pjmedia_rtcp_fb_decode_sdp(pool, endpt, NULL, local, stream_idx,
+                                        &si->loc_rtcp_fb);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    /* Get remote RTCP-FB info */
+    status = pjmedia_rtcp_fb_decode_sdp(pool, endpt, NULL, remote, stream_idx,
+                                        &si->rem_rtcp_fb);
+    if (status != PJ_SUCCESS)
+        return status;
+
     return status;
 }

pjproject/trunk/pjmedia/src/pjmedia/transport_ice.c

@@ -186 +186 @@
 };
 
-static const pj_str_t STR_RTP_AVP       = { "RTP/AVP", 7 };
 static const pj_str_t STR_CANDIDATE     = { "candidate", 9};
 static const pj_str_t STR_REM_CAND      = { "remote-candidates", 17 };
@@ -1408 +1407 @@
      */
     if ((tp_ice->media_option & PJMEDIA_TPMED_NO_TRANSPORT_CHECKING) == 0) {
-        pjmedia_sdp_media *loc_m, *rem_m;
-
-        rem_m = rem_sdp? rem_sdp->media[media_index] : NULL;
-        loc_m = sdp_local->media[media_index];
-
-        if (pj_stricmp(&loc_m->desc.transport, &STR_RTP_AVP) ||
-           (rem_m && pj_stricmp(&rem_m->desc.transport, &STR_RTP_AVP)))
+        pjmedia_sdp_media *m_rem, *m_loc;
+        pj_uint32_t tp_proto_loc, tp_proto_rem;
+
+        m_rem = rem_sdp? rem_sdp->media[media_index] : NULL;
+        m_loc = sdp_local->media[media_index];
+
+        tp_proto_loc = pjmedia_sdp_transport_get_proto(&m_loc->desc.transport);
+        tp_proto_rem = m_rem? 
+                pjmedia_sdp_transport_get_proto(&m_rem->desc.transport) : 0;
+        PJMEDIA_TP_PROTO_TRIM_FLAG(tp_proto_loc, PJMEDIA_TP_PROFILE_RTCP_FB);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(tp_proto_rem, PJMEDIA_TP_PROFILE_RTCP_FB);
+
+        if ((tp_proto_loc != PJMEDIA_TP_PROTO_RTP_AVP) ||
+            (m_rem && tp_proto_rem != PJMEDIA_TP_PROTO_RTP_AVP))
         {
-            pjmedia_sdp_media_deactivate(sdp_pool, loc_m);
+            pjmedia_sdp_media_deactivate(sdp_pool, m_loc);
             return PJMEDIA_SDP_EINPROTO;
         }
@@ -1826 +1832 @@
     param.addr_len = addr_len;
     param.rtp_cb = rtp_cb;
+    param.rtcp_cb = rtcp_cb;
     return transport_attach2(tp, &param);
 }

pjproject/trunk/pjmedia/src/pjmedia/transport_srtp_dtls.c

@@ -1048 +1048 @@
         pjmedia_sdp_media *m_rem = sdp_remote->media[media_index];
         pjmedia_sdp_attr *attr_setup;
-
-        if (pj_stricmp(&m_rem->desc.transport, &ID_TP_DTLS_SRTP)!=0) {
+        pj_uint32_t rem_proto = 0;
+
+        rem_proto = pjmedia_sdp_transport_get_proto(&m_rem->desc.transport);
+        if (!PJMEDIA_TP_PROTO_HAS_FLAG(rem_proto, PJMEDIA_TP_PROTO_DTLS_SRTP))
+        {
             /* Remote doesn't signal DTLS-SRTP */
             status = PJMEDIA_SRTP_ESDPINTRANSPORT;

pjproject/trunk/pjmedia/src/pjmedia/transport_srtp_sdes.c

@@ -274 +274 @@
 {
     struct transport_srtp *srtp = (struct transport_srtp*)tp->user_data;
+    pj_uint32_t rem_proto = 0;
 
     PJ_UNUSED_ARG(options);
@@ -281 +282 @@
     if (!srtp->offerer_side) {
         pjmedia_sdp_media *m = sdp_remote->media[media_index];
-        if (pj_stricmp(&m->desc.transport, &ID_RTP_AVP)  != 0 &&
-            pj_stricmp(&m->desc.transport, &ID_RTP_SAVP) != 0)
+
+        /* Get transport protocol and drop any RTCP-FB flag */
+        rem_proto = pjmedia_sdp_transport_get_proto(&m->desc.transport);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(rem_proto, PJMEDIA_TP_PROFILE_RTCP_FB);
+        if (rem_proto != PJMEDIA_TP_PROTO_RTP_AVP &&
+            rem_proto != PJMEDIA_TP_PROTO_RTP_SAVP)
         {
             return PJMEDIA_SRTP_ESDPINTRANSPORT;
@@ -292 +297 @@
         /* As offerer: do nothing. */
     } else {
-        pjmedia_sdp_media *m_rem = sdp_remote->media[media_index];
-
         /* Validate remote media transport based on SRTP usage option. */
         switch (srtp->setting.use) {
             case PJMEDIA_SRTP_DISABLED:
-                if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) == 0)
+                if (rem_proto == PJMEDIA_TP_PROTO_RTP_SAVP)
                     return PJMEDIA_SRTP_ESDPINTRANSPORT;
                 break;
@@ -303 +306 @@
                 break;
             case PJMEDIA_SRTP_MANDATORY:
-                if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) != 0)
+                if (rem_proto != PJMEDIA_TP_PROTO_RTP_SAVP)
                     return PJMEDIA_SRTP_ESDPINTRANSPORT;
                 break;
@@ -334 +337 @@
     {
         pjmedia_sdp_media *m = sdp_remote? m_rem : m_loc;
-        if (pj_stricmp(&m->desc.transport, &ID_RTP_AVP)  != 0 &&
-            pj_stricmp(&m->desc.transport, &ID_RTP_SAVP) != 0)
+        pj_uint32_t proto = 0;
+
+        /* Get transport protocol and drop any RTCP-FB flag */
+        proto = pjmedia_sdp_transport_get_proto(&m->desc.transport);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(proto, PJMEDIA_TP_PROFILE_RTCP_FB);
+        if (proto != PJMEDIA_TP_PROTO_RTP_AVP &&
+            proto != PJMEDIA_TP_PROTO_RTP_SAVP)
         {
             return PJMEDIA_SRTP_ESDPINTRANSPORT;
@@ -409 +417 @@
     } else {
         /* Answerer side */
+        pj_uint32_t rem_proto = 0;
 
         pj_assert(sdp_remote && m_rem);
+
+        /* Get transport protocol and drop any RTCP-FB flag */
+        rem_proto = pjmedia_sdp_transport_get_proto(&m_rem->desc.transport);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(rem_proto, PJMEDIA_TP_PROFILE_RTCP_FB);
 
         /* Generate transport */
@@ -416 +429 @@
             case PJMEDIA_SRTP_DISABLED:
                 /* Should never reach here */
-                if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) == 0)
+                if (rem_proto == PJMEDIA_TP_PROTO_RTP_SAVP)
                     return PJMEDIA_SRTP_ESDPINTRANSPORT;
                 return PJ_SUCCESS;
@@ -422 +435 @@
                 break;
             case PJMEDIA_SRTP_MANDATORY:
-                if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) != 0)
+                if (rem_proto != PJMEDIA_TP_PROTO_RTP_SAVP)
                     return PJMEDIA_SRTP_ESDPINTRANSPORT;
                 break;
@@ -496 +509 @@
                      */
                     if ((!has_crypto_attr || matched_idx == -1) &&
-                        pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0)
+                        rem_proto == PJMEDIA_TP_PROTO_RTP_AVP)
                     {
                         return PJ_SUCCESS;
@@ -610 +623 @@
 
     /* Verify media transport, it has to be RTP/AVP or RTP/SAVP */
-    if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP)  != 0 &&
-        pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) != 0)
     {
-        return PJMEDIA_SRTP_ESDPINTRANSPORT;
-    }
-
-    if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP) == 0)
-        srtp->peer_use = PJMEDIA_SRTP_MANDATORY;
-    else
-        srtp->peer_use = PJMEDIA_SRTP_OPTIONAL;
+        pj_uint32_t rem_proto;
+
+        /* Get transport protocol and drop any RTCP-FB flag */
+        rem_proto = pjmedia_sdp_transport_get_proto(&m_rem->desc.transport);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(rem_proto, PJMEDIA_TP_PROFILE_RTCP_FB);
+        if (rem_proto != PJMEDIA_TP_PROTO_RTP_AVP &&
+            rem_proto != PJMEDIA_TP_PROTO_RTP_SAVP)
+        {
+            return PJMEDIA_SRTP_ESDPINTRANSPORT;
+        }
+
+        /* Also check if peer signal SRTP as mandatory */
+        if (rem_proto == PJMEDIA_TP_PROTO_RTP_SAVP)
+            srtp->peer_use = PJMEDIA_SRTP_MANDATORY;
+        else
+            srtp->peer_use = PJMEDIA_SRTP_OPTIONAL;
+    }
 
     /* For answerer side, this function will just have to start SRTP as
@@ -647 +668 @@
         fill_local_crypto(srtp->pool, m_loc, loc_crypto, &loc_cryto_cnt);
     } else if (srtp->setting.use == PJMEDIA_SRTP_MANDATORY) {
-        if (pj_stricmp(&m_rem->desc.transport, &ID_RTP_SAVP)) {
+        if (srtp->peer_use != PJMEDIA_SRTP_MANDATORY) {
             DEACTIVATE_MEDIA(pool, m_loc);
             return PJMEDIA_SDP_EINPROTO;

pjproject/trunk/pjmedia/src/pjmedia/transport_udp.c

@@ -37 +37 @@
 /* Maximum pending write operations */
 #define MAX_PENDING 4
-
-static const pj_str_t ID_RTP_AVP  = { "RTP/AVP", 7 };
 
 /* Pending write buffer */
@@ -1031 +1029 @@
     if ((udp->media_options & PJMEDIA_TPMED_NO_TRANSPORT_CHECKING) == 0) {
         pjmedia_sdp_media *m_rem, *m_loc;
+        pj_uint32_t tp_proto_loc, tp_proto_rem;
 
         m_rem = rem_sdp? rem_sdp->media[media_index] : NULL;
         m_loc = sdp_local->media[media_index];
 
-        if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP) ||
-           (m_rem && pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP)))
+        tp_proto_loc = pjmedia_sdp_transport_get_proto(&m_loc->desc.transport);
+        tp_proto_rem = m_rem? 
+                pjmedia_sdp_transport_get_proto(&m_rem->desc.transport) : 0;
+        PJMEDIA_TP_PROTO_TRIM_FLAG(tp_proto_loc, PJMEDIA_TP_PROFILE_RTCP_FB);
+        PJMEDIA_TP_PROTO_TRIM_FLAG(tp_proto_rem, PJMEDIA_TP_PROFILE_RTCP_FB);
+
+        if ((tp_proto_loc != PJMEDIA_TP_PROTO_RTP_AVP) ||
+            (m_rem && tp_proto_rem != PJMEDIA_TP_PROTO_RTP_AVP))
         {
             pjmedia_sdp_media_deactivate(pool, m_loc);

pjproject/trunk/pjmedia/src/pjmedia/vid_stream_info.c

@@ -29 +29 @@
 static const pj_str_t ID_IP4 = { "IP4", 3};
 static const pj_str_t ID_IP6 = { "IP6", 3};
-static const pj_str_t ID_RTP_AVP = { "RTP/AVP", 7 };
-static const pj_str_t ID_RTP_SAVP = { "RTP/SAVP", 8 };
 //static const pj_str_t ID_SDP_NAME = { "pjmedia", 7 };
 static const pj_str_t ID_RTPMAP = { "rtpmap", 6 };
@@ -240 +238 @@
         return PJMEDIA_SDPNEG_EINVANSTP;
 
-    if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
-
-        si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
-
-    } else if (pj_stristr(&local_m->desc.transport, &ID_RTP_SAVP)) {
-
-        si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
-
-    } else {
-
-        si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
+    /* Get the transport protocol */
+    si->proto = pjmedia_sdp_transport_get_proto(&local_m->desc.transport);
+
+    /* Return success if transport protocol is not RTP/AVP compatible */
+    if (!PJMEDIA_TP_PROTO_HAS_FLAG(si->proto, PJMEDIA_TP_PROTO_RTP_AVP))
         return PJ_SUCCESS;
-    }
 
 

pjproject/trunk/pjsip-apps/src/swig/symbols.i

@@ -110 +110 @@
 typedef enum pjmedia_vid_packing {PJMEDIA_VID_PACKING_UNKNOWN, PJMEDIA_VID_PACKING_PACKETS = 1, PJMEDIA_VID_PACKING_WHOLE = 2} pjmedia_vid_packing;
 
+typedef enum pjmedia_rtcp_fb_type {PJMEDIA_RTCP_FB_ACK, PJMEDIA_RTCP_FB_NACK, PJMEDIA_RTCP_FB_TRR_INT, PJMEDIA_RTCP_FB_OTHER} pjmedia_rtcp_fb_type;
+
 typedef enum pjsip_cred_data_type {PJSIP_CRED_DATA_PLAIN_PASSWD = 0, PJSIP_CRED_DATA_DIGEST = 1, PJSIP_CRED_DATA_EXT_AKA = 16} pjsip_cred_data_type;
 

pjproject/trunk/pjsip-apps/src/swig/symbols.lst

@@ -18 +18 @@
 pjmedia/format.h                pjmedia_format_id
 pjmedia/vid_codec.h             pjmedia_vid_packing
+pjmedia/rtcp_fb.h               pjmedia_rtcp_fb_type
 
 pjsip/sip_auth.h                pjsip_cred_data_type

pjproject/trunk/pjsip/include/pjsua-lib/pjsua.h

@@ -3913 +3913 @@
     pj_bool_t           enable_rtcp_mux;
 
+    /**
+     * RTCP Feedback configuration.
+     */
+    pjmedia_rtcp_fb_setting rtcp_fb_cfg;
+
 } pjsua_acc_config;
 

pjproject/trunk/pjsip/include/pjsua2/account.hpp

@@ -738 +738 @@
 typedef std::vector<SrtpCrypto> SrtpCryptoVector;
 
+/**
+ * SRTP settings.
+ */
 struct SrtpOpt : public PersistentObject
 {
@@ -772 +775 @@
      */
     pjsua_srtp_opt toPj() const;
+
+public:
+    /**
+     * Read this object from a container node.
+     *
+     * @param node              Container to read values from.
+     */
+    virtual void readObject(const ContainerNode &node) throw(Error);
+
+    /**
+     * Write this object to a container node.
+     *
+     * @param node              Container to write values to.
+     */
+    virtual void writeObject(ContainerNode &node) const throw(Error);
+};
+
+/**
+ * RTCP Feedback capability.
+ */
+struct RtcpFbCap
+{
+    /**
+     * Specify the codecs to which the capability is applicable. Codec ID is
+     * using the same format as in pjmedia_codec_mgr_find_codecs_by_id() and
+     * pjmedia_vid_codec_mgr_find_codecs_by_id(), e.g: "L16/8000/1", "PCMU",
+     * "H264". This can also be an asterisk ("*") to represent all codecs.
+     */
+    string                  codecId;
+
+    /**
+     * Specify the RTCP Feedback type.
+     */
+    pjmedia_rtcp_fb_type    type;
+
+    /**
+     * Specify the type name if RTCP Feedback type is PJMEDIA_RTCP_FB_OTHER.
+     */
+    string                  typeName;
+
+    /**
+     * Specify the RTCP Feedback parameters.
+     */
+    string                  param;
+
+public:
+    /**
+     * Constructor.
+     */
+    RtcpFbCap() : type(PJMEDIA_RTCP_FB_OTHER)
+    {}
+
+    /**
+     * Convert from pjsip
+     */
+    void fromPj(const pjmedia_rtcp_fb_cap &prm);
+
+    /**
+     * Convert to pjsip
+     */
+    pjmedia_rtcp_fb_cap toPj() const;
+};
+
+/* Array of RTCP Feedback capabilities. */
+typedef std::vector<RtcpFbCap> RtcpFbCapVector;
+
+
+/**
+ * RTCP Feedback settings.
+ */
+struct RtcpFbConfig : public PersistentObject
+{
+    /**
+     * Specify whether transport protocol in SDP media description uses
+     * RTP/AVP instead of RTP/AVPF. Note that the standard mandates to signal
+     * AVPF profile, but it may cause SDP negotiation failure when negotiating
+     * with endpoints that does not support RTCP Feedback (including older
+     * version of PJSIP).
+     *
+     * Default: false.
+     */
+    bool                    dontUseAvpf;
+
+    /**
+     * RTCP Feedback capabilities.
+     */
+    RtcpFbCapVector         caps;
+
+public:
+    /**
+     * Constructor.
+     */
+    RtcpFbConfig();
+
+    /**
+     * Convert from pjsip
+     */
+    void fromPj(const pjmedia_rtcp_fb_setting &prm);
+
+    /**
+     * Convert to pjsip
+     */
+    pjmedia_rtcp_fb_setting toPj() const;
 
 public:
@@ -854 +960 @@
      */
     bool                rtcpMuxEnabled;
+
+    /**
+     * RTCP Feedback settings.
+     */
+    RtcpFbConfig        rtcpFbConfig;
 
 public:

pjproject/trunk/pjsip/src/pjsua-lib/pjsua_acc.c

@@ -141 +141 @@
 
     pj_strdup(pool, &dst->ka_data, &src->ka_data);
+
+    pjmedia_rtcp_fb_setting_dup(pool, &dst->rtcp_fb_cfg, &src->rtcp_fb_cfg);
 }
 
@@ -1433 +1435 @@
     acc->cfg.ip_change_cfg.hangup_calls = cfg->ip_change_cfg.hangup_calls;    
     acc->cfg.ip_change_cfg.reinvite_flags = cfg->ip_change_cfg.reinvite_flags;
+
+    /* RTCP-FB config */
+    pjmedia_rtcp_fb_setting_dup(acc->pool, &acc->cfg.rtcp_fb_cfg,
+                                &cfg->rtcp_fb_cfg);
 
 on_return:

pjproject/trunk/pjsip/src/pjsua-lib/pjsua_core.c

@@ -292 +292 @@
     pjsua_transport_config_default(&cfg->rtp_cfg);
     cfg->rtp_cfg.port = DEFAULT_RTP_PORT;
+    pjmedia_rtcp_fb_setting_default(&cfg->rtcp_fb_cfg);
 
     pjsua_media_config_default(&med_cfg);

pjproject/trunk/pjsip/src/pjsua-lib/pjsua_media.c

@@ -2258 +2258 @@
     pj_sockaddr origin;
     pjsua_call *call = &pjsua_var.calls[call_id];
+    pjsua_acc *acc = &pjsua_var.acc[call->acc_id];
     pjmedia_sdp_neg_state sdp_neg_state = PJMEDIA_SDP_NEG_STATE_NULL;
     unsigned mi;
@@ -2484 +2485 @@
             }
         }
+
+        /* Add RTCP-FB info in SDP if we are offerer */
+        if (rem_sdp == NULL && acc->cfg.rtcp_fb_cfg.cap_count) {
+            status = pjmedia_rtcp_fb_encode_sdp(pool, pjsua_var.med_endpt,
+                                                &acc->cfg.rtcp_fb_cfg, sdp,
+                                                mi, rem_sdp);
+            if (status != PJ_SUCCESS) {
+                PJ_PERROR(3,(THIS_FILE, status,
+                             "Call %d media %d: Failed to encode RTCP-FB "
+                             "setting to SDP",
+                             call_id, mi));
+            }
+        }
     }
 
@@ -2529 +2543 @@
         sdp->bandw[sdp->bandw_count++] = b;
     }
-
 
 #if DISABLED_FOR_TICKET_1185 && defined(PJMEDIA_HAS_SRTP) && (PJMEDIA_HAS_SRTP != 0)
@@ -2961 +2974 @@
 #endif
 
-    /* Applying media count limitation. Note that in generating SDP answer,
-     * no media count limitation applied, as we didn't know yet which media
-     * would pass the SDP negotiation.
+    /* We need to re-nego SDP or modify our answer when:
+     * - media count exceeds the configured limit,
+     * - RTCP-FB is enabled (so a=rtcp-fb will only be printed for negotiated
+     *   codecs)
      */
-    if (maudcnt > call->opt.aud_cnt || mvidcnt > call->opt.vid_cnt)
+    if (!pjmedia_sdp_neg_was_answer_remote(call->inv->neg) &&
+        ((maudcnt > call->opt.aud_cnt || mvidcnt > call->opt.vid_cnt) ||
+        (acc->cfg.rtcp_fb_cfg.cap_count)))
     {
-        pjmedia_sdp_session *local_sdp2;
-
-        maudcnt = PJ_MIN(maudcnt, call->opt.aud_cnt);
-        mvidcnt = PJ_MIN(mvidcnt, call->opt.vid_cnt);
-        local_sdp2 = pjmedia_sdp_session_clone(tmp_pool, local_sdp);
-
-        for (mi=0; mi < local_sdp2->media_count; ++mi) {
-            pjmedia_sdp_media *m = local_sdp2->media[mi];
-
-            if (m->desc.port == 0 ||
-                pj_memchr(maudidx, mi, maudcnt*sizeof(maudidx[0])) ||
-                pj_memchr(mvididx, mi, mvidcnt*sizeof(mvididx[0])))
-            {
-                continue;
-            }
-            
-            /* Deactivate this media */
-            pjmedia_sdp_media_deactivate(tmp_pool, m);
-        }
-
-        local_sdp = local_sdp2;
+        pjmedia_sdp_session *local_sdp_renego = NULL;
+
+        local_sdp_renego = pjmedia_sdp_session_clone(tmp_pool, local_sdp);
+        local_sdp = local_sdp_renego;
         need_renego_sdp = PJ_TRUE;
+
+        /* Add RTCP-FB info into local SDP answer */
+        if (acc->cfg.rtcp_fb_cfg.cap_count) {
+            for (mi=0; mi < local_sdp_renego->media_count; ++mi) {
+                status = pjmedia_rtcp_fb_encode_sdp(
+                                        tmp_pool, pjsua_var.med_endpt,
+                                        &acc->cfg.rtcp_fb_cfg,
+                                        local_sdp_renego, mi, remote_sdp);
+                if (status != PJ_SUCCESS) {
+                    PJ_PERROR(3,(THIS_FILE, status,
+                                 "Call %d media %d: Failed to encode RTCP-FB "
+                                 "setting to SDP",
+                                 call_id, mi));
+                }
+            }
+        }
+
+        /* Applying media count limitation. Note that in generating SDP
+         * answer, no media count limitation applied as we didn't know yet
+         * which media would pass the SDP negotiation.
+         */
+        if (maudcnt > call->opt.aud_cnt || mvidcnt > call->opt.vid_cnt)
+        {
+            maudcnt = PJ_MIN(maudcnt, call->opt.aud_cnt);
+            mvidcnt = PJ_MIN(mvidcnt, call->opt.vid_cnt);
+
+            for (mi=0; mi < local_sdp_renego->media_count; ++mi) {
+                pjmedia_sdp_media *m = local_sdp_renego->media[mi];
+
+                if (m->desc.port == 0 ||
+                    pj_memchr(maudidx, mi, maudcnt*sizeof(maudidx[0])) ||
+                    pj_memchr(mvididx, mi, mvidcnt*sizeof(mvididx[0])))
+                {
+                    continue;
+                }
+            
+                /* Deactivate this excess media */
+                pjmedia_sdp_media_deactivate(tmp_pool, m);
+            }
+        }
     }
 
@@ -3389 +3428 @@
               sizeof(call->media_prov[0]) * call->med_prov_cnt);
 
-    /* Perform SDP re-negotiation if some media have just got disabled
-     * in this function due to media count limit settings.
-     */
+    /* Perform SDP re-negotiation. */
     if (got_media && need_renego_sdp) {
         pjmedia_sdp_neg *neg = call->inv->neg;
 
-        /* This should only happen when we are the answerer. */
-        PJ_ASSERT_RETURN(neg && !pjmedia_sdp_neg_was_answer_remote(neg),
-                         PJMEDIA_SDPNEG_EINSTATE);
-        
         status = pjmedia_sdp_neg_set_remote_offer(tmp_pool, neg, remote_sdp);
         if (status != PJ_SUCCESS)

pjproject/trunk/pjsip/src/pjsua2/account.cpp

@@ -27 +27 @@
 
 #define THIS_FILE               "account.cpp"
+
+///////////////////////////////////////////////////////////////////////////////
+
+void RtcpFbCap::fromPj(const pjmedia_rtcp_fb_cap &prm)
+{
+    this->codecId   = pj2Str(prm.codec_id);
+    this->type      = prm.type;
+    this->typeName  = pj2Str(prm.type_name);
+    this->param     = pj2Str(prm.param);
+}
+
+pjmedia_rtcp_fb_cap RtcpFbCap::toPj() const
+{
+    pjmedia_rtcp_fb_cap cap;
+
+    pj_bzero(&cap, sizeof(cap));
+    cap.codec_id    = str2Pj(this->codecId);
+    cap.type        = this->type;
+    cap.type_name   = str2Pj(this->typeName);
+    cap.param       = str2Pj(this->param);
+
+    return cap;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+RtcpFbConfig::RtcpFbConfig()
+{
+    pjmedia_rtcp_fb_setting setting;
+    pjmedia_rtcp_fb_setting_default(&setting);
+    fromPj(setting);
+}
+
+void RtcpFbConfig::fromPj(const pjmedia_rtcp_fb_setting &prm)
+{
+    this->dontUseAvpf = PJ2BOOL(prm.dont_use_avpf);
+    this->caps.clear();
+    for (unsigned i = 0; i < prm.cap_count; ++i) {
+        RtcpFbCap cap;
+        cap.fromPj(prm.caps[i]);
+        this->caps.push_back(cap);
+    }
+}
+
+pjmedia_rtcp_fb_setting RtcpFbConfig::toPj() const
+{
+    pjmedia_rtcp_fb_setting setting;
+
+    pj_bzero(&setting, sizeof(setting));
+    setting.dont_use_avpf   = this->dontUseAvpf;
+    setting.cap_count       = this->caps.size();
+    for (unsigned i = 0; i < setting.cap_count; ++i) {
+        setting.caps[i] = this->caps[i].toPj();
+    }
+
+    return setting;
+}
+
+void RtcpFbConfig::readObject(const ContainerNode &node) throw(Error)
+{
+    ContainerNode this_node = node.readContainer("RtcpFbConfig");
+    NODE_READ_BOOL      (this_node, dontUseAvpf);
+
+    ContainerNode cap_node = this_node.readArray("caps");
+    this->caps.clear();
+    while (cap_node.hasUnread()) {
+        RtcpFbCap cap;
+        NODE_READ_STRING        (cap_node, cap.codecId);
+        NODE_READ_NUM_T         (cap_node, pjmedia_rtcp_fb_type, cap.type);
+        NODE_READ_STRING        (cap_node, cap.typeName);
+        NODE_READ_STRING        (cap_node, cap.param);
+        this->caps.push_back(cap);
+    }
+}
+
+void RtcpFbConfig::writeObject(ContainerNode &node) const throw(Error)
+{
+    ContainerNode this_node = node.writeNewContainer("RtcpFbConfig");
+    NODE_WRITE_BOOL     (this_node, dontUseAvpf);
+
+    ContainerNode cap_node = this_node.writeNewArray("caps");
+    for (unsigned i=0; i<this->caps.size(); ++i) {
+        NODE_WRITE_STRING       (cap_node, this->caps[i].codecId);
+        NODE_WRITE_NUM_T        (cap_node, pjmedia_rtcp_fb_type,
+                                 this->caps[i].type);
+        NODE_WRITE_STRING       (cap_node, this->caps[i].typeName);
+        NODE_WRITE_STRING       (cap_node, this->caps[i].param);
+    }
+}
 
 ///////////////////////////////////////////////////////////////////////////////