pjsip_session_caps.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2020, Sangoma Technologies Corporation
 *
 * Kevin Harwell <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

#include "asterisk.h"

#include "asterisk/astobj2.h"
#include "asterisk/channel.h"
#include "asterisk/format.h"
#include "asterisk/format_cap.h"
#include "asterisk/logger.h"
#include "asterisk/sorcery.h"
#include "asterisk/stream.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/res_pjsip_session_caps.h"

static void log_caps(int level, const char *file, int line, const char *function,
   const struct ast_sip_session *session, enum ast_media_type media_type,
   const struct ast_format_cap *local, const struct ast_format_cap *remote,
   const struct ast_format_cap *joint)
{
   struct ast_str *s1;
   struct ast_str *s2;
   struct ast_str *s3;
   int outgoing = session->call_direction == AST_SIP_SESSION_OUTGOING_CALL;
   struct ast_flags pref =
      outgoing
      ? session->endpoint->media.outgoing_call_offer_pref
      : session->endpoint->media.incoming_call_offer_pref;

   if (level == __LOG_DEBUG && !DEBUG_ATLEAST(3)) {
      return;
   }

   s1 = local ? ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN) : NULL;
   s2 = remote ? ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN) : NULL;
   s3 = joint ? ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN) : NULL;

   ast_log(level, file, line, function, "'%s' Caps for %s %s call with pref '%s' - remote: %s local: %s joint: %s\n",
      session->channel ? ast_channel_name(session->channel) :
         ast_sorcery_object_get_id(session->endpoint),
      outgoing? "outgoing" : "incoming",
      ast_codec_media_type2str(media_type),
      ast_sip_call_codec_pref_to_str(pref),
      s2 ? ast_format_cap_get_names(remote, &s2) : "(NONE)",
      s1 ? ast_format_cap_get_names(local, &s1) : "(NONE)",
      s3 ? ast_format_cap_get_names(joint, &s3) : "(NONE)");
}

struct ast_format_cap *ast_sip_create_joint_call_cap(const struct ast_format_cap *remote,
   struct ast_format_cap *local, enum ast_media_type media_type,
   struct ast_flags codec_pref)
{
   struct ast_format_cap *joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   struct ast_format_cap *local_filtered = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   struct ast_format_cap *remote_filtered = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);

   if (!joint || !local_filtered || !remote_filtered) {
      ast_log(LOG_ERROR, "Failed to allocate %s call offer capabilities\n",
            ast_codec_media_type2str(media_type));
      ao2_cleanup(joint);
      ao2_cleanup(local_filtered);
      ao2_cleanup(remote_filtered);
      return NULL;
   }

   ast_format_cap_append_from_cap(local_filtered, local, media_type);

   /* Remote should always be a subset of local, as local is what defines the underlying
    * permitted formats.
    */
   ast_format_cap_get_compatible(remote, local_filtered, remote_filtered);

   if (ast_sip_call_codec_pref_test(codec_pref, LOCAL)) {
      if (ast_sip_call_codec_pref_test(codec_pref, INTERSECT)) {
         ast_format_cap_get_compatible(local_filtered, remote_filtered, joint); /* Get common, prefer local */
      } else {
         ast_format_cap_append_from_cap(joint, local_filtered, media_type); /* Add local */
         ast_format_cap_append_from_cap(joint, remote_filtered, media_type); /* Then remote */
      }
   } else {
      if (ast_sip_call_codec_pref_test(codec_pref, INTERSECT)) {
         joint = remote_filtered; /* Get common, prefer remote - as was done when filtering initially */
         remote_filtered = NULL;
      } else {
         ast_format_cap_append_from_cap(joint, remote_filtered, media_type); /* Add remote */
         ast_format_cap_append_from_cap(joint, local_filtered, media_type); /* Then local */
      }
   }

   ao2_ref(local_filtered, -1);
   ao2_cleanup(remote_filtered);

   if (ast_format_cap_empty(joint)) {
      return joint;
   }

   if (ast_sip_call_codec_pref_test(codec_pref, FIRST)) {
      /*
       * Save the most preferred one. Session capabilities are per stream and
       * a stream only carries a single media type, so no reason to worry with
       * the type here (i.e different or multiple types)
       */
      struct ast_format *single = ast_format_cap_get_format(joint, 0);
      /* Remove all formats */
      ast_format_cap_remove_by_type(joint, AST_MEDIA_TYPE_UNKNOWN);
      /* Put the most preferred one back */
      ast_format_cap_append(joint, single, 0);
      ao2_ref(single, -1);
   }

   return joint;
}

struct ast_stream *ast_sip_session_create_joint_call_stream(const struct ast_sip_session *session,
   struct ast_stream *remote_stream)
{
   struct ast_stream *joint_stream = ast_stream_clone(remote_stream, NULL);
   const struct ast_format_cap *remote = ast_stream_get_formats(remote_stream);
   enum ast_media_type media_type = ast_stream_get_type(remote_stream);

   struct ast_format_cap *joint = ast_sip_create_joint_call_cap(remote,
      session->endpoint->media.codecs, media_type,
      session->call_direction == AST_SIP_SESSION_OUTGOING_CALL
            ? session->endpoint->media.outgoing_call_offer_pref
            : session->endpoint->media.incoming_call_offer_pref);

   ast_stream_set_formats(joint_stream, joint);
   ao2_cleanup(joint);

   log_caps(LOG_DEBUG, session, media_type, session->endpoint->media.codecs, remote, joint);

   return joint_stream;
}

struct ast_format_cap *ast_sip_session_create_joint_call_cap(
   const struct ast_sip_session *session, enum ast_media_type media_type,
   const struct ast_format_cap *remote)
{
   struct ast_format_cap *joint = ast_sip_create_joint_call_cap(remote,
      session->endpoint->media.codecs, media_type,
      session->call_direction == AST_SIP_SESSION_OUTGOING_CALL
            ? session->endpoint->media.outgoing_call_offer_pref
            : session->endpoint->media.incoming_call_offer_pref);

   log_caps(LOG_DEBUG, session, media_type, session->endpoint->media.codecs, remote, joint);

   return joint;
}