res/res_format_attr_opus.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2013, Digium, Inc.
   5  *
   6  * Lorenzo Miniero <lorenzo@meetecho.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*!
  20  * \file
  21  * \brief Opus format attribute interface
  22  *
  23  * \author Lorenzo Miniero <lorenzo@meetecho.com>
  24  */
  25
  26 /*** MODULEINFO
  27         <support_level>core</support_level>
  28  ***/
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  33
  34 #include "asterisk/module.h"
  35 #include "asterisk/format.h"
  36
  37 /*!
  38  * \brief Opus attribute structure.
  39  *
  40  * \note http://tools.ietf.org/html/draft-ietf-payload-rtp-opus-00.
  41  */
  42 struct opus_attr {
  43         unsigned int maxbitrate;                /* Default 64-128 kb/s for FB stereo music */
  44         unsigned int maxplayrate                /* Default 48000 */;
  45         unsigned int minptime;              /* Default 3, but it's 10 in format.c */
  46         unsigned int stereo;                /* Default 0 */
  47         unsigned int cbr;                       /* Default 0 */
  48         unsigned int fec;                       /* Default 0 */
  49         unsigned int dtx;                       /* Default 0 */
  50         unsigned int spropmaxcapturerate;       /* Default 48000 */
  51         unsigned int spropstereo;               /* Default 0 */
  52 };
  53
  54 static int opus_sdp_parse(struct ast_format_attr *format_attr, const char *attributes)
  55 {
  56         struct opus_attr *attr = (struct opus_attr *) format_attr;
  57         const char *kvp;
  58         unsigned int val;
  59
  60         if ((kvp = strstr(attributes, "maxplaybackrate")) && sscanf(kvp, "maxplaybackrate=%30u", &val) == 1) {
  61                 attr->maxplayrate = val;
  62         }
  63         if ((kvp = strstr(attributes, "sprop-maxcapturerate")) && sscanf(kvp, "sprop-maxcapturerate=%30u", &val) == 1) {
  64                 attr->spropmaxcapturerate = val;
  65         }
  66         if ((kvp = strstr(attributes, "minptime")) && sscanf(kvp, "minptime=%30u", &val) == 1) {
  67                 attr->minptime = val;
  68         }
  69         if ((kvp = strstr(attributes, "maxaveragebitrate")) && sscanf(kvp, "maxaveragebitrate=%30u", &val) == 1) {
  70                 attr->maxbitrate = val;
  71         }
  72         if ((kvp = strstr(attributes, " stereo")) && sscanf(kvp, " stereo=%30u", &val) == 1) {
  73                 attr->stereo = val;
  74         }
  75         if ((kvp = strstr(attributes, ";stereo")) && sscanf(kvp, ";stereo=%30u", &val) == 1) {
  76                 attr->stereo = val;
  77         }
  78         if ((kvp = strstr(attributes, "sprop-stereo")) && sscanf(kvp, "sprop-stereo=%30u", &val) == 1) {
  79                 attr->spropstereo = val;
  80         }
  81         if ((kvp = strstr(attributes, "cbr")) && sscanf(kvp, "cbr=%30u", &val) == 1) {
  82                 attr->cbr = val;
  83         }
  84         if ((kvp = strstr(attributes, "useinbandfec")) && sscanf(kvp, "useinbandfec=%30u", &val) == 1) {
  85                 attr->fec = val;
  86         }
  87         if ((kvp = strstr(attributes, "usedtx")) && sscanf(kvp, "usedtx=%30u", &val) == 1) {
  88                 attr->dtx = val;
  89         }
  90
  91         return 0;
  92 }
  93
  94 static void opus_sdp_generate(const struct ast_format_attr *format_attr, unsigned int payload, struct ast_str **str)
  95 {
  96         struct opus_attr *attr = (struct opus_attr *) format_attr;
  97
  98         /* FIXME should we only generate attributes that were explicitly set? */
  99         ast_str_append(str, 0,
 100                                 "a=fmtp:%d "
 101                                         "maxplaybackrate=%d;"
 102                                         "sprop-maxcapturerate=%d;"
 103                                         "minptime=%d;"
 104                                         "maxaveragebitrate=%d;"
 105                                         "stereo=%d;"
 106                                         "sprop-stereo=%d;"
 107                                         "cbr=%d;"
 108                                         "useinbandfec=%d;"
 109                                         "usedtx=%d\r\n",
 110                         payload,
 111                         attr->maxplayrate ? attr->maxplayrate : 48000,  /* maxplaybackrate */
 112                         attr->spropmaxcapturerate ? attr->spropmaxcapturerate : 48000,  /* sprop-maxcapturerate */
 113                         attr->minptime > 10 ? attr->minptime : 10,      /* minptime */
 114                         attr->maxbitrate ? attr->maxbitrate : 20000,    /* maxaveragebitrate */
 115                         attr->stereo ? 1 : 0,           /* stereo */
 116                         attr->spropstereo ? 1 : 0,              /* sprop-stereo */
 117                         attr->cbr ? 1 : 0,              /* cbr */
 118                         attr->fec ? 1 : 0,              /* useinbandfec */
 119                         attr->dtx ? 1 : 0               /* usedtx */
 120         );
 121 }
 122
 123 static int opus_get_val(const struct ast_format_attr *fattr, int key, void *result)
 124 {
 125         const struct opus_attr *attr = (struct opus_attr *) fattr;
 126         int *val = result;
 127
 128         switch (key) {
 129         case OPUS_ATTR_KEY_MAX_BITRATE:
 130                 *val = attr->maxbitrate;
 131                 break;
 132         case OPUS_ATTR_KEY_MAX_PLAYRATE:
 133                 *val = attr->maxplayrate;
 134                 break;
 135         case OPUS_ATTR_KEY_MINPTIME:
 136                 *val = attr->minptime;
 137                 break;
 138         case OPUS_ATTR_KEY_STEREO:
 139                 *val = attr->stereo;
 140                 break;
 141         case OPUS_ATTR_KEY_CBR:
 142                 *val = attr->cbr;
 143                 break;
 144         case OPUS_ATTR_KEY_FEC:
 145                 *val = attr->fec;
 146                 break;
 147         case OPUS_ATTR_KEY_DTX:
 148                 *val = attr->dtx;
 149                 break;
 150         case OPUS_ATTR_KEY_SPROP_CAPTURE_RATE:
 151                 *val = attr->spropmaxcapturerate;
 152                 break;
 153         case OPUS_ATTR_KEY_SPROP_STEREO:
 154                 *val = attr->spropstereo;
 155                 break;
 156         default:
 157                 ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
 158                 return -1;
 159         }
 160         return 0;
 161 }
 162
 163 static int opus_isset(const struct ast_format_attr *fattr, va_list ap)
 164 {
 165         enum opus_attr_keys key;
 166         const struct opus_attr *attr = (struct opus_attr *) fattr;
 167
 168         for (key = va_arg(ap, int);
 169                 key != AST_FORMAT_ATTR_END;
 170                 key = va_arg(ap, int))
 171         {
 172                 switch (key) {
 173                 case OPUS_ATTR_KEY_MAX_BITRATE:
 174                         if (attr->maxbitrate != (va_arg(ap, int))) {
 175                                 return -1;
 176                         }
 177                         break;
 178                 case OPUS_ATTR_KEY_MAX_PLAYRATE:
 179                         if (attr->maxplayrate != (va_arg(ap, int))) {
 180                                 return -1;
 181                         }
 182                         break;
 183                 case OPUS_ATTR_KEY_MINPTIME:
 184                         if (attr->minptime != (va_arg(ap, int))) {
 185                                 return -1;
 186                         }
 187                         break;
 188                 case OPUS_ATTR_KEY_STEREO:
 189                         if (attr->stereo != (va_arg(ap, int))) {
 190                                 return -1;
 191                         }
 192                         break;
 193                 case OPUS_ATTR_KEY_CBR:
 194                         if (attr->cbr != (va_arg(ap, int))) {
 195                                 return -1;
 196                         }
 197                         break;
 198                 case OPUS_ATTR_KEY_FEC:
 199                         if (attr->fec != (va_arg(ap, int))) {
 200                                 return -1;
 201                         }
 202                         break;
 203                 case OPUS_ATTR_KEY_DTX:
 204                         if (attr->dtx != (va_arg(ap, int))) {
 205                                 return -1;
 206                         }
 207                         break;
 208                 case OPUS_ATTR_KEY_SPROP_CAPTURE_RATE:
 209                         if (attr->spropmaxcapturerate != (va_arg(ap, int))) {
 210                                 return -1;
 211                         }
 212                         break;
 213                 case OPUS_ATTR_KEY_SPROP_STEREO:
 214                         if (attr->spropstereo != (va_arg(ap, int))) {
 215                                 return -1;
 216                         }
 217                         break;
 218                 default:
 219                         ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
 220                         return -1;
 221                 }
 222         }
 223         return 0;
 224 }
 225 static int opus_getjoint(const struct ast_format_attr *fattr1, const struct ast_format_attr *fattr2, struct ast_format_attr *result)
 226 {
 227         struct opus_attr *attr1 = (struct opus_attr *) fattr1;
 228         struct opus_attr *attr2 = (struct opus_attr *) fattr2;
 229         struct opus_attr *attr_res = (struct opus_attr *) result;
 230         int joint = 0;
 231
 232         /* Only do dtx if both sides want it. DTX is a trade off between
 233          * computational complexity and bandwidth. */
 234         attr_res->dtx = attr1->dtx && attr2->dtx ? 1 : 0;
 235
 236         /* Only do FEC if both sides want it.  If a peer specifically requests not
 237          * to receive with FEC, it may be a waste of bandwidth. */
 238         attr_res->fec = attr1->fec && attr2->fec ? 1 : 0;
 239
 240         /* Only do stereo if both sides want it.  If a peer specifically requests not
 241          * to receive stereo signals, it may be a waste of bandwidth. */
 242         attr_res->stereo = attr1->stereo && attr2->stereo ? 1 : 0;
 243
 244         /* FIXME: do we need to join other attributes as well, e.g., minptime, cbr, etc.? */
 245
 246         return joint;
 247 }
 248
 249 static void opus_set(struct ast_format_attr *fattr, va_list ap)
 250 {
 251         enum opus_attr_keys key;
 252         struct opus_attr *attr = (struct opus_attr *) fattr;
 253
 254         for (key = va_arg(ap, int);
 255                 key != AST_FORMAT_ATTR_END;
 256                 key = va_arg(ap, int))
 257         {
 258                 switch (key) {
 259                 case OPUS_ATTR_KEY_MAX_BITRATE:
 260                         attr->maxbitrate = (va_arg(ap, int));
 261                         break;
 262                 case OPUS_ATTR_KEY_MAX_PLAYRATE:
 263                         attr->maxplayrate = (va_arg(ap, int));
 264                         break;
 265                 case OPUS_ATTR_KEY_MINPTIME:
 266                         attr->minptime = (va_arg(ap, int));
 267                         break;
 268                 case OPUS_ATTR_KEY_STEREO:
 269                         attr->stereo = (va_arg(ap, int));
 270                         break;
 271                 case OPUS_ATTR_KEY_CBR:
 272                         attr->cbr = (va_arg(ap, int));
 273                         break;
 274                 case OPUS_ATTR_KEY_FEC:
 275                         attr->fec = (va_arg(ap, int));
 276                         break;
 277                 case OPUS_ATTR_KEY_DTX:
 278                         attr->dtx = (va_arg(ap, int));
 279                         break;
 280                 case OPUS_ATTR_KEY_SPROP_CAPTURE_RATE:
 281                         attr->spropmaxcapturerate = (va_arg(ap, int));
 282                         break;
 283                 case OPUS_ATTR_KEY_SPROP_STEREO:
 284                         attr->spropstereo = (va_arg(ap, int));
 285                         break;
 286                 default:
 287                         ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
 288                 }
 289         }
 290 }
 291
 292 static struct ast_format_attr_interface opus_interface = {
 293         .id = AST_FORMAT_OPUS,
 294         .format_attr_get_joint = opus_getjoint,
 295         .format_attr_set = opus_set,
 296         .format_attr_isset = opus_isset,
 297         .format_attr_get_val = opus_get_val,
 298         .format_attr_sdp_parse = opus_sdp_parse,
 299         .format_attr_sdp_generate = opus_sdp_generate,
 300 };
 301
 302 static int load_module(void)
 303 {
 304         if (ast_format_attr_reg_interface(&opus_interface)) {
 305                 return AST_MODULE_LOAD_DECLINE;
 306         }
 307
 308         return AST_MODULE_LOAD_SUCCESS;
 309 }
 310
 311 static int unload_module(void)
 312 {
 313         ast_format_attr_unreg_interface(&opus_interface);
 314         return 0;
 315 }
 316
 317 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Opus Format Attribute Module",
 318         .load = load_module,
 319         .unload = unload_module,
 320         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
 321 );