main/format.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2010, Digium, Inc.
   5  *
   6  * David Vossel <dvossel@digium.com>
   7  * Mark Spencer <markster@digium.com>
   8  *
   9  * See http://www.asterisk.org for more information about
  10  * the Asterisk project. Please do not directly contact
  11  * any of the maintainers of this project for assistance;
  12  * the project provides a web site, mailing lists and IRC
  13  * channels for your use.
  14  *
  15  * This program is free software, distributed under the terms of
  16  * the GNU General Public License Version 2. See the LICENSE file
  17  * at the top of the source tree.
  18  */
  19
  20 /*!
  21  * \file
  22  * \brief Format API
  23  *
  24  * \author David Vossel <dvossel@digium.com>
  25  * \author Mark Spencer <markster@digium.com>
  26  */
  27
  28 /*** MODULEINFO
  29         <support_level>core</support_level>
  30  ***/
  31
  32 #include "asterisk.h"
  33
  34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
  35
  36 #include "asterisk/_private.h"
  37 #include "asterisk/format.h"
  38 #include "asterisk/astobj2.h"
  39 #include "asterisk/lock.h"
  40 #include "asterisk/frame.h"
  41 #include "asterisk/utils.h"
  42 #include "asterisk/cli.h"
  43 #include "asterisk/rtp_engine.h"
  44 #include "asterisk/config.h"
  45
  46 #define FORMAT_CONFIG "codecs.conf"
  47
  48 /*!
  49  * \brief Container for all the format attribute interfaces.
  50  * \note This container uses RWLOCKs instead of MUTEX locks.                                                             .
  51  * \note An ao2 container was chosen for fast lookup.
  52  */
  53 static struct ao2_container *interfaces;
  54
  55 /*! a wrapper is used put interfaces into the ao2 container. */
  56 struct interface_ao2_wrapper {
  57         enum ast_format_id id;
  58         const struct ast_format_attr_interface *interface;
  59 };
  60
  61 /*! \brief Format List container, This container is never directly accessed outside
  62  * of this file, and It only exists for building the format_list_array. */
  63 static struct ao2_container *format_list;
  64 /*! \brief Format List array is a read only array protected by a read write lock.
  65  * This array may be used outside this file with the use of reference counting to
  66  * guarantee safety for access by multiple threads. */
  67 static struct ast_format_list *format_list_array;
  68 static size_t format_list_array_len = 0;
  69 /*! \brief Locks the format list array so a reference can be taken safely. */
  70 static ast_rwlock_t format_list_array_lock;
  71
  72 static int interface_cmp_cb(void *obj, void *arg, int flags)
  73 {
  74         struct interface_ao2_wrapper *wrapper1 = obj;
  75         struct interface_ao2_wrapper *wrapper2 = arg;
  76
  77         return (wrapper2->id == wrapper1->id) ? CMP_MATCH | CMP_STOP : 0;
  78 }
  79
  80 static int interface_hash_cb(const void *obj, const int flags)
  81 {
  82         const struct interface_ao2_wrapper *wrapper = obj;
  83         return wrapper->id;
  84 }
  85
  86 void ast_format_copy(struct ast_format *dst, const struct ast_format *src)
  87 {
  88         *dst = *src;
  89 }
  90
  91 void ast_format_set_video_mark(struct ast_format *format)
  92 {
  93         format->fattr.rtp_marker_bit = 1;
  94 }
  95
  96 int ast_format_get_video_mark(const struct ast_format *format)
  97 {
  98         return format->fattr.rtp_marker_bit;
  99 }
 100
 101 static struct interface_ao2_wrapper *find_interface(const struct ast_format *format)
 102 {
 103         struct interface_ao2_wrapper tmp_wrapper = {
 104                 .id = format->id,
 105         };
 106
 107         return ao2_find(interfaces, &tmp_wrapper, OBJ_POINTER);
 108 }
 109
 110 static int has_interface(const struct ast_format *format)
 111 {
 112         struct interface_ao2_wrapper *wrapper;
 113
 114         wrapper = find_interface(format);
 115         if (!wrapper) {
 116                 return 0;
 117         }
 118         ao2_ref(wrapper, -1);
 119         return 1;
 120 }
 121
 122 int ast_format_sdp_parse(struct ast_format *format, const char *attributes)
 123 {
 124         struct interface_ao2_wrapper *wrapper;
 125         int res;
 126
 127         if (!(wrapper = find_interface(format))) {
 128                 return 0;
 129         }
 130
 131         ao2_rdlock(wrapper);
 132         if (!(wrapper->interface || !wrapper->interface->format_attr_sdp_parse)) {
 133                 ao2_unlock(wrapper);
 134                 ao2_ref(wrapper, -1);
 135                 return 0;
 136         }
 137
 138         res = wrapper->interface->format_attr_sdp_parse(&format->fattr, attributes);
 139
 140         ao2_unlock(wrapper);
 141         ao2_ref(wrapper, -1);
 142
 143         return res;
 144 }
 145
 146 void ast_format_sdp_generate(const struct ast_format *format, unsigned int payload, struct ast_str **str)
 147 {
 148         struct interface_ao2_wrapper *wrapper;
 149
 150         if (!(wrapper = find_interface(format))) {
 151                 return;
 152         }
 153
 154         ao2_rdlock(wrapper);
 155         if (!(wrapper->interface || !wrapper->interface->format_attr_sdp_generate)) {
 156                 ao2_unlock(wrapper);
 157                 ao2_ref(wrapper, -1);
 158                 return;
 159         }
 160
 161         wrapper->interface->format_attr_sdp_generate(&format->fattr, payload, str);
 162
 163         ao2_unlock(wrapper);
 164         ao2_ref(wrapper, -1);
 165 }
 166
 167 /*! \internal
 168  * \brief set format attributes using an interface
 169  */
 170 static int format_set_helper(struct ast_format *format, va_list ap)
 171 {
 172         struct interface_ao2_wrapper *wrapper;
 173
 174         if (!(wrapper = find_interface(format))) {
 175                 ast_log(LOG_WARNING, "Could not find format interface to set.\n");
 176                 return -1;
 177         }
 178
 179         ao2_rdlock(wrapper);
 180         if (!wrapper->interface || !wrapper->interface->format_attr_set) {
 181                 ao2_unlock(wrapper);
 182                 ao2_ref(wrapper, -1);
 183                 return -1;
 184         }
 185
 186         wrapper->interface->format_attr_set(&format->fattr, ap);
 187
 188         ao2_unlock(wrapper);
 189         ao2_ref(wrapper, -1);
 190
 191         return 0;
 192 }
 193
 194 struct ast_format *ast_format_append(struct ast_format *format, ... )
 195 {
 196         va_list ap;
 197         va_start(ap, format);
 198         format_set_helper(format, ap);
 199         va_end(ap);
 200
 201         return format;
 202 }
 203
 204 struct ast_format *ast_format_set(struct ast_format *format, enum ast_format_id id, int set_attributes, ... )
 205 {
 206         /* initialize the structure before setting it. */
 207         ast_format_clear(format);
 208
 209         format->id = id;
 210
 211         if (set_attributes) {
 212                 va_list ap;
 213                 va_start(ap, set_attributes);
 214                 format_set_helper(format, ap);
 215                 va_end(ap);
 216         }
 217
 218         return format;
 219 }
 220
 221 void ast_format_clear(struct ast_format *format)
 222 {
 223         format->id = 0;
 224         memset(&format->fattr, 0, sizeof(format->fattr));
 225 }
 226
 227 /*! \internal
 228  * \brief determine if a list of attribute key value pairs are set on a format
 229  */
 230 static int format_isset_helper(const struct ast_format *format, va_list ap)
 231 {
 232         int res;
 233         struct interface_ao2_wrapper *wrapper;
 234         struct ast_format tmp = {
 235                 .id = format->id,
 236                 .fattr = { { 0, }, },
 237         };
 238
 239         if (!(wrapper = find_interface(format))) {
 240                 return -1;
 241         }
 242
 243         ao2_rdlock(wrapper);
 244         if (!wrapper->interface ||
 245                 !wrapper->interface->format_attr_set ||
 246                 !wrapper->interface->format_attr_cmp) {
 247
 248                 ao2_unlock(wrapper);
 249                 ao2_ref(wrapper, -1);
 250                 return -1;
 251         }
 252
 253         /* if isset is present, use that function, else just build a new
 254          * format and use the cmp function */
 255         if (wrapper->interface->format_attr_isset) {
 256                 res = wrapper->interface->format_attr_isset(&format->fattr, ap);
 257         } else {
 258                 wrapper->interface->format_attr_set(&tmp.fattr, ap);
 259                 /* use our tmp structure to tell if the attributes are set or not */
 260                 res = wrapper->interface->format_attr_cmp(&tmp.fattr, &format->fattr);
 261                 res = (res == AST_FORMAT_CMP_NOT_EQUAL) ? -1 : 0;
 262         }
 263
 264         ao2_unlock(wrapper);
 265         ao2_ref(wrapper, -1);
 266
 267         return res;
 268 }
 269
 270 int ast_format_isset(const struct ast_format *format, ... )
 271 {
 272         va_list ap;
 273         int res;
 274
 275         va_start(ap, format);
 276         res = format_isset_helper(format, ap);
 277         va_end(ap);
 278         return res;
 279 }
 280
 281 int ast_format_get_value(const struct ast_format *format, int key, void *value)
 282 {
 283         int res = 0;
 284         struct interface_ao2_wrapper *wrapper;
 285
 286         if (!(wrapper = find_interface(format))) {
 287                 return -1;
 288         }
 289         ao2_rdlock(wrapper);
 290         if (!wrapper->interface ||
 291                 !wrapper->interface->format_attr_get_val) {
 292
 293                 ao2_unlock(wrapper);
 294                 ao2_ref(wrapper, -1);
 295                 return -1;
 296         }
 297
 298         res = wrapper->interface->format_attr_get_val(&format->fattr, key, value);
 299
 300         ao2_unlock(wrapper);
 301         ao2_ref(wrapper, -1);
 302
 303         return res;
 304 }
 305
 306 /*! \internal
 307  * \brief cmp format attributes using an interface
 308  */
 309 static enum ast_format_cmp_res format_cmp_helper(const struct ast_format *format1, const struct ast_format *format2)
 310 {
 311         enum ast_format_cmp_res res = AST_FORMAT_CMP_EQUAL;
 312         struct interface_ao2_wrapper *wrapper;
 313
 314         if (!(wrapper = find_interface(format1))) {
 315                 return res;
 316         }
 317
 318         ao2_rdlock(wrapper);
 319         if (!wrapper->interface || !wrapper->interface->format_attr_cmp) {
 320                 ao2_unlock(wrapper);
 321                 ao2_ref(wrapper, -1);
 322                 return res;
 323         }
 324
 325         res = wrapper->interface->format_attr_cmp(&format1->fattr, &format2->fattr);
 326
 327         ao2_unlock(wrapper);
 328         ao2_ref(wrapper, -1);
 329
 330         return res;
 331 }
 332
 333 enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
 334 {
 335         if (format1->id != format2->id) {
 336                 return AST_FORMAT_CMP_NOT_EQUAL;
 337         }
 338
 339         return format_cmp_helper(format1, format2);
 340 }
 341
 342 /*! \internal
 343  * \brief get joint format attributes using an interface
 344  */
 345 static int format_joint_helper(const struct ast_format *format1, const struct ast_format *format2, struct ast_format *result)
 346 {
 347         int res = 0;
 348         struct interface_ao2_wrapper *wrapper;
 349
 350         if (!(wrapper = find_interface(format1))) {
 351                 /* if no interface is present, we assume formats are joint by id alone */
 352                 return res;
 353         }
 354
 355         ao2_rdlock(wrapper);
 356         if (wrapper->interface && wrapper->interface->format_attr_get_joint) {
 357                 res = wrapper->interface->format_attr_get_joint(&format1->fattr, &format2->fattr, &result->fattr);
 358         }
 359         ao2_unlock(wrapper);
 360
 361         ao2_ref(wrapper, -1);
 362
 363         return res;
 364 }
 365
 366 int ast_format_joint(const struct ast_format *format1, const struct ast_format *format2, struct ast_format *result)
 367 {
 368         if (format1->id != format2->id) {
 369                 return -1;
 370         }
 371         result->id = format1->id;
 372         return format_joint_helper(format1, format2, result);
 373 }
 374
 375
 376 uint64_t ast_format_id_to_old_bitfield(enum ast_format_id id)
 377 {
 378         switch (id) {
 379         /*! G.723.1 compression */
 380         case AST_FORMAT_G723_1:
 381                 return (1ULL << 0);
 382         /*! GSM compression */
 383         case AST_FORMAT_GSM:
 384                 return (1ULL << 1);
 385         /*! Raw mu-law data (G.711) */
 386         case AST_FORMAT_ULAW:
 387                 return (1ULL << 2);
 388         /*! Raw A-law data (G.711) */
 389         case AST_FORMAT_ALAW:
 390                 return (1ULL << 3);
 391         /*! ADPCM (G.726, 32kbps, AAL2 codeword packing) */
 392         case AST_FORMAT_G726_AAL2:
 393                 return (1ULL << 4);
 394         /*! ADPCM (IMA) */
 395         case AST_FORMAT_ADPCM:
 396                 return (1ULL << 5);
 397         /*! Raw 16-bit Signed Linear (8000 Hz) PCM */
 398         case AST_FORMAT_SLINEAR:
 399                 return (1ULL << 6);
 400         /*! LPC10, 180 samples/frame */
 401         case AST_FORMAT_LPC10:
 402                 return (1ULL << 7);
 403         /*! G.729A audio */
 404         case AST_FORMAT_G729A:
 405                 return (1ULL << 8);
 406         /*! SpeeX Free Compression */
 407         case AST_FORMAT_SPEEX:
 408                 return (1ULL << 9);
 409         /*! iLBC Free Compression */
 410         case AST_FORMAT_ILBC:
 411                 return (1ULL << 10);
 412         /*! ADPCM (G.726, 32kbps, RFC3551 codeword packing) */
 413         case AST_FORMAT_G726:
 414                 return (1ULL << 11);
 415         /*! G.722 */
 416         case AST_FORMAT_G722:
 417                 return (1ULL << 12);
 418         /*! G.722.1 (also known as Siren7, 32kbps assumed) */
 419         case AST_FORMAT_SIREN7:
 420                 return (1ULL << 13);
 421         /*! G.722.1 Annex C (also known as Siren14, 48kbps assumed) */
 422         case AST_FORMAT_SIREN14:
 423                 return (1ULL << 14);
 424         /*! Raw 16-bit Signed Linear (16000 Hz) PCM */
 425         case AST_FORMAT_SLINEAR16:
 426                 return (1ULL << 15);
 427         /*! G.719 (64 kbps assumed) */
 428         case AST_FORMAT_G719:
 429                 return (1ULL << 32);
 430         /*! SpeeX Wideband (16kHz) Free Compression */
 431         case AST_FORMAT_SPEEX16:
 432                 return (1ULL << 33);
 433         /*! Raw mu-law data (G.711) */
 434         case AST_FORMAT_TESTLAW:
 435                 return (1ULL << 47);
 436
 437         /*! H.261 Video */
 438         case AST_FORMAT_H261:
 439                 return (1ULL << 18);
 440         /*! H.263 Video */
 441         case AST_FORMAT_H263:
 442                 return (1ULL << 19);
 443         /*! H.263+ Video */
 444         case AST_FORMAT_H263_PLUS:
 445                 return (1ULL << 20);
 446         /*! H.264 Video */
 447         case AST_FORMAT_H264:
 448                 return (1ULL << 21);
 449         /*! MPEG4 Video */
 450         case AST_FORMAT_MP4_VIDEO:
 451                 return (1ULL << 22);
 452
 453         /*! JPEG Images */
 454         case AST_FORMAT_JPEG:
 455                 return (1ULL << 16);
 456         /*! PNG Images */
 457         case AST_FORMAT_PNG:
 458                 return (1ULL << 17);
 459
 460         /*! T.140 RED Text format RFC 4103 */
 461         case AST_FORMAT_T140RED:
 462                 return (1ULL << 26);
 463         /*! T.140 Text format - ITU T.140, RFC 4103 */
 464         case AST_FORMAT_T140:
 465                 return (1ULL << 27);
 466         default:
 467                 return 0; /* not supported by old bitfield. */
 468         }
 469
 470         return 0;
 471
 472 }
 473 uint64_t ast_format_to_old_bitfield(const struct ast_format *format)
 474 {
 475         return ast_format_id_to_old_bitfield(format->id);
 476 }
 477
 478 struct ast_format *ast_format_from_old_bitfield(struct ast_format *dst, uint64_t src)
 479 {
 480         switch (src) {
 481         /*! G.723.1 compression */
 482         case (1ULL << 0):
 483                 return ast_format_set(dst, AST_FORMAT_G723_1, 0);
 484         /*! GSM compression */
 485         case (1ULL << 1):
 486                 return ast_format_set(dst, AST_FORMAT_GSM, 0);
 487         /*! Raw mu-law data (G.711) */
 488         case (1ULL << 2):
 489                 return ast_format_set(dst, AST_FORMAT_ULAW, 0);
 490         /*! Raw A-law data (G.711) */
 491         case (1ULL << 3):
 492                 return ast_format_set(dst, AST_FORMAT_ALAW, 0);
 493         /*! ADPCM (G.726, 32kbps, AAL2 codeword packing) */
 494         case (1ULL << 4):
 495                 return ast_format_set(dst, AST_FORMAT_G726_AAL2, 0);
 496         /*! ADPCM (IMA) */
 497         case (1ULL << 5):
 498                 return ast_format_set(dst, AST_FORMAT_ADPCM, 0);
 499         /*! Raw 16-bit Signed Linear (8000 Hz) PCM */
 500         case (1ULL << 6):
 501                 return ast_format_set(dst, AST_FORMAT_SLINEAR, 0);
 502         /*! LPC10, 180 samples/frame */
 503         case (1ULL << 7):
 504                 return ast_format_set(dst, AST_FORMAT_LPC10, 0);
 505         /*! G.729A audio */
 506         case (1ULL << 8):
 507                 return ast_format_set(dst, AST_FORMAT_G729A, 0);
 508         /*! SpeeX Free Compression */
 509         case (1ULL << 9):
 510                 return ast_format_set(dst, AST_FORMAT_SPEEX, 0);
 511         /*! iLBC Free Compression */
 512         case (1ULL << 10):
 513                 return ast_format_set(dst, AST_FORMAT_ILBC, 0);
 514         /*! ADPCM (G.726, 32kbps, RFC3551 codeword packing) */
 515         case (1ULL << 11):
 516                 return ast_format_set(dst, AST_FORMAT_G726, 0);
 517         /*! G.722 */
 518         case (1ULL << 12):
 519                 return ast_format_set(dst, AST_FORMAT_G722, 0);
 520         /*! G.722.1 (also known as Siren7, 32kbps assumed) */
 521         case (1ULL << 13):
 522                 return ast_format_set(dst, AST_FORMAT_SIREN7, 0);
 523         /*! G.722.1 Annex C (also known as Siren14, 48kbps assumed) */
 524         case (1ULL << 14):
 525                 return ast_format_set(dst, AST_FORMAT_SIREN14, 0);
 526         /*! Raw 16-bit Signed Linear (16000 Hz) PCM */
 527         case (1ULL << 15):
 528                 return ast_format_set(dst, AST_FORMAT_SLINEAR16, 0);
 529         /*! G.719 (64 kbps assumed) */
 530         case (1ULL << 32):
 531                 return ast_format_set(dst, AST_FORMAT_G719, 0);
 532         /*! SpeeX Wideband (16kHz) Free Compression */
 533         case (1ULL << 33):
 534                 return ast_format_set(dst, AST_FORMAT_SPEEX16, 0);
 535         /*! Raw mu-law data (G.711) */
 536         case (1ULL << 47):
 537                 return ast_format_set(dst, AST_FORMAT_TESTLAW, 0);
 538
 539         /*! H.261 Video */
 540         case (1ULL << 18):
 541                 return ast_format_set(dst, AST_FORMAT_H261, 0);
 542         /*! H.263 Video */
 543         case (1ULL << 19):
 544                 return ast_format_set(dst, AST_FORMAT_H263, 0);
 545         /*! H.263+ Video */
 546         case (1ULL << 20):
 547                 return ast_format_set(dst, AST_FORMAT_H263_PLUS, 0);
 548         /*! H.264 Video */
 549         case (1ULL << 21):
 550                 return ast_format_set(dst, AST_FORMAT_H264, 0);
 551         /*! MPEG4 Video */
 552         case (1ULL << 22):
 553                 return ast_format_set(dst, AST_FORMAT_MP4_VIDEO, 0);
 554
 555         /*! JPEG Images */
 556         case (1ULL << 16):
 557                 return ast_format_set(dst, AST_FORMAT_JPEG, 0);
 558         /*! PNG Images */
 559         case (1ULL << 17):
 560                 return ast_format_set(dst, AST_FORMAT_PNG, 0);
 561
 562         /*! T.140 RED Text format RFC 4103 */
 563         case (1ULL << 26):
 564                 return ast_format_set(dst, AST_FORMAT_T140RED, 0);
 565         /*! T.140 Text format - ITU T.140, RFC 4103 */
 566         case (1ULL << 27):
 567                 return ast_format_set(dst, AST_FORMAT_T140, 0);
 568         }
 569         ast_format_clear(dst);
 570         return NULL;
 571 }
 572
 573 enum ast_format_id ast_format_id_from_old_bitfield(uint64_t src)
 574 {
 575         struct ast_format dst;
 576         if (ast_format_from_old_bitfield(&dst, src)) {
 577                 return dst.id;
 578         }
 579         return 0;
 580 }
 581
 582 int ast_format_is_slinear(const struct ast_format *format)
 583 {
 584         if (format->id == AST_FORMAT_SLINEAR ||
 585                 format->id == AST_FORMAT_SLINEAR12 ||
 586                 format->id == AST_FORMAT_SLINEAR16 ||
 587                 format->id == AST_FORMAT_SLINEAR24 ||
 588                 format->id == AST_FORMAT_SLINEAR32 ||
 589                 format->id == AST_FORMAT_SLINEAR44 ||
 590                 format->id == AST_FORMAT_SLINEAR48 ||
 591                 format->id == AST_FORMAT_SLINEAR96 ||
 592                 format->id == AST_FORMAT_SLINEAR192) {
 593                 return 1;
 594         }
 595         return 0;
 596 }
 597
 598 enum ast_format_id ast_format_slin_by_rate(unsigned int rate)
 599 {
 600         if (rate >= 192000) {
 601                 return AST_FORMAT_SLINEAR192;
 602         } else if (rate >= 96000) {
 603                 return AST_FORMAT_SLINEAR96;
 604         } else if (rate >= 48000) {
 605                 return AST_FORMAT_SLINEAR48;
 606         } else if (rate >= 44100) {
 607                 return AST_FORMAT_SLINEAR44;
 608         } else if (rate >= 32000) {
 609                 return AST_FORMAT_SLINEAR32;
 610         } else if (rate >= 24000) {
 611                 return AST_FORMAT_SLINEAR24;
 612         } else if (rate >= 16000) {
 613                 return AST_FORMAT_SLINEAR16;
 614         } else if (rate >= 12000) {
 615                 return AST_FORMAT_SLINEAR12;
 616         }
 617         return AST_FORMAT_SLINEAR;
 618 }
 619
 620 const char* ast_getformatname(const struct ast_format *format)
 621 {
 622         int x;
 623         const char *ret = "unknown";
 624         size_t f_len;
 625         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 626         for (x = 0; x < f_len; x++) {
 627                 if (ast_format_cmp(&f_list[x].format, format) == AST_FORMAT_CMP_EQUAL) {
 628                         ret = f_list[x].name;
 629                         break;
 630                 }
 631         }
 632         f_list = ast_format_list_destroy(f_list);
 633         return ret;
 634 }
 635
 636
 637 char *ast_getformatname_multiple_byid(char *buf, size_t size, enum ast_format_id id)
 638 {
 639         int x;
 640         unsigned len;
 641         char *start, *end = buf;
 642         size_t f_len;
 643         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 644
 645         if (!size) {
 646                 f_list = ast_format_list_destroy(f_list);
 647                 return buf;
 648         }
 649         snprintf(end, size, "(");
 650         len = strlen(end);
 651         end += len;
 652         size -= len;
 653         start = end;
 654         for (x = 0; x < f_len; x++) {
 655                 if (f_list[x].format.id == id) {
 656                         snprintf(end, size, "%s|", f_list[x].name);
 657                         len = strlen(end);
 658                         end += len;
 659                         size -= len;
 660                 }
 661         }
 662         if (start == end) {
 663                 ast_copy_string(start, "nothing)", size);
 664         } else if (size > 1) {
 665                 *(end - 1) = ')';
 666         }
 667         f_list = ast_format_list_destroy(f_list);
 668         return buf;
 669 }
 670
 671 static struct ast_codec_alias_table {
 672         const char *alias;
 673         const char *realname;
 674 } ast_codec_alias_table[] = {
 675         { "slinear", "slin"},
 676         { "slinear16", "slin16"},
 677         { "g723.1", "g723"},
 678         { "g722.1", "siren7"},
 679         { "g722.1c", "siren14"},
 680 };
 681
 682 static const char *ast_expand_codec_alias(const char *in)
 683 {
 684         int x;
 685
 686         for (x = 0; x < ARRAY_LEN(ast_codec_alias_table); x++) {
 687                 if (!strcmp(in,ast_codec_alias_table[x].alias))
 688                         return ast_codec_alias_table[x].realname;
 689         }
 690         return in;
 691 }
 692
 693 struct ast_format *ast_getformatbyname(const char *name, struct ast_format *result)
 694 {
 695         int x;
 696         size_t f_len;
 697         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 698
 699         for (x = 0; x < f_len; x++) {
 700                 if (!strcasecmp(f_list[x].name, name) ||
 701                          !strcasecmp(f_list[x].name, ast_expand_codec_alias(name))) {
 702
 703                         ast_format_copy(result, &f_list[x].format);
 704                         f_list = ast_format_list_destroy(f_list);
 705                         return result;
 706                 }
 707         }
 708         f_list = ast_format_list_destroy(f_list);
 709
 710         return NULL;
 711 }
 712
 713 const char *ast_codec2str(struct ast_format *format)
 714 {
 715         int x;
 716         const char *ret = "unknown";
 717         size_t f_len;
 718         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 719
 720         for (x = 0; x < f_len; x++) {
 721                 if (ast_format_cmp(&f_list[x].format, format) == AST_FORMAT_CMP_EQUAL) {
 722                         ret = f_list[x].desc;
 723                         break;
 724                 }
 725         }
 726         f_list = ast_format_list_destroy(f_list);
 727         return ret;
 728 }
 729
 730 int ast_format_rate(const struct ast_format *format)
 731 {
 732         switch (format->id) {
 733         case AST_FORMAT_SLINEAR12:
 734                 return 12000;
 735         case AST_FORMAT_SLINEAR24:
 736                 return 24000;
 737         case AST_FORMAT_SLINEAR32:
 738                 return 32000;
 739         case AST_FORMAT_SLINEAR44:
 740                 return 44100;
 741         case AST_FORMAT_SLINEAR48:
 742                 return 48000;
 743         case AST_FORMAT_SLINEAR96:
 744                 return 96000;
 745         case AST_FORMAT_SLINEAR192:
 746                 return 192000;
 747         case AST_FORMAT_G722:
 748         case AST_FORMAT_SLINEAR16:
 749         case AST_FORMAT_SIREN7:
 750         case AST_FORMAT_SPEEX16:
 751                 return 16000;
 752         case AST_FORMAT_SIREN14:
 753         case AST_FORMAT_SPEEX32:
 754                 return 32000;
 755         case AST_FORMAT_G719:
 756                 return 48000;
 757         case AST_FORMAT_SILK:
 758                 if (!(ast_format_isset(format,
 759                         SILK_ATTR_KEY_SAMP_RATE,
 760                         SILK_ATTR_VAL_SAMP_24KHZ,
 761                         AST_FORMAT_ATTR_END))) {
 762                         return 24000;
 763                 } else if (!(ast_format_isset(format,
 764                         SILK_ATTR_KEY_SAMP_RATE,
 765                         SILK_ATTR_VAL_SAMP_16KHZ,
 766                         AST_FORMAT_ATTR_END))) {
 767                         return 16000;
 768                 } else if (!(ast_format_isset(format,
 769                         SILK_ATTR_KEY_SAMP_RATE,
 770                         SILK_ATTR_VAL_SAMP_12KHZ,
 771                         AST_FORMAT_ATTR_END))) {
 772                         return 12000;
 773                 } else {
 774                         return 8000;
 775                 }
 776         case AST_FORMAT_CELT:
 777         {
 778                 int samplerate;
 779                 if (!(ast_format_get_value(format,
 780                         CELT_ATTR_KEY_SAMP_RATE,
 781                         &samplerate))) {
 782                         return samplerate;
 783                 }
 784         }
 785         default:
 786                 return 8000;
 787         }
 788 }
 789
 790 static char *show_codecs(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 791 {
 792         int x, found=0;
 793         size_t f_len;
 794         const struct ast_format_list *f_list;
 795
 796         switch (cmd) {
 797         case CLI_INIT:
 798                 e->command = "core show codecs [audio|video|image|text]";
 799                 e->usage =
 800                         "Usage: core show codecs [audio|video|image|text]\n"
 801                         "       Displays codec mapping\n";
 802                 return NULL;
 803         case CLI_GENERATE:
 804                 return NULL;
 805         }
 806
 807         if ((a->argc < 3) || (a->argc > 4)) {
 808                 return CLI_SHOWUSAGE;
 809         }
 810
 811         f_list = ast_format_list_get(&f_len);
 812         if (!ast_opt_dont_warn) {
 813                 ast_cli(a->fd, "Disclaimer: this command is for informational purposes only.\n"
 814                                 "\tIt does not indicate anything about your configuration.\n");
 815         }
 816
 817         ast_cli(a->fd, "%8s %5s %8s %s\n","ID","TYPE","NAME","DESCRIPTION");
 818         ast_cli(a->fd, "-----------------------------------------------------------------------------------\n");
 819
 820         for (x = 0; x < f_len; x++) {
 821                 if (a->argc == 4) {
 822                         if (!strcasecmp(a->argv[3], "audio")) {
 823                                 if (AST_FORMAT_GET_TYPE(f_list[x].format.id) != AST_FORMAT_TYPE_AUDIO) {
 824                                         continue;
 825                                 }
 826                         } else if (!strcasecmp(a->argv[3], "video")) {
 827                                 if (AST_FORMAT_GET_TYPE(f_list[x].format.id) != AST_FORMAT_TYPE_VIDEO) {
 828                                         continue;
 829                                 }
 830                         } else if (!strcasecmp(a->argv[3], "image")) {
 831                                 if (AST_FORMAT_GET_TYPE(f_list[x].format.id) != AST_FORMAT_TYPE_IMAGE) {
 832                                         continue;
 833                                 }
 834                         } else if (!strcasecmp(a->argv[3], "text")) {
 835                                 if (AST_FORMAT_GET_TYPE(f_list[x].format.id) != AST_FORMAT_TYPE_TEXT) {
 836                                         continue;
 837                                 }
 838                         } else {
 839                                 continue;
 840                         }
 841                 }
 842
 843                 ast_cli(a->fd, "%8u %5s %8s (%s)\n",
 844                         f_list[x].format.id,
 845                         (AST_FORMAT_GET_TYPE(f_list[x].format.id) == AST_FORMAT_TYPE_AUDIO) ? "audio" :
 846                         (AST_FORMAT_GET_TYPE(f_list[x].format.id)  == AST_FORMAT_TYPE_IMAGE)  ? "image" :
 847                         (AST_FORMAT_GET_TYPE(f_list[x].format.id)  == AST_FORMAT_TYPE_VIDEO) ? "video" :
 848                         (AST_FORMAT_GET_TYPE(f_list[x].format.id)  == AST_FORMAT_TYPE_TEXT)  ? "text"  :
 849                         "(unk)",
 850                         f_list[x].name,
 851                         f_list[x].desc);
 852                 found = 1;
 853         }
 854
 855         f_list = ast_format_list_destroy(f_list);
 856         if (!found) {
 857                 return CLI_SHOWUSAGE;
 858         } else {
 859                 return CLI_SUCCESS;
 860         }
 861 }
 862
 863 static char *show_codec_n(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 864 {
 865         enum ast_format_id format_id;
 866         int x, found = 0;
 867         int type_punned_codec;
 868         size_t f_len;
 869         const struct ast_format_list *f_list;
 870
 871         switch (cmd) {
 872         case CLI_INIT:
 873                 e->command = "core show codec";
 874                 e->usage =
 875                         "Usage: core show codec <number>\n"
 876                         "       Displays codec mapping\n";
 877                 return NULL;
 878         case CLI_GENERATE:
 879                 return NULL;
 880         }
 881
 882         if (a->argc != 4) {
 883                 return CLI_SHOWUSAGE;
 884         }
 885
 886         if (sscanf(a->argv[3], "%30d", &type_punned_codec) != 1) {
 887                 return CLI_SHOWUSAGE;
 888         }
 889         format_id = type_punned_codec;
 890
 891         f_list = ast_format_list_get(&f_len);
 892         for (x = 0; x < f_len; x++) {
 893                 if (f_list[x].format.id == format_id) {
 894                         found = 1;
 895                         ast_cli(a->fd, "%11u %s\n", (unsigned int) format_id, f_list[x].desc);
 896                 }
 897         }
 898
 899         if (!found) {
 900                 ast_cli(a->fd, "Codec %d not found\n", format_id);
 901         }
 902
 903         f_list = ast_format_list_destroy(f_list);
 904         return CLI_SUCCESS;
 905 }
 906
 907 /* Builtin Asterisk CLI-commands for debugging */
 908 static struct ast_cli_entry my_clis[] = {
 909         AST_CLI_DEFINE(show_codecs, "Displays a list of codecs"),
 910         AST_CLI_DEFINE(show_codec_n, "Shows a specific codec"),
 911 };
 912
 913 static int format_list_add_custom(struct ast_format_list *new)
 914 {
 915         struct ast_format_list *entry;
 916         if (!(entry = ao2_alloc(sizeof(*entry), NULL))) {
 917                 return -1;
 918         }
 919         memcpy(entry, new, sizeof(struct ast_format_list));
 920         entry->custom_entry = 1;
 921         ao2_link(format_list, entry);
 922         return 0;
 923 }
 924 static int format_list_add_static(
 925         const struct ast_format *format,
 926         const char *name,
 927         int samplespersecond,
 928         const char *description,
 929         int fr_len,
 930         int min_ms,
 931         int max_ms,
 932         int inc_ms,
 933         int def_ms,
 934         unsigned int flags,
 935         int cur_ms)
 936 {
 937         struct ast_format_list *entry;
 938         if (!(entry = ao2_alloc(sizeof(*entry), NULL))) {
 939                 return -1;
 940         }
 941         ast_format_copy(&entry->format, format);
 942         ast_copy_string(entry->name, name, sizeof(entry->name));
 943         ast_copy_string(entry->desc, description, sizeof(entry->desc));
 944         entry->samplespersecond = samplespersecond;
 945         entry->fr_len = fr_len;
 946         entry->min_ms = min_ms;
 947         entry->max_ms = max_ms;
 948         entry->inc_ms = inc_ms;
 949         entry->def_ms = def_ms;
 950         entry->flags = flags;
 951         entry->cur_ms = cur_ms;
 952         entry->custom_entry = 0;
 953
 954         ao2_link(format_list, entry);
 955         ao2_ref(entry, -1);
 956         return 0;
 957 }
 958
 959 static int list_all_custom(void *obj, void *arg, int flag)
 960 {
 961         struct ast_format_list *entry = obj;
 962         return entry->custom_entry ? CMP_MATCH : 0;
 963 }
 964
 965 static int list_cmp_cb(void *obj, void *arg, int flags)
 966 {
 967         struct ast_format_list *entry1 = obj;
 968         struct ast_format_list *entry2 = arg;
 969
 970         return (ast_format_cmp(&entry1->format, &entry2->format) == AST_FORMAT_CMP_EQUAL) ? CMP_MATCH | CMP_STOP : 0;
 971 }
 972 static int list_hash_cb(const void *obj, const int flags)
 973 {
 974         return ao2_container_count(format_list);
 975 }
 976
 977 const struct ast_format_list *ast_format_list_get(size_t *size)
 978 {
 979         struct ast_format_list *list;
 980         ast_rwlock_rdlock(&format_list_array_lock);
 981         ao2_ref(format_list_array, 1);
 982         list = format_list_array;
 983         *size = format_list_array_len;
 984         ast_rwlock_unlock(&format_list_array_lock);
 985         return list;
 986 }
 987 const struct ast_format_list *ast_format_list_destroy(const struct ast_format_list *list)
 988 {
 989         ao2_ref((void *) list, -1);
 990         return NULL;
 991 }
 992
 993 static int build_format_list_array(void)
 994 {
 995         struct ast_format_list *tmp;
 996         size_t arraysize = sizeof(struct ast_format_list) * ao2_container_count(format_list);
 997         int i = 0;
 998         struct ao2_iterator it;
 999
1000         ast_rwlock_wrlock(&format_list_array_lock);
1001         tmp = format_list_array;
1002         if (!(format_list_array = ao2_alloc(arraysize, NULL))) {
1003                 format_list_array = tmp;
1004                 ast_rwlock_unlock(&format_list_array_lock);
1005                 return -1;
1006         }
1007         format_list_array_len = ao2_container_count(format_list);
1008         if (tmp) {
1009                 ao2_ref(tmp, -1);
1010         }
1011
1012         /* walk through the container adding elements to the static array */
1013         it = ao2_iterator_init(format_list, 0);
1014         while ((tmp = ao2_iterator_next(&it)) && (i < format_list_array_len)) {
1015                 memcpy(&format_list_array[i], tmp, sizeof(struct ast_format_list));
1016                 ao2_ref(tmp, -1);
1017                 i++;
1018         }
1019         ao2_iterator_destroy(&it);
1020
1021         ast_rwlock_unlock(&format_list_array_lock);
1022         return 0;
1023 }
1024
1025 static int format_list_init(void)
1026 {
1027         struct ast_format tmpfmt;
1028         if (!(format_list = ao2_container_alloc(283, list_hash_cb, list_cmp_cb))) {
1029                 return -1;
1030         }
1031         /* initiate static entries XXX DO NOT CHANGE THIS ORDER! */
1032         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G723_1, 0), "g723", 8000, "G.723.1", 20, 30, 300, 30, 30, 0, 0);       /*!< G723.1 */
1033         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_GSM, 0), "gsm",  8000, "GSM", 33, 20, 300, 20, 20, 0, 0);              /*!< codec_gsm.c */
1034         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_ULAW, 0), "ulaw", 8000, "G.711 u-law", 80, 10, 150, 10, 20, 0, 0);     /*!< codec_ulaw.c */
1035         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_ALAW, 0), "alaw", 8000, "G.711 A-law", 80, 10, 150, 10, 20, 0, 0);     /*!< codec_alaw.c */
1036         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G726, 0), "g726", 8000, "G.726 RFC3551", 40, 10, 300, 10, 20, 0, 0);   /*!< codec_g726.c */
1037         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_ADPCM, 0), "adpcm" , 8000, "ADPCM", 40, 10, 300, 10, 20, 0, 0);        /*!< codec_adpcm.c */
1038         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR, 0), "slin", 8000, "16 bit Signed Linear PCM", 160, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0); /*!< Signed linear */
1039         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_LPC10, 0), "lpc10", 8000, "LPC10", 7, 20, 20, 20, 20, 0, 0);           /*!< codec_lpc10.c */
1040         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G729A, 0), "g729", 8000, "G.729A", 10, 10, 230, 10, 20, AST_SMOOTHER_FLAG_G729, 0);   /*!< Binary commercial distribution */
1041         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SPEEX, 0), "speex", 8000, "SpeeX", 10, 10, 60, 10, 20, 0, 0);          /*!< codec_speex.c */
1042         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SPEEX16, 0), "speex16", 16000, "SpeeX 16khz", 10, 10, 60, 10, 20, 0, 0);   /*!< codec_speex.c */
1043         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_ILBC, 0), "ilbc", 8000, "iLBC", 50, 30, 30, 30, 30, 0, 0);                 /*!< codec_ilbc.c */ /* inc=30ms - workaround */
1044         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G726_AAL2, 0), "g726aal2", 8000, "G.726 AAL2", 40, 10, 300, 10, 20, 0, 0); /*!< codec_g726.c */
1045         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G722, 0), "g722", 16000, "G722", 80, 10, 150, 10, 20, 0, 0);               /*!< codec_g722.c */
1046         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR16, 0), "slin16", 16000, "16 bit Signed Linear PCM (16kHz)", 320, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (16kHz) */
1047         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_JPEG, 0), "jpeg", 0, "JPEG image", 0, 0, 0, 0 ,0 ,0 ,0);          /*!< See format_jpeg.c */
1048         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_PNG, 0), "png", 0, "PNG image", 0, 0, 0, 0 ,0 ,0 ,0);             /*!< PNG Image format */
1049         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_H261, 0), "h261", 0, "H.261 Video", 0, 0, 0, 0 ,0 ,0 ,0);         /*!< H.261 Video Passthrough */
1050         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_H263, 0), "h263", 0, "H.263 Video", 0, 0, 0, 0 ,0 ,0 ,0);         /*!< H.263 Passthrough support, see format_h263.c */
1051         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_H263_PLUS, 0), "h263p", 0, "H.263+ Video", 0, 0, 0,0 ,0 ,0, 0);  /*!< H.263plus passthrough support See format_h263.c */
1052         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_H264, 0), "h264", 0, "H.264 Video", 0, 0, 0, 0 ,0 ,0, 0);         /*!< Passthrough support, see format_h263.c */
1053         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_MP4_VIDEO, 0), "mpeg4", 0, "MPEG4 Video", 0, 0, 0, 0, 0 ,0, 0);   /*!< Passthrough support for MPEG4 */
1054         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_T140RED, 0), "red", 1, "T.140 Realtime Text with redundancy", 0, 0, 0,0 ,0 ,0, 0);     /*!< Redundant T.140 Realtime Text */
1055         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_T140, 0), "t140", 0, "Passthrough T.140 Realtime Text", 0, 0, 0, 0 ,0 ,0, 0);      /*!< Passthrough support for T.140 Realtime Text */
1056         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SIREN7, 0), "siren7", 16000, "ITU G.722.1 (Siren7, licensed from Polycom)", 80, 20, 80, 20, 20, 0, 0); /*!< Binary commercial distribution */
1057         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SIREN14, 0), "siren14", 32000, "ITU G.722.1 Annex C, (Siren14, licensed from Polycom)", 120, 20, 80, 20, 20, 0, 0);   /*!< Binary commercial distribution */
1058         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_TESTLAW, 0), "testlaw", 8000, "G.711 test-law", 80, 10, 150, 10, 20, 0, 0);    /*!< codec_ulaw.c */
1059         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_G719, 0), "g719", 48000, "ITU G.719", 160, 20, 80, 20, 20, 0, 0);
1060
1061         /* ORDER MAY CHANGE AFTER THIS POINT IN THE LIST */
1062         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SPEEX32, 0), "speex32", 32000, "SpeeX 32khz", 10, 10, 60, 10, 20, 0, 0);   /*!< codec_speex.c */
1063         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR12, 0), "slin12", 12000, "16 bit Signed Linear PCM (12kHz)", 240, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (12kHz) */
1064         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR24, 0), "slin24", 24000, "16 bit Signed Linear PCM (24kHz)", 480, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (24kHz) */
1065         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR32, 0), "slin32", 32000, "16 bit Signed Linear PCM (32kHz)", 640, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (32kHz) */
1066         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR44, 0), "slin44", 44100, "16 bit Signed Linear PCM (44kHz)", 882, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (44.1kHz) */
1067         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR48, 0), "slin48", 48000, "16 bit Signed Linear PCM (48kHz)", 960, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (48kHz) */
1068         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR96, 0), "slin96", 96000, "16 bit Signed Linear PCM (96kHz)", 1920, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (96kHz) */
1069         format_list_add_static(ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR192, 0), "slin192", 192000, "16 bit Signed Linear PCM (192kHz)", 3840, 10, 70, 10, 20, AST_SMOOTHER_FLAG_BE, 0);/*!< Signed linear (192kHz) */
1070
1071         return 0;
1072 }
1073
1074 /*! \internal \brief Clean up resources on Asterisk shutdown */
1075 static void format_list_shutdown(void)
1076 {
1077         ast_rwlock_destroy(&format_list_array_lock);
1078         if (format_list) {
1079                 ao2_t_ref(format_list, -1, "Unref format_list container in shutdown");
1080                 format_list = NULL;
1081         }
1082         if (format_list_array) {
1083                 ao2_t_ref(format_list_array, -1, "Unref format_list_array in shutdown");
1084                 format_list_array = NULL;
1085         }
1086 }
1087
1088 int ast_format_list_init(void)
1089 {
1090         if (ast_rwlock_init(&format_list_array_lock)) {
1091                 return -1;
1092         }
1093         if (format_list_init()) {
1094                 goto init_list_cleanup;
1095         }
1096         if (build_format_list_array()) {
1097                 goto init_list_cleanup;
1098         }
1099
1100         ast_register_atexit(format_list_shutdown);
1101         return 0;
1102 init_list_cleanup:
1103
1104         format_list_shutdown();
1105         return -1;
1106 }
1107
1108 /*! \internal \brief Clean up resources on Asterisk shutdown */
1109 static void format_attr_shutdown(void)
1110 {
1111         ast_cli_unregister_multiple(my_clis, ARRAY_LEN(my_clis));
1112         if (interfaces) {
1113                 ao2_ref(interfaces, -1);
1114                 interfaces = NULL;
1115         }
1116 }
1117
1118 int ast_format_attr_init(void)
1119 {
1120         interfaces = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_RWLOCK,
1121                 283, interface_hash_cb, interface_cmp_cb);
1122         if (!interfaces) {
1123                 return -1;
1124         }
1125
1126         ast_cli_register_multiple(my_clis, ARRAY_LEN(my_clis));
1127         ast_register_atexit(format_attr_shutdown);
1128         return 0;
1129 }
1130
1131 static int custom_celt_format(struct ast_format_list *entry, unsigned int maxbitrate, unsigned int framesize)
1132 {
1133         if (!entry->samplespersecond) {
1134                 ast_log(LOG_WARNING, "Custom CELT format definition '%s' requires sample rate to be defined.\n", entry->name);
1135         }
1136         ast_format_set(&entry->format, AST_FORMAT_CELT, 0);
1137         if (!has_interface(&entry->format)) {
1138                 return -1;
1139         }
1140
1141         snprintf(entry->desc, sizeof(entry->desc), "CELT Custom Format %dkhz", entry->samplespersecond/1000);
1142
1143         ast_format_append(&entry->format,
1144                 CELT_ATTR_KEY_SAMP_RATE, entry->samplespersecond,
1145                 CELT_ATTR_KEY_MAX_BITRATE, maxbitrate,
1146                 CELT_ATTR_KEY_FRAME_SIZE, framesize,
1147                 AST_FORMAT_ATTR_END);
1148
1149         entry->fr_len = 80;
1150         entry->min_ms = 20;
1151         entry->max_ms = 20;
1152         entry->inc_ms = 20;
1153         entry->def_ms = 20;
1154         return 0;
1155 }
1156
1157 static int custom_silk_format(struct ast_format_list *entry, unsigned int maxbitrate, int usedtx, int usefec, int packetloss_percentage)
1158 {
1159         if (!entry->samplespersecond) {
1160                 ast_log(LOG_WARNING, "Custom SILK format definition '%s' requires sample rate to be defined.\n", entry->name);
1161         }
1162         ast_format_set(&entry->format, AST_FORMAT_SILK, 0);
1163
1164         if (!has_interface(&entry->format)) {
1165                 return -1;
1166         }
1167
1168         switch (entry->samplespersecond) {
1169         case 8000:
1170                 ast_copy_string(entry->desc, "SILK Custom Format 8khz", sizeof(entry->desc));
1171                 ast_format_append(&entry->format,
1172                         SILK_ATTR_KEY_SAMP_RATE, SILK_ATTR_VAL_SAMP_8KHZ,
1173                         AST_FORMAT_ATTR_END);
1174                 break;
1175         case 12000:
1176                 ast_copy_string(entry->desc, "SILK Custom Format 12khz", sizeof(entry->desc));
1177                 ast_format_append(&entry->format,
1178                         SILK_ATTR_KEY_SAMP_RATE, SILK_ATTR_VAL_SAMP_12KHZ,
1179                         AST_FORMAT_ATTR_END);
1180                 break;
1181         case 16000:
1182                 ast_copy_string(entry->desc, "SILK Custom Format 16khz", sizeof(entry->desc));
1183                 ast_format_append(&entry->format,
1184                         SILK_ATTR_KEY_SAMP_RATE, SILK_ATTR_VAL_SAMP_16KHZ,
1185                         AST_FORMAT_ATTR_END);
1186                 break;
1187         case 24000:
1188                 ast_copy_string(entry->desc, "SILK Custom Format 24khz", sizeof(entry->desc));
1189                 ast_format_append(&entry->format,
1190                         SILK_ATTR_KEY_SAMP_RATE, SILK_ATTR_VAL_SAMP_24KHZ,
1191                         AST_FORMAT_ATTR_END);
1192                 break;
1193         default:
1194                 ast_log(LOG_WARNING, "Custom SILK format definition '%s' can not support sample rate %d\n", entry->name, entry->samplespersecond);
1195                 return -1;
1196         }
1197         ast_format_append(&entry->format,
1198                         SILK_ATTR_KEY_MAX_BITRATE, maxbitrate,
1199                         SILK_ATTR_KEY_DTX, usedtx ? 1 : 0,
1200                         SILK_ATTR_KEY_FEC, usefec ? 1 : 0,
1201                         SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE, packetloss_percentage,
1202                         AST_FORMAT_ATTR_END);
1203
1204         entry->fr_len = 80;
1205         entry->min_ms = 20;
1206         entry->max_ms = 20;
1207         entry->inc_ms = 20;
1208         entry->def_ms = 20;
1209         return 0;
1210 }
1211
1212 static int conf_process_format_name(const char *name, enum ast_format_id *id)
1213 {
1214         if (!strcasecmp(name, "silk")) {
1215                 *id = AST_FORMAT_SILK;
1216         } else if (!strcasecmp(name, "celt")) {
1217                 *id = AST_FORMAT_CELT;
1218         } else {
1219                 *id = 0;
1220                 return -1;
1221         }
1222         return 0;
1223 }
1224
1225 static int conf_process_sample_rate(const char *rate, unsigned int *result)
1226 {
1227         if (!strcasecmp(rate, "8000")) {
1228                 *result = 8000;
1229         } else if (!strcasecmp(rate, "12000")) {
1230                 *result = 12000;
1231         } else if (!strcasecmp(rate, "16000")) {
1232                 *result = 16000;
1233         } else if (!strcasecmp(rate, "24000")) {
1234                 *result = 24000;
1235         } else if (!strcasecmp(rate, "32000")) {
1236                 *result = 32000;
1237         } else if (!strcasecmp(rate, "44100")) {
1238                 *result = 44100;
1239         } else if (!strcasecmp(rate, "48000")) {
1240                 *result = 48000;
1241         } else if (!strcasecmp(rate, "96000")) {
1242                 *result = 96000;
1243         } else if (!strcasecmp(rate, "192000")) {
1244                 *result = 192000;
1245         } else {
1246                 *result = 0;
1247                 return -1;
1248         }
1249
1250         return 0;
1251 }
1252 static int load_format_config(void)
1253 {
1254         struct ast_flags config_flags = { 0, };
1255         struct ast_config *cfg = ast_config_load(FORMAT_CONFIG, config_flags);
1256         struct ast_format_list entry;
1257         struct ast_variable *var;
1258         char *cat = NULL;
1259         int add_it = 0;
1260
1261         struct {
1262                 enum ast_format_id id;
1263                 unsigned int maxbitrate;
1264                 unsigned int framesize;
1265                 unsigned int packetloss_percentage;
1266                 int usefec;
1267                 int usedtx;
1268         } settings;
1269
1270         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1271                 return 0;
1272         }
1273
1274         /* remove all custom formats from the AO2 Container. Note, this has no affect on the
1275          * global format list until the list is rebuild.  That is why this is okay to do while
1276          * reloading the config. */
1277         ao2_callback(format_list, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE, list_all_custom, NULL);
1278
1279         while ((cat = ast_category_browse(cfg, cat))) {
1280                 memset(&entry, 0, sizeof(entry));
1281                 memset(&settings, 0, sizeof(settings));
1282                 add_it = 0;
1283
1284                 if (!(ast_variable_retrieve(cfg, cat, "type"))) {
1285                         continue;
1286                 }
1287                 ast_copy_string(entry.name, cat, sizeof(entry.name));
1288                 var = ast_variable_browse(cfg, cat);
1289                 for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
1290                         if (!strcasecmp(var->name, "type") && conf_process_format_name(var->value, &settings.id)) {
1291                                 ast_log(LOG_WARNING, "Can not make custom format type for '%s' at line %d of %s\n",
1292                                         var->value, var->lineno, FORMAT_CONFIG);
1293                                 continue;
1294                         } else if (!strcasecmp(var->name, "samprate") && conf_process_sample_rate(var->value, &entry.samplespersecond)) {
1295                                 ast_log(LOG_WARNING, "Sample rate '%s' at line %d of %s is not supported.\n",
1296                                                 var->value, var->lineno, FORMAT_CONFIG);
1297                         } else if (!strcasecmp(var->name, "maxbitrate")) {
1298                                 if (sscanf(var->value, "%30u", &settings.maxbitrate) != 1) {
1299                                         ast_log(LOG_WARNING, "maxbitrate '%s' at line %d of %s is not supported.\n",
1300                                                 var->value, var->lineno, FORMAT_CONFIG);
1301                                 }
1302                         } else if (!strcasecmp(var->name, "framesize")) {
1303                                 if (sscanf(var->value, "%30u", &settings.framesize) != 1) {
1304                                         ast_log(LOG_WARNING, "framesize '%s' at line %d of %s is not supported.\n",
1305                                                 var->value, var->lineno, FORMAT_CONFIG);
1306                                 }
1307                         } else if (!strcasecmp(var->name, "dtx")) {
1308                                 settings.usedtx = ast_true(var->value) ? 1 : 0;
1309                         } else if (!strcasecmp(var->name, "fec")) {
1310                                 settings.usefec = ast_true(var->value) ? 1 : 0;
1311                         } else if (!strcasecmp(var->name, "packetloss_percentage")) {
1312                                 if ((sscanf(var->value, "%30u", &settings.packetloss_percentage) != 1) || (settings.packetloss_percentage > 100)) {
1313                                         ast_log(LOG_WARNING, "packetloss_percentage '%s' at line %d of %s is not supported.\n",
1314                                                 var->value, var->lineno, FORMAT_CONFIG);
1315                                 }
1316                         }
1317                 }
1318
1319                 switch (settings.id) {
1320                 case AST_FORMAT_SILK:
1321                         if (!(custom_silk_format(&entry, settings.maxbitrate, settings.usedtx, settings.usefec, settings.packetloss_percentage))) {
1322                                 add_it = 1;
1323                         }
1324                         break;
1325                 case AST_FORMAT_CELT:
1326                         if (!(custom_celt_format(&entry, settings.maxbitrate, settings.framesize))) {
1327                                 add_it = 1;
1328                         }
1329                         break;
1330                 default:
1331                         ast_log(LOG_WARNING, "Can not create custom format %s\n", entry.name);
1332                 }
1333
1334                 if (add_it) {
1335                         format_list_add_custom(&entry);
1336                 }
1337         }
1338         ast_config_destroy(cfg);
1339         build_format_list_array();
1340         return 0;
1341 }
1342
1343 int ast_format_attr_reg_interface(const struct ast_format_attr_interface *interface)
1344 {
1345         int x;
1346         size_t f_len;
1347         const struct ast_format_list *f_list;
1348         struct interface_ao2_wrapper *wrapper;
1349         struct interface_ao2_wrapper tmp_wrapper = {
1350                 .id = interface->id,
1351         };
1352
1353         /*
1354          * Grab the write lock before checking for duplicates in
1355          * anticipation of adding a new interface and to prevent a
1356          * duplicate from sneaking in between the check and add.
1357          */
1358         ao2_wrlock(interfaces);
1359
1360         /* check for duplicates first*/
1361         if ((wrapper = ao2_find(interfaces, &tmp_wrapper, (OBJ_POINTER | OBJ_NOLOCK)))) {
1362                 ao2_unlock(interfaces);
1363                 ast_log(LOG_WARNING, "Can not register attribute interface for format id %d, interface already exists.\n", interface->id);
1364                 ao2_ref(wrapper, -1);
1365                 return -1;
1366         }
1367
1368         wrapper = ao2_alloc_options(sizeof(*wrapper), NULL, AO2_ALLOC_OPT_LOCK_RWLOCK);
1369         if (!wrapper) {
1370                 ao2_unlock(interfaces);
1371                 return -1;
1372         }
1373
1374         wrapper->interface = interface;
1375         wrapper->id = interface->id;
1376
1377         /* The write lock is already held. */
1378         ao2_link_flags(interfaces, wrapper, OBJ_NOLOCK);
1379         ao2_unlock(interfaces);
1380
1381         ao2_ref(wrapper, -1);
1382
1383         /* This will find all custom formats in codecs.conf for this new registered interface */
1384         load_format_config();
1385
1386         /* update the RTP engine to all custom formats created for this interface */
1387         f_list = ast_format_list_get(&f_len);
1388         for (x = 0; x < f_len; x++) {
1389                 if (f_list[x].format.id == tmp_wrapper.id) {
1390                         ast_rtp_engine_load_format(&f_list[x].format);
1391                 }
1392         }
1393         f_list = ast_format_list_destroy(f_list);
1394         return 0;
1395 }
1396
1397 int ast_format_attr_unreg_interface(const struct ast_format_attr_interface *interface)
1398 {
1399         int x;
1400         size_t f_len;
1401         const struct ast_format_list *f_list;
1402         struct interface_ao2_wrapper *wrapper;
1403         struct interface_ao2_wrapper tmp_wrapper = {
1404                 .id = interface->id,
1405         };
1406
1407         if (!(wrapper = ao2_find(interfaces, &tmp_wrapper, (OBJ_POINTER | OBJ_UNLINK)))) {
1408                 return -1;
1409         }
1410
1411         ao2_wrlock(wrapper);
1412         wrapper->interface = NULL;
1413         ao2_unlock(wrapper);
1414
1415         ao2_ref(wrapper, -1);
1416
1417         /* update the RTP engine to remove all custom formats created for this interface */
1418         f_list = ast_format_list_get(&f_len);
1419         for (x = 0; x < f_len; x++) {
1420                 if (f_list[x].format.id == tmp_wrapper.id) {
1421                         ast_rtp_engine_unload_format(&f_list[x].format);
1422                 }
1423         }
1424
1425         /* This will remove all custom formats previously created for this interface */
1426         load_format_config();
1427         f_list = ast_format_list_destroy(f_list);
1428         return 0;
1429 }