mgw: clean up codec negotiation (sdp)
The codec negotiation via SDP is currently in a neglected state. Also
osmo-mgw does some kind of codec decision wile the SDP is parsed, the
result is information for one codec, even when there are multiple codecs
negotiated. This is problematic because we loose all information about
alternate codecs while we parse. This should be untangled and the
information should be presevered. Also we are not really capable
picking a default. Wehen we do not supply any codec information (not
even LCO), then we should pick a sane default codec.
- separate the codec decision from the sdp parser and concentrate
codec related code in a separate c file
- add support for multiple codecs in one SDP negotiation
- do not initalize "magic" codec defaults during conn allocation
- do not allow invalid payload types, especially not 255. When
someone tries to select an invalid payload type, do not fail
hard, just pick a sane default.
- handle the codec decision in protocol.c, pick a sane default
codec when no (valid) codec has been negotiated (no LCO, no SDP)
Change-Id: If730d022ba6bdb217ad4e20b3fbbd1114dbb4b8f
Closes: OS#2658
Related: OS#3114
Related: OS#2728
diff --git a/src/libosmo-mgcp/mgcp_codec.c b/src/libosmo-mgcp/mgcp_codec.c
new file mode 100644
index 0000000..2ce90dd
--- /dev/null
+++ b/src/libosmo-mgcp/mgcp_codec.c
@@ -0,0 +1,343 @@
+/*
+ * (C) 2009-2015 by Holger Hans Peter Freyther <zecke@selfish.org>
+ * (C) 2009-2014 by On-Waves
+ * All Rights Reserved
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include <osmocom/mgcp/mgcp_internal.h>
+#include <osmocom/mgcp/mgcp_endp.h>
+#include <errno.h>
+
+/* Helper function to dump codec information of a specified codec to a printable
+ * string, used by dump_codec_summary() */
+static char *dump_codec(struct mgcp_rtp_codec *codec)
+{
+ static char str[256];
+ char *pt_str;
+
+ if (codec->payload_type > 76)
+ pt_str = "DYNAMIC";
+ else if (codec->payload_type > 72)
+ pt_str = "RESERVED <!>";
+ else if (codec->payload_type != PTYPE_UNDEFINED)
+ pt_str = codec->subtype_name;
+ else
+ pt_str = "INVALID <!>";
+
+ snprintf(str, sizeof(str), "(pt:%i=%s, audio:%s subt=%s, rate=%u, ch=%i, t=%u/%u)", codec->payload_type, pt_str,
+ codec->audio_name, codec->subtype_name, codec->rate, codec->channels, codec->frame_duration_num,
+ codec->frame_duration_den);
+ return str;
+}
+
+/*! Dump a summary of all negotiated codecs to debug log
+ * \param[in] conn related rtp-connection. */
+void mgcp_codec_summary(struct mgcp_conn_rtp *conn)
+{
+ struct mgcp_rtp_end *rtp;
+ unsigned int i;
+ struct mgcp_rtp_codec *codec;
+ struct mgcp_endpoint *endp;
+
+ rtp = &conn->end;
+ endp = conn->conn->endp;
+
+ if (rtp->codecs_assigned == 0) {
+ LOGP(DLMGCP, LOGL_ERROR, "endpoint:0x%x conn:%s no codecs available\n", ENDPOINT_NUMBER(endp),
+ mgcp_conn_dump(conn->conn));
+ return;
+ }
+
+ /* Store parsed codec information */
+ for (i = 0; i < rtp->codecs_assigned; i++) {
+ codec = &rtp->codecs[i];
+
+ LOGP(DLMGCP, LOGL_DEBUG, "endpoint:0x%x conn:%s codecs[%u]:%s", ENDPOINT_NUMBER(endp),
+ mgcp_conn_dump(conn->conn), i, dump_codec(codec));
+
+ if (codec == rtp->codec)
+ LOGPC(DLMGCP, LOGL_DEBUG, " [selected]");
+
+ LOGPC(DLMGCP, LOGL_DEBUG, "\n");
+ }
+}
+
+/* Initalize or reset codec information with default data. */
+void codec_init(struct mgcp_rtp_codec *codec)
+{
+ if (codec->subtype_name)
+ talloc_free(codec->subtype_name);
+ if (codec->audio_name)
+ talloc_free(codec->audio_name);
+ memset(codec, 0, sizeof(*codec));
+ codec->payload_type = -1;
+ codec->frame_duration_num = DEFAULT_RTP_AUDIO_FRAME_DUR_NUM;
+ codec->frame_duration_den = DEFAULT_RTP_AUDIO_FRAME_DUR_DEN;
+ codec->rate = DEFAULT_RTP_AUDIO_DEFAULT_RATE;
+ codec->channels = DEFAULT_RTP_AUDIO_DEFAULT_CHANNELS;
+}
+
+/*! Initalize or reset codec information with default data.
+ * \param[out] conn related rtp-connection. */
+void mgcp_codec_reset_all(struct mgcp_conn_rtp *conn)
+{
+ memset(conn->end.codecs, 0, sizeof(conn->end.codecs));
+ conn->end.codecs_assigned = 0;
+ conn->end.codec = NULL;
+}
+
+/* Set members of struct mgcp_rtp_codec, extrapolate in missing information */
+static int codec_set(void *ctx, struct mgcp_rtp_codec *codec,
+ int payload_type, const char *audio_name, unsigned int pt_offset)
+{
+ int rate;
+ int channels;
+ char audio_codec[64];
+
+ /* Initalize the codec struct with some default data to begin with */
+ codec_init(codec);
+
+ if (payload_type != PTYPE_UNDEFINED) {
+ /* Make sure we do not get any reserved or undefined type numbers */
+ /* See also: https://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml */
+ if (payload_type == 1 || payload_type == 2 || payload_type == 19)
+ goto error;
+ if (payload_type >= 72 && payload_type <= 76)
+ goto error;
+ if (payload_type >= 127)
+ goto error;
+
+ codec->payload_type = payload_type;
+ }
+
+ /* When no audio name is given, we are forced to use the payload
+ * type to generate the audio name. This is only possible for
+ * non dynamic payload types, which are statically defined */
+ if (!audio_name) {
+ switch (payload_type) {
+ case 0:
+ audio_name = talloc_strdup(ctx, "PCMU/8000/1");
+ break;
+ case 3:
+ audio_name = talloc_strdup(ctx, "GSM/8000/1");
+ break;
+ case 8:
+ audio_name = talloc_strdup(ctx, "PCMA/8000/1");
+ break;
+ case 18:
+ audio_name = talloc_strdup(ctx, "G729/8000/1");
+ break;
+ default:
+ /* The given payload type is not known to us, or it
+ * it is a dynamic payload type for which we do not
+ * know the audio name. We must give up here */
+ goto error;
+ }
+ }
+
+ /* Now we extract the codec subtype name, rate and channels. The latter
+ * two are optional. If they are not present we use the safe defaults
+ * above. */
+ if (strlen(audio_name) > sizeof(audio_codec))
+ goto error;
+ channels = DEFAULT_RTP_AUDIO_DEFAULT_CHANNELS;
+ rate = DEFAULT_RTP_AUDIO_DEFAULT_RATE;
+ if (sscanf(audio_name, "%63[^/]/%d/%d", audio_codec, &rate, &channels) < 1)
+ goto error;
+
+ /* Note: We only accept configurations with one audio channel! */
+ if (channels != 1)
+ goto error;
+
+ codec->rate = rate;
+ codec->channels = channels;
+ codec->subtype_name = talloc_strdup(ctx, audio_codec);
+ codec->audio_name = talloc_strdup(ctx, audio_name);
+ codec->payload_type = payload_type;
+
+ if (!strcmp(audio_codec, "G729")) {
+ codec->frame_duration_num = 10;
+ codec->frame_duration_den = 1000;
+ } else {
+ codec->frame_duration_num = DEFAULT_RTP_AUDIO_FRAME_DUR_NUM;
+ codec->frame_duration_den = DEFAULT_RTP_AUDIO_FRAME_DUR_DEN;
+ }
+
+ /* Derive the payload type if it is unknown */
+ if (codec->payload_type == PTYPE_UNDEFINED) {
+
+ /* For the known codecs from the static range we restore
+ * the IANA or 3GPP assigned payload type number */
+ if (codec->rate == 8000 && codec->channels == 1) {
+ /* See also: https://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml */
+ if (!strcmp(codec->subtype_name, "GSM"))
+ codec->payload_type = 3;
+ else if (!strcmp(codec->subtype_name, "PCMA"))
+ codec->payload_type = 8;
+ else if (!strcmp(codec->subtype_name, "PCMU"))
+ codec->payload_type = 0;
+ else if (!strcmp(codec->subtype_name, "G729"))
+ codec->payload_type = 18;
+
+ /* See also: 3GPP TS 48.103, chapter 5.4.2.2 RTP Payload
+ * Note: These are not fixed payload types as the IANA
+ * defined once, they still remain dymanic payload
+ * types, but with a payload type number preference. */
+ else if (!strcmp(codec->subtype_name, "GSM-EFR"))
+ codec->payload_type = 110;
+ else if (!strcmp(codec->subtype_name, "GSM-HR-08"))
+ codec->payload_type = 111;
+ else if (!strcmp(codec->subtype_name, "AMR"))
+ codec->payload_type = 112;
+ else if (!strcmp(codec->subtype_name, "AMR-WB"))
+ codec->payload_type = 113;
+ }
+
+ /* If we could not determine a payload type we assume that
+ * we are dealing with a codec from the dynamic range. We
+ * choose a fixed identifier from 96-109. (Note: normally,
+ * the dynamic payload type rante is from 96-127, but from
+ * 110 onwards 3gpp defines prefered codec types, which are
+ * also fixed, see above) */
+ if (codec->payload_type < 0) {
+ codec->payload_type = 96 + pt_offset;
+ if (codec->payload_type > 109)
+ goto error;
+ }
+ }
+
+ return 0;
+error:
+ /* Make sure we leave a clean codec entry on error. */
+ codec_init(codec);
+ memset(codec, 0, sizeof(*codec));
+ return -EINVAL;
+}
+
+/*! Add codec configuration depending on payload type and/or codec name. This
+ * function uses the input parameters to extrapolate the full codec information.
+ * \param[out] codec configuration (caller provided memory).
+ * \param[out] conn related rtp-connection.
+ * \param[in] payload_type codec type id (e.g. 3 for GSM, -1 when undefined).
+ * \param[in] audio_name audio codec name (e.g. "GSM/8000/1").
+ * \returns 0 on success, -EINVAL on failure. */
+int mgcp_codec_add(struct mgcp_conn_rtp *conn, int payload_type, const char *audio_name)
+{
+ int rc;
+
+ /* The amount of codecs we can store is limited, make sure we do not
+ * overrun this limit. */
+ if (conn->end.codecs_assigned >= MGCP_MAX_CODECS)
+ return -EINVAL;
+
+ rc = codec_set(conn->conn, &conn->end.codecs[conn->end.codecs_assigned], payload_type, audio_name,
+ conn->end.codecs_assigned);
+ if (rc != 0)
+ return -EINVAL;
+
+ conn->end.codecs_assigned++;
+
+ return 0;
+}
+
+/* Check if the given codec is applicable on the specified endpoint
+ * Helper function for mgcp_codec_decide() */
+static bool is_codec_compatible(const struct mgcp_endpoint *endp, const struct mgcp_rtp_codec *codec)
+{
+ char codec_name[64];
+
+ /* A codec name must be set, if not, this might mean that the codec
+ * (payload type) that was assigned is unknown to us so we must stop
+ * here. */
+ if (!codec->subtype_name)
+ return false;
+
+ /* We now extract the codec_name (letters before the /, e.g. "GSM"
+ * from the audio name that is stored in the trunk configuration.
+ * We do not compare to the full audio_name because we expect that
+ * "GSM", "GSM/8000" and "GSM/8000/1" are all compatible when the
+ * audio name of the codec is set to "GSM" */
+ if (sscanf(endp->tcfg->audio_name, "%63[^/]/%*d/%*d", codec_name) < 1)
+ return false;
+
+ /* Finally we check if the subtype_name we have generated from the
+ * audio_name in the trunc struct patches the codec_name of the
+ * given codec */
+ if (strcasecmp(codec_name, codec->subtype_name) == 0)
+ return true;
+
+ /* FIXME: It is questinable that the method to pick a compatible
+ * codec can work properly. Since this useses tcfg->audio_name, as
+ * a reference, which is set to "AMR/8000" permanently.
+ * tcfg->audio_name must be updated by the first connection that
+ * has been made on an endpoint, so that the second connection
+ * can make a meaningful decision here */
+
+ return false;
+}
+
+/*! Decide for one suitable codec
+ * \param[in] conn related rtp-connection.
+ * \returns 0 on success, -EINVAL on failure. */
+int mgcp_codec_decide(struct mgcp_conn_rtp *conn)
+{
+ struct mgcp_rtp_end *rtp;
+ unsigned int i;
+ struct mgcp_endpoint *endp;
+ bool codec_assigned = false;
+
+ endp = conn->conn->endp;
+ rtp = &conn->end;
+
+ /* This function works on the results the SDP/LCO parser has extracted
+ * from the MGCP message. The goal is to select a suitable codec for
+ * the given connection. When transcoding is available, the first codec
+ * from the codec list is taken without further checking. When
+ * transcoding is not available, then the choice must be made more
+ * carefully. Each codec in the list is checked until one is found that
+ * is rated compatible. The rating is done by the helper function
+ * is_codec_compatible(), which does the actual checking. */
+ for (i = 0; i < rtp->codecs_assigned; i++) {
+ /* When no transcoding is available, avoid codecs that would
+ * require transcoding. */
+ if (endp->tcfg->no_audio_transcoding && !is_codec_compatible(endp, &rtp->codecs[i])) {
+ LOGP(DLMGCP, LOGL_NOTICE, "transcoding not available, skipping codec: %d/%s\n",
+ rtp->codecs[i].payload_type, rtp->codecs[i].subtype_name);
+ continue;
+ }
+
+ rtp->codec = &rtp->codecs[i];
+ codec_assigned = true;
+ break;
+ }
+
+ /* FIXME: To the reviewes: This is problematic. I do not get why we
+ * need to reset the packet_duration_ms depending on the codec
+ * selection. I thought it were all 20ms? Is this to address some
+ * cornercase. (This piece of code was in the code path before,
+ * together with the note: "TODO/XXX: Store this per codec and derive
+ * it on use" */
+ if (codec_assigned) {
+ if (rtp->maximum_packet_time >= 0
+ && rtp->maximum_packet_time * rtp->codec->frame_duration_den >
+ rtp->codec->frame_duration_num * 1500)
+ rtp->packet_duration_ms = 0;
+
+ return 0;
+ }
+
+ return -EINVAL;
+}