res_format_attr_opus.c File Reference

Opus format attribute interface. More...

#include "asterisk.h"
#include <ctype.h>
#include "asterisk/module.h"
#include "asterisk/format.h"
#include "asterisk/astobj2.h"
#include "asterisk/logger.h"
#include "asterisk/strings.h"
#include "asterisk/utils.h"
#include "asterisk/opus.h"

Include dependency graph for res_format_attr_opus.c:

Go to the source code of this file.

Data Structures
struct	opus_attr
	Opus attribute structure. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static int	opus_clone (const struct ast_format *src, struct ast_format *dst)
static void	opus_destroy (struct ast_format *format)
static void	opus_generate_sdp_fmtp (const struct ast_format *format, unsigned int payload, struct ast_str **str)
static const void *	opus_get (const struct ast_format *format, const char *name)
static struct ast_format *	opus_getjoint (const struct ast_format *format1, const struct ast_format *format2)
static struct ast_format *	opus_parse_sdp_fmtp (const struct ast_format *format, const char *attributes)
static struct ast_format *	opus_set (const struct ast_format *format, const char *name, const char *value)
static void	sdp_fmtp_get (const char *attributes, const char *name, int *attr)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Opus Format Attribute Module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct opus_attr	default_opus_attr
static struct ast_format_interface	opus_interface

Detailed Description

Opus format attribute interface.

Author

Lorenzo Miniero loren.nosp@m.zo@m.nosp@m.eetec.nosp@m.ho.c.nosp@m.om

Definition in file res_format_attr_opus.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 417 of file res_format_attr_opus.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 417 of file res_format_attr_opus.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 417 of file res_format_attr_opus.c.

load_module()

static int load_module ( void  )

static

Definition at line 398 of file res_format_attr_opus.c.

References __ast_format_interface_register(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, and ast_module_info::self.

Referenced by unload_module().

{
   if (__ast_format_interface_register("opus", &opus_interface, ast_module_info->self)) {
      return AST_MODULE_LOAD_DECLINE;
   }

   return AST_MODULE_LOAD_SUCCESS;
}

opus_clone()

static int opus_clone ( const struct ast_format *  src, struct ast_format *  dst  )

static

Definition at line 87 of file res_format_attr_opus.c.

References ao2_bump, ast_format_get_attribute_data(), ast_format_get_channel_count(), ast_format_set_attribute_data(), ast_format_set_channel_count(), ast_malloc, opus_attr::data, and default_opus_attr.

{
   struct opus_attr *original = ast_format_get_attribute_data(src);
   struct opus_attr *attr = ast_malloc(sizeof(*attr));

   if (!attr) {
      return -1;
   }

   *attr = original ? *original : default_opus_attr;
   ao2_bump(attr->data);

   ast_format_set_attribute_data(dst, attr);
   ast_format_set_channel_count(dst, ast_format_get_channel_count(src));

   return 0;
}

opus_destroy()

static void opus_destroy ( struct ast_format *  format )

static

Definition at line 75 of file res_format_attr_opus.c.

References ao2_cleanup, ast_format_get_attribute_data(), ast_free, and opus_attr::data.

{
   struct opus_attr *attr = ast_format_get_attribute_data(format);

   if (!attr) {
      return;
   }

   ao2_cleanup(attr->data);
   ast_free(attr);
}

opus_generate_sdp_fmtp()

static void opus_generate_sdp_fmtp ( const struct ast_format *  format, unsigned int  payload, struct ast_str **  str  )

static

Definition at line 177 of file res_format_attr_opus.c.

References ast_format_get_attribute_data(), ast_str_append(), ast_str_strlen(), ast_str_truncate(), opus_attr::cbr, CODEC_OPUS_ATTR_CBR, CODEC_OPUS_ATTR_DTX, CODEC_OPUS_ATTR_FEC, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE, CODEC_OPUS_ATTR_SPROP_STEREO, CODEC_OPUS_ATTR_STEREO, CODEC_OPUS_DEFAULT_BITRATE, CODEC_OPUS_DEFAULT_CBR, CODEC_OPUS_DEFAULT_DTX, CODEC_OPUS_DEFAULT_FEC, CODEC_OPUS_DEFAULT_SAMPLE_RATE, CODEC_OPUS_DEFAULT_STEREO, default_opus_attr, opus_attr::dtx, opus_attr::fec, opus_attr::maxbitrate, opus_attr::maxplayrate, opus_attr::spropmaxcapturerate, opus_attr::spropstereo, and opus_attr::stereo.

{
   struct opus_attr *attr = ast_format_get_attribute_data(format);
   int base_fmtp_size;
   int original_size;

   if (!attr) {
      /*
       * (Only) cached formats do not have attribute data assigned because
       * they were created before this attribute module was registered.
       * Therefore, we assume the default attribute values here.
       */
      attr = &default_opus_attr;
   }

   original_size = ast_str_strlen(*str);
   base_fmtp_size = ast_str_append(str, 0, "a=fmtp:%u ", payload);

   if (CODEC_OPUS_DEFAULT_SAMPLE_RATE != attr->maxplayrate) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, attr->maxplayrate);
   }

   if (CODEC_OPUS_DEFAULT_SAMPLE_RATE != attr->spropmaxcapturerate) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE, attr->spropmaxcapturerate);
   }

   if (CODEC_OPUS_DEFAULT_BITRATE != attr->maxbitrate || attr->maxbitrate > 0) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, attr->maxbitrate);
   }

   if (CODEC_OPUS_DEFAULT_STEREO != attr->stereo) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_STEREO, attr->stereo);
   }

   if (CODEC_OPUS_DEFAULT_STEREO != attr->spropstereo) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_SPROP_STEREO, attr->spropstereo);
   }

   if (CODEC_OPUS_DEFAULT_CBR != attr->cbr) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_CBR, attr->cbr);
   }

   if (CODEC_OPUS_DEFAULT_FEC!= attr->fec) {
      ast_str_append(str, 0, "%s=%d;",
             CODEC_OPUS_ATTR_FEC, attr->fec);
   }

   if (CODEC_OPUS_DEFAULT_DTX != attr->dtx) {
      ast_str_append(str, 0, "%s=%d;",
         CODEC_OPUS_ATTR_DTX, attr->dtx);
   }

   if (base_fmtp_size == ast_str_strlen(*str) - original_size) {
      ast_str_truncate(*str, original_size);
   } else {
      ast_str_truncate(*str, -1);
      ast_str_append(str, 0, "\r\n");
   }
}

opus_get()

static const void* opus_get ( const struct ast_format *  format, const char *  name  )

static

Definition at line 350 of file res_format_attr_opus.c.

References ao2_bump, ast_format_get_attribute_data(), ast_log, opus_attr::cbr, CODEC_OPUS_ATTR_CBR, CODEC_OPUS_ATTR_DATA, CODEC_OPUS_ATTR_DTX, CODEC_OPUS_ATTR_FEC, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, CODEC_OPUS_ATTR_MAX_PTIME, CODEC_OPUS_ATTR_PTIME, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE, CODEC_OPUS_ATTR_SPROP_STEREO, CODEC_OPUS_ATTR_STEREO, opus_attr::data, opus_attr::dtx, opus_attr::fec, LOG_WARNING, opus_attr::maxbitrate, opus_attr::maxplayrate, opus_attr::maxptime, NULL, opus_attr::ptime, opus_attr::spropmaxcapturerate, opus_attr::spropstereo, and opus_attr::stereo.

{
   struct opus_attr *attr = ast_format_get_attribute_data(format);
   int *val = NULL;

   if (!attr) {
      return NULL;
   }

   if (!strcasecmp(name, CODEC_OPUS_ATTR_DATA)) {
      return ao2_bump(attr->data);
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE)) {
      val = &attr->maxplayrate;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE)) {
      val = &attr->spropmaxcapturerate;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_PTIME)) {
      val = &attr->maxptime;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_PTIME)) {
      val = &attr->ptime;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE)) {
      val = &attr->maxbitrate;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_STEREO)) {
      val = &attr->stereo;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_SPROP_STEREO)) {
      val = &attr->spropstereo;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_CBR)) {
      val = &attr->cbr;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_FEC)) {
      val = &attr->fec;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_DTX)) {
      val = &attr->dtx;
   } else {
      ast_log(LOG_WARNING, "unknown attribute type %s\n", name);
   }

   return val;
}

opus_getjoint()

static struct ast_format* opus_getjoint ( const struct ast_format *  format1, const struct ast_format *  format2  )

static

Definition at line 243 of file res_format_attr_opus.c.

References ast_format_clone(), ast_format_get_attribute_data(), ast_format_get_channel_count(), ast_format_set_channel_count(), opus_attr::cbr, default_opus_attr, opus_attr::dtx, opus_attr::fec, opus_attr::maxbitrate, opus_attr::maxplayrate, MIN, NULL, opus_attr::spropmaxcapturerate, opus_attr::spropstereo, and opus_attr::stereo.

{
   struct opus_attr *attr1 = ast_format_get_attribute_data(format1);
   struct opus_attr *attr2 = ast_format_get_attribute_data(format2);
   struct ast_format *jointformat;
   struct opus_attr *attr_res;

   if (!attr1) {
      attr1 = &default_opus_attr;
   }

   if (!attr2) {
      attr2 = &default_opus_attr;
   }

   jointformat = ast_format_clone(format1);
   if (!jointformat) {
      return NULL;
   }

   if (ast_format_get_channel_count(format1) == 2 || ast_format_get_channel_count(format2) == 2) {
      ast_format_set_channel_count(jointformat, 2);
   }
   attr_res = ast_format_get_attribute_data(jointformat);

   attr_res->dtx = attr1->dtx || attr2->dtx ? 1 : 0;

   /* Only do FEC if both sides want it.  If a peer specifically requests not
    * to receive with FEC, it may be a waste of bandwidth. */
   attr_res->fec = attr1->fec && attr2->fec ? 1 : 0;

   attr_res->cbr = attr1->cbr || attr2->cbr ? 1 : 0;
   attr_res->spropstereo = attr1->spropstereo || attr2->spropstereo ? 1 : 0;

   /* Only do stereo if both sides want it.  If a peer specifically requests not
    * to receive stereo signals, it may be a waste of bandwidth. */
   attr_res->stereo = attr1->stereo && attr2->stereo ? 1 : 0;

   if (attr1->maxbitrate < 0) {
      attr_res->maxbitrate = attr2->maxbitrate;
   } else if (attr2->maxbitrate < 0) {
      attr_res->maxbitrate = attr1->maxbitrate;
   } else {
      attr_res->maxbitrate = MIN(attr1->maxbitrate, attr2->maxbitrate);
   }

   attr_res->spropmaxcapturerate = MIN(attr1->spropmaxcapturerate, attr2->spropmaxcapturerate);
   attr_res->maxplayrate = MIN(attr1->maxplayrate, attr2->maxplayrate);

   return jointformat;
}

opus_parse_sdp_fmtp()

static struct ast_format* opus_parse_sdp_fmtp ( const struct ast_format *  format, const char *  attributes  )

static

Definition at line 139 of file res_format_attr_opus.c.

References ast_format_clone(), ast_format_get_attribute_data(), ast_format_set_channel_count(), ast_strdupa, opus_attr::cbr, CODEC_OPUS_ATTR_CBR, CODEC_OPUS_ATTR_DTX, CODEC_OPUS_ATTR_FEC, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, CODEC_OPUS_ATTR_MAX_CODED_AUDIO_BANDWIDTH, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, CODEC_OPUS_ATTR_MAX_PTIME, CODEC_OPUS_ATTR_PTIME, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE, CODEC_OPUS_ATTR_SPROP_STEREO, CODEC_OPUS_ATTR_STEREO, opus_attr::dtx, opus_attr::fec, opus_attr::maxbitrate, opus_attr::maxplayrate, opus_attr::maxptime, NULL, opus_attr::ptime, sdp_fmtp_get(), opus_attr::spropmaxcapturerate, opus_attr::spropstereo, and opus_attr::stereo.

{
   char *attribs = ast_strdupa(attributes), *attrib;
   struct ast_format *cloned;
   struct opus_attr *attr;

   cloned = ast_format_clone(format);
   if (!cloned) {
      return NULL;
   }

   attr = ast_format_get_attribute_data(cloned);

   /* lower-case everything, so we are case-insensitive */
   for (attrib = attribs; *attrib; ++attrib) {
      *attrib = tolower(*attrib);
   } /* based on channels/chan_sip.c:process_a_sdp_image() */

   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, &attr->maxplayrate);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_MAX_CODED_AUDIO_BANDWIDTH,
      &attr->maxplayrate);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE,
      &attr->spropmaxcapturerate);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_MAX_PTIME, &attr->maxptime);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_PTIME, &attr->ptime);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, &attr->maxbitrate);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_STEREO, &attr->stereo);
   if (attr->stereo) {
      ast_format_set_channel_count(cloned, 2);
   }
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_SPROP_STEREO, &attr->spropstereo);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_CBR, &attr->cbr);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_FEC, &attr->fec);
   sdp_fmtp_get(attribs, CODEC_OPUS_ATTR_DTX, &attr->dtx);

   return cloned;
}

opus_set()

static struct ast_format* opus_set ( const struct ast_format *  format, const char *  name, const char *  value  )

static

Definition at line 295 of file res_format_attr_opus.c.

References ao2_bump, ao2_cleanup, ao2_ref, ast_format_clone(), ast_format_get_attribute_data(), ast_log, opus_attr::cbr, CODEC_OPUS_ATTR_CBR, CODEC_OPUS_ATTR_DATA, CODEC_OPUS_ATTR_DTX, CODEC_OPUS_ATTR_FEC, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE, CODEC_OPUS_ATTR_MAX_CODED_AUDIO_BANDWIDTH, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE, CODEC_OPUS_ATTR_MAX_PTIME, CODEC_OPUS_ATTR_PTIME, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE, CODEC_OPUS_ATTR_SPROP_STEREO, CODEC_OPUS_ATTR_STEREO, opus_attr::data, opus_attr::dtx, opus_attr::fec, LOG_WARNING, opus_attr::maxbitrate, opus_attr::maxplayrate, opus_attr::maxptime, NULL, opus_attr::ptime, opus_attr::spropmaxcapturerate, opus_attr::spropstereo, and opus_attr::stereo.

{
   struct ast_format *cloned;
   struct opus_attr *attr;
   int val;

   if (!(cloned = ast_format_clone(format))) {
      return NULL;
   }

   attr = ast_format_get_attribute_data(cloned);

   if (!strcmp(name, CODEC_OPUS_ATTR_DATA)) {
      ao2_cleanup(attr->data);
      attr->data = ao2_bump((void*)value);
      return cloned;
   }

   if (sscanf(value, "%30d", &val) != 1) {
      ast_log(LOG_WARNING, "Unknown value '%s' for attribute type '%s'\n",
         value, name);
      ao2_ref(cloned, -1);
      return NULL;
   }

   if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_PLAYBACK_RATE)) {
      attr->maxplayrate = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_CODED_AUDIO_BANDWIDTH)) {
      attr->maxplayrate = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_SPROP_MAX_CAPTURE_RATE)) {
      attr->spropmaxcapturerate = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_PTIME)) {
      attr->maxptime = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_PTIME)) {
      attr->ptime = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_MAX_AVERAGE_BITRATE)) {
      attr->maxbitrate = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_STEREO)) {
      attr->stereo = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_SPROP_STEREO)) {
      attr->spropstereo = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_CBR)) {
      attr->cbr = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_FEC)) {
      attr->fec = val;
   } else if (!strcasecmp(name, CODEC_OPUS_ATTR_DTX)) {
      attr->dtx = val;
   } else {
      ast_log(LOG_WARNING, "unknown attribute type %s\n", name);
   }

   return cloned;
}

sdp_fmtp_get()

static void sdp_fmtp_get ( const char *  attributes, const char *  name, int *  attr  )

static

Definition at line 105 of file res_format_attr_opus.c.

References ast_skip_blanks(), and ast_strlen_zero.

Referenced by opus_parse_sdp_fmtp().

{
   const char *kvp = attributes;
   int val;

   if (ast_strlen_zero(attributes)) {
      return;
   }

   /* This logic goes through each attribute in the fmtp line looking for the
    * requested named attribute.
    */
   while (*kvp) {
      /* Skip any preceeding blanks as some implementations separate attributes using spaces too */
      kvp = ast_skip_blanks(kvp);

      /* If we are at the requested attribute get its value and return */
      if (!strncmp(kvp, name, strlen(name)) && kvp[strlen(name)] == '=') {
         if (sscanf(kvp, "%*[^=]=%30d", &val) == 1) {
            *attr = val;
            break;
         }
      }

      /* Move on to the next attribute if possible */
      kvp = strchr(kvp, ';');
      if (!kvp) {
         break;
      }

      kvp++;
   }
}

unload_module()

static int unload_module ( void  )

static

Definition at line 407 of file res_format_attr_opus.c.

References AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_REALTIME_DRIVER, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, and load_module().

{
   return 0;
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Opus Format Attribute Module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER }

static

Definition at line 417 of file res_format_attr_opus.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 417 of file res_format_attr_opus.c.

default_opus_attr

struct opus_attr default_opus_attr

static

Definition at line 62 of file res_format_attr_opus.c.

Referenced by opus_clone(), opus_generate_sdp_fmtp(), and opus_getjoint().

opus_interface

struct ast_format_interface opus_interface

static

Definition at line 388 of file res_format_attr_opus.c.