main/format_cap.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2010, Digium, Inc.
   5  *
   6  * David Vossel <dvossel@digium.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 Format Capability API
  22  *
  23  * \author David Vossel <dvossel@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
  29
  30 #include "asterisk/_private.h"
  31 #include "asterisk/version.h"
  32 #include "asterisk/format.h"
  33 #include "asterisk/format_cap.h"
  34 #include "asterisk/frame.h"
  35 #include "asterisk/astobj2.h"
  36 #include "asterisk/utils.h"
  37
  38
  39 struct ast_format_cap {
  40         /* The capabilities structure is just an ao2 container of ast_formats */
  41         struct ao2_container *formats;
  42         struct ao2_iterator it;
  43         int nolock;
  44 };
  45
  46 /*! format exists within capabilities structure if it is identical to
  47  * another format, or if the format is a proper subset of another format. */
  48 static int cmp_cb(void *obj, void *arg, int flags)
  49 {
  50         struct ast_format *format1 = arg;
  51         struct ast_format *format2 = obj;
  52         enum ast_format_cmp_res res = ast_format_cmp(format1, format2);
  53
  54         return ((res == AST_FORMAT_CMP_EQUAL) ||
  55                         (res == AST_FORMAT_CMP_SUBSET)) ?
  56                                 CMP_MATCH | CMP_STOP :
  57                                 0;
  58 }
  59
  60 static int hash_cb(const void *obj, const int flags)
  61 {
  62         const struct ast_format *format = obj;
  63         return format->id;
  64 }
  65
  66 static struct ast_format_cap *cap_alloc_helper(int nolock)
  67 {
  68         struct ast_format_cap *cap = ast_calloc(1, sizeof(*cap));
  69
  70         if (!cap) {
  71                 return NULL;
  72         }
  73         cap->nolock = nolock ? OBJ_NOLOCK : 0;
  74         if (!(cap->formats = ao2_container_alloc(283, hash_cb, cmp_cb))) {
  75                 ast_free(cap);
  76                 return NULL;
  77         }
  78
  79         return cap;
  80 }
  81
  82 struct ast_format_cap *ast_format_cap_alloc_nolock(void)
  83 {
  84         return cap_alloc_helper(1);
  85 }
  86
  87 struct ast_format_cap *ast_format_cap_alloc(void)
  88 {
  89         return cap_alloc_helper(0);
  90 }
  91
  92 void *ast_format_cap_destroy(struct ast_format_cap *cap)
  93 {
  94         if (!cap) {
  95                 return NULL;
  96         }
  97         ao2_ref(cap->formats, -1);
  98         ast_free(cap);
  99         return NULL;
 100 }
 101
 102 void ast_format_cap_add(struct ast_format_cap *cap, const struct ast_format *format)
 103 {
 104         struct ast_format *fnew;
 105
 106         if (!format || !format->id) {
 107                 return;
 108         }
 109         if (!(fnew = ao2_alloc(sizeof(struct ast_format), NULL))) {
 110                 return;
 111         }
 112         ast_format_copy(fnew, format);
 113         if (cap->nolock) {
 114                 ao2_link_nolock(cap->formats, fnew);
 115         } else {
 116                 ao2_link(cap->formats, fnew);
 117         }
 118         ao2_ref(fnew, -1);
 119 }
 120
 121 void ast_format_cap_add_all_by_type(struct ast_format_cap *cap, enum ast_format_type type)
 122 {
 123         int x;
 124         size_t f_len = 0;
 125         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 126
 127         for (x = 0; x < f_len; x++) {
 128                 if (AST_FORMAT_GET_TYPE(f_list[x].format.id) == type) {
 129                         ast_format_cap_add(cap, &f_list[x].format);
 130                 }
 131         }
 132         ast_format_list_destroy(f_list);
 133 }
 134
 135 void ast_format_cap_add_all(struct ast_format_cap *cap)
 136 {
 137         int x;
 138         size_t f_len = 0;
 139         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 140
 141         for (x = 0; x < f_len; x++) {
 142                 ast_format_cap_add(cap, &f_list[x].format);
 143         }
 144         ast_format_list_destroy(f_list);
 145 }
 146
 147 static int append_cb(void *obj, void *arg, int flag)
 148 {
 149         struct ast_format_cap *result = (struct ast_format_cap *) arg;
 150         struct ast_format *format = (struct ast_format *) obj;
 151
 152         if (!ast_format_cap_iscompatible(result, format)) {
 153                 ast_format_cap_add(result, format);
 154         }
 155
 156         return 0;
 157 }
 158
 159 void ast_format_cap_append(struct ast_format_cap *dst, const struct ast_format_cap *src)
 160 {
 161         ao2_callback(src->formats, OBJ_NODATA | src->nolock, append_cb, dst);
 162 }
 163
 164 static int copy_cb(void *obj, void *arg, int flag)
 165 {
 166         struct ast_format_cap *result = (struct ast_format_cap *) arg;
 167         struct ast_format *format = (struct ast_format *) obj;
 168
 169         ast_format_cap_add(result, format);
 170         return 0;
 171 }
 172
 173 void ast_format_cap_copy(struct ast_format_cap *dst, const struct ast_format_cap *src)
 174 {
 175         ast_format_cap_remove_all(dst);
 176         ao2_callback(src->formats, OBJ_NODATA | src->nolock, copy_cb, dst);
 177 }
 178
 179 struct ast_format_cap *ast_format_cap_dup(const struct ast_format_cap *cap)
 180 {
 181         struct ast_format_cap *dst;
 182         if (cap->nolock) {
 183                 dst = ast_format_cap_alloc_nolock();
 184         } else {
 185                 dst = ast_format_cap_alloc();
 186         }
 187         if (!dst) {
 188                 return NULL;
 189         }
 190         ao2_callback(cap->formats, OBJ_NODATA | cap->nolock, copy_cb, dst);
 191         return dst;
 192 }
 193
 194 int ast_format_cap_is_empty(const struct ast_format_cap *cap)
 195 {
 196         if (!cap) {
 197                 return 1;
 198         }
 199         return ao2_container_count(cap->formats) == 0 ? 1 : 0;
 200 }
 201
 202 static int find_exact_cb(void *obj, void *arg, int flag)
 203 {
 204         struct ast_format *format1 = (struct ast_format *) arg;
 205         struct ast_format *format2 = (struct ast_format *) obj;
 206
 207         return (ast_format_cmp(format1, format2) == AST_FORMAT_CMP_EQUAL) ? CMP_MATCH : 0;
 208 }
 209
 210 int ast_format_cap_remove(struct ast_format_cap *cap, struct ast_format *format)
 211 {
 212         struct ast_format *fremove;
 213         fremove = ao2_callback(cap->formats, OBJ_POINTER | OBJ_UNLINK | cap->nolock, find_exact_cb, format);
 214
 215         if (fremove) {
 216                 ao2_ref(fremove, -1);
 217                 return 0;
 218         }
 219
 220         return -1;
 221 }
 222
 223 struct multiple_by_id_data {
 224         struct ast_format *format;
 225         int match_found;
 226 };
 227
 228 static int multiple_by_id_cb(void *obj, void *arg, int flag)
 229 {
 230         struct multiple_by_id_data *data = arg;
 231         struct ast_format *format = obj;
 232         int res;
 233
 234         res = (format->id == data->format->id) ? CMP_MATCH : 0;
 235         if (res) {
 236                 data->match_found = 1;
 237         }
 238
 239         return res;
 240 }
 241
 242 int ast_format_cap_remove_byid(struct ast_format_cap *cap, enum ast_format_id id)
 243 {
 244         struct ast_format format = {
 245                 .id = id,
 246         };
 247         struct multiple_by_id_data data = {
 248                 .format = &format,
 249                 .match_found = 0,
 250         };
 251
 252         ao2_callback(cap->formats,
 253                 OBJ_NODATA | cap->nolock | OBJ_MULTIPLE | OBJ_UNLINK,
 254                 multiple_by_id_cb,
 255                 &data);
 256
 257         /* match_found will be set if at least one item was removed */
 258         if (data.match_found) {
 259                 return 0;
 260         }
 261
 262         return -1;
 263 }
 264
 265 static int multiple_by_type_cb(void *obj, void *arg, int flag)
 266 {
 267         int *type = arg;
 268         struct ast_format *format = obj;
 269         return ((AST_FORMAT_GET_TYPE(format->id)) == *type) ? CMP_MATCH : 0;
 270 }
 271
 272 void ast_format_cap_remove_bytype(struct ast_format_cap *cap, enum ast_format_type type)
 273 {
 274         ao2_callback(cap->formats,
 275                 OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE | cap->nolock,
 276                 multiple_by_type_cb,
 277                 &type);
 278 }
 279
 280 void ast_format_cap_remove_all(struct ast_format_cap *cap)
 281 {
 282         ao2_callback(cap->formats, OBJ_NODATA | cap->nolock | OBJ_MULTIPLE | OBJ_UNLINK, NULL, NULL);
 283 }
 284
 285 void ast_format_cap_set(struct ast_format_cap *cap, struct ast_format *format)
 286 {
 287         ast_format_cap_remove_all(cap);
 288         ast_format_cap_add(cap, format);
 289 }
 290
 291 int ast_format_cap_get_compatible_format(const struct ast_format_cap *cap, const struct ast_format *format, struct ast_format *result)
 292 {
 293         struct ast_format *f;
 294         struct ast_format_cap *tmp_cap = (struct ast_format_cap *) cap;
 295         f = ao2_find(tmp_cap->formats, (struct ast_format *) format, OBJ_POINTER | tmp_cap->nolock);
 296
 297         if (f) {
 298                 ast_format_copy(result, f);
 299                 ao2_ref(f, -1);
 300                 return 1;
 301         }
 302         ast_format_clear(result);
 303         return 0;
 304 }
 305
 306 int ast_format_cap_iscompatible(const struct ast_format_cap *cap, const struct ast_format *format)
 307 {
 308         struct ast_format *f;
 309         struct ast_format_cap *tmp_cap = (struct ast_format_cap *) cap;
 310
 311         if (!tmp_cap) {
 312                 return 0;
 313         }
 314         f = ao2_find(tmp_cap->formats, (struct ast_format *) format, OBJ_POINTER | tmp_cap->nolock);
 315         if (f) {
 316                 ao2_ref(f, -1);
 317                 return 1;
 318         }
 319
 320         return 0;
 321 }
 322
 323 struct byid_data {
 324         struct ast_format *result;
 325         enum ast_format_id id;
 326 };
 327 static int find_best_byid_cb(void *obj, void *arg, int flag)
 328 {
 329         struct ast_format *format = obj;
 330         struct byid_data *data = arg;
 331
 332         if (data->id != format->id) {
 333                 return 0;
 334         }
 335         if (!data->result->id || (ast_format_rate(data->result) < ast_format_rate(format))) {
 336                 ast_format_copy(data->result, format);
 337         }
 338         return 0;
 339 }
 340
 341 int ast_format_cap_best_byid(const struct ast_format_cap *cap, enum ast_format_id id, struct ast_format *result)
 342 {
 343         struct byid_data data;
 344         data.result = result;
 345         data.id = id;
 346
 347         ast_format_clear(result);
 348         ao2_callback(cap->formats,
 349                 OBJ_MULTIPLE | OBJ_NODATA | cap->nolock,
 350                 find_best_byid_cb,
 351                 &data);
 352         return result->id ? 1 : 0;
 353 }
 354
 355 /*! \internal
 356  * \brief this struct is just used for the ast_format_cap_joint function so we can provide
 357  * both a format and a result ast_format_cap structure as arguments to the find_joint_cb
 358  * ao2 callback function.
 359  */
 360 struct find_joint_data {
 361         /*! format to compare to for joint capabilities */
 362         struct ast_format *format;
 363         /*! if joint formmat exists with above format, add it to the result container */
 364         struct ast_format_cap *joint_cap;
 365         int joint_found;
 366 };
 367
 368 static int find_joint_cb(void *obj, void *arg, int flag)
 369 {
 370         struct ast_format *format = obj;
 371         struct find_joint_data *data = arg;
 372
 373         struct ast_format tmp = { 0, };
 374         if (!ast_format_joint(format, data->format, &tmp)) {
 375                 if (data->joint_cap) {
 376                         ast_format_cap_add(data->joint_cap, &tmp);
 377                 }
 378                 data->joint_found++;
 379         }
 380
 381         return 0;
 382 }
 383
 384 int ast_format_cap_has_joint(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
 385 {
 386         struct ao2_iterator it;
 387         struct ast_format *tmp;
 388         struct find_joint_data data = {
 389                 .joint_found = 0,
 390                 .joint_cap = NULL,
 391         };
 392
 393         it = ao2_iterator_init(cap1->formats, cap1->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 394         while ((tmp = ao2_iterator_next(&it))) {
 395                 data.format = tmp;
 396                 ao2_callback(cap2->formats,
 397                         OBJ_MULTIPLE | OBJ_NODATA | cap2->nolock,
 398                         find_joint_cb,
 399                         &data);
 400                 ao2_ref(tmp, -1);
 401         }
 402         ao2_iterator_destroy(&it);
 403
 404         return data.joint_found ? 1 : 0;
 405 }
 406
 407 int ast_format_cap_identical(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
 408 {
 409         struct ao2_iterator it;
 410         struct ast_format *tmp;
 411
 412         if (ao2_container_count(cap1->formats) != ao2_container_count(cap2->formats)) {
 413                 return 0; /* if they are not the same size, they are not identical */
 414         }
 415
 416         it = ao2_iterator_init(cap1->formats, cap1->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 417         while ((tmp = ao2_iterator_next(&it))) {
 418                 if (!ast_format_cap_iscompatible(cap2, tmp)) {
 419                         ao2_ref(tmp, -1);
 420                         ao2_iterator_destroy(&it);
 421                         return 0;
 422                 }
 423                 ao2_ref(tmp, -1);
 424         }
 425         ao2_iterator_destroy(&it);
 426
 427         return 1;
 428 }
 429
 430 struct ast_format_cap *ast_format_cap_joint(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
 431 {
 432         struct ao2_iterator it;
 433         struct ast_format_cap *result = ast_format_cap_alloc_nolock();
 434         struct ast_format *tmp;
 435         struct find_joint_data data = {
 436                 .joint_found = 0,
 437                 .joint_cap = result,
 438         };
 439         if (!result) {
 440                 return NULL;
 441         }
 442
 443         it = ao2_iterator_init(cap1->formats, cap1->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 444         while ((tmp = ao2_iterator_next(&it))) {
 445                 data.format = tmp;
 446                 ao2_callback(cap2->formats,
 447                         OBJ_MULTIPLE | OBJ_NODATA | cap2->nolock,
 448                         find_joint_cb,
 449                         &data);
 450                 ao2_ref(tmp, -1);
 451         }
 452         ao2_iterator_destroy(&it);
 453
 454         if (ao2_container_count(result->formats)) {
 455                 return result;
 456         }
 457
 458         result = ast_format_cap_destroy(result);
 459         return NULL;
 460 }
 461
 462 static int joint_copy_helper(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2, struct ast_format_cap *result, int append)
 463 {
 464         struct ao2_iterator it;
 465         struct ast_format *tmp;
 466         struct find_joint_data data = {
 467                 .joint_cap = result,
 468                 .joint_found = 0,
 469         };
 470         if (!append) {
 471                 ast_format_cap_remove_all(result);
 472         }
 473         it = ao2_iterator_init(cap1->formats, cap2->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 474         while ((tmp = ao2_iterator_next(&it))) {
 475                 data.format = tmp;
 476                 ao2_callback(cap2->formats,
 477                         OBJ_MULTIPLE | OBJ_NODATA | cap2->nolock,
 478                         find_joint_cb,
 479                         &data);
 480                 ao2_ref(tmp, -1);
 481         }
 482         ao2_iterator_destroy(&it);
 483
 484         return ao2_container_count(result->formats) ? 1 : 0;
 485 }
 486
 487 int ast_format_cap_joint_append(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2, struct ast_format_cap *result)
 488 {
 489         return joint_copy_helper(cap1, cap2, result, 1);
 490 }
 491
 492 int ast_format_cap_joint_copy(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2, struct ast_format_cap *result)
 493 {
 494         return joint_copy_helper(cap1, cap2, result, 0);
 495 }
 496
 497 struct ast_format_cap *ast_format_cap_get_type(const struct ast_format_cap *cap, enum ast_format_type ftype)
 498 {
 499         struct ao2_iterator it;
 500         struct ast_format_cap *result = ast_format_cap_alloc_nolock();
 501         struct ast_format *tmp;
 502
 503         if (!result) {
 504                 return NULL;
 505         }
 506
 507         /* for each format in cap1, see if that format is
 508          * compatible with cap2. If so copy it to the result */
 509         it = ao2_iterator_init(cap->formats, cap->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 510         while ((tmp = ao2_iterator_next(&it))) {
 511                 if (AST_FORMAT_GET_TYPE(tmp->id) == ftype) {
 512                         /* copy format */
 513                         ast_format_cap_add(result, tmp);
 514                 }
 515                 ao2_ref(tmp, -1);
 516         }
 517         ao2_iterator_destroy(&it);
 518
 519         if (ao2_container_count(result->formats)) {
 520                 return result;
 521         }
 522         result = ast_format_cap_destroy(result);
 523
 524         return NULL;
 525 }
 526
 527
 528 int ast_format_cap_has_type(const struct ast_format_cap *cap, enum ast_format_type type)
 529 {
 530         struct ao2_iterator it;
 531         struct ast_format *tmp;
 532
 533         it = ao2_iterator_init(cap->formats, cap->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 534         while ((tmp = ao2_iterator_next(&it))) {
 535                 if (AST_FORMAT_GET_TYPE(tmp->id) == type) {
 536                         ao2_ref(tmp, -1);
 537                         ao2_iterator_destroy(&it);
 538                         return 1;
 539                 }
 540                 ao2_ref(tmp, -1);
 541         }
 542         ao2_iterator_destroy(&it);
 543
 544         return 0;
 545 }
 546
 547 void ast_format_cap_iter_start(struct ast_format_cap *cap)
 548 {
 549         if (!cap->nolock) {
 550                 ao2_lock(cap->formats);
 551         }
 552         cap->it = ao2_iterator_init(cap->formats, cap->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 553 }
 554
 555 void ast_format_cap_iter_end(struct ast_format_cap *cap)
 556 {
 557         ao2_iterator_destroy(&cap->it);
 558         if (!cap->nolock) {
 559                 ao2_unlock(cap->formats);
 560         }
 561 }
 562
 563 int ast_format_cap_iter_next(struct ast_format_cap *cap, struct ast_format *format)
 564 {
 565         struct ast_format *tmp = ao2_iterator_next(&cap->it);
 566
 567         if (!tmp) {
 568                 return -1;
 569         }
 570         ast_format_copy(format, tmp);
 571         ao2_ref(tmp, -1);
 572
 573         return 0;
 574 }
 575
 576 char *ast_getformatname_multiple(char *buf, size_t size, struct ast_format_cap *cap)
 577 {
 578         int x;
 579         unsigned len;
 580         char *start, *end = buf;
 581         struct ast_format tmp_fmt;
 582         size_t f_len;
 583         const struct ast_format_list *f_list = ast_format_list_get(&f_len);
 584
 585         if (!size) {
 586                 f_list = ast_format_list_destroy(f_list);
 587                 return buf;
 588         }
 589         snprintf(end, size, "(");
 590         len = strlen(end);
 591         end += len;
 592         size -= len;
 593         start = end;
 594         for (x = 0; x < f_len; x++) {
 595                 ast_format_copy(&tmp_fmt, &f_list[x].format);
 596                 if (ast_format_cap_iscompatible(cap, &tmp_fmt)) {
 597                         snprintf(end, size, "%s|", f_list[x].name);
 598                         len = strlen(end);
 599                         end += len;
 600                         size -= len;
 601                 }
 602         }
 603         if (start == end) {
 604                 ast_copy_string(start, "nothing)", size);
 605         } else if (size > 1) {
 606                 *(end - 1) = ')';
 607         }
 608         f_list = ast_format_list_destroy(f_list);
 609         return buf;
 610 }
 611
 612 uint64_t ast_format_cap_to_old_bitfield(const struct ast_format_cap *cap)
 613 {
 614         uint64_t res = 0;
 615         struct ao2_iterator it;
 616         struct ast_format *tmp;
 617
 618         it = ao2_iterator_init(cap->formats, cap->nolock ? AO2_ITERATOR_DONTLOCK : 0);
 619         while ((tmp = ao2_iterator_next(&it))) {
 620                 res |= ast_format_to_old_bitfield(tmp);
 621                 ao2_ref(tmp, -1);
 622         }
 623         ao2_iterator_destroy(&it);
 624         return res;
 625 }
 626
 627 void ast_format_cap_from_old_bitfield(struct ast_format_cap *dst, uint64_t src)
 628 {
 629         uint64_t tmp = 0;
 630         int x;
 631         struct ast_format tmp_format = { 0, };
 632
 633         ast_format_cap_remove_all(dst);
 634         for (x = 0; x < 64; x++) {
 635                 tmp = (1ULL << x);
 636                 if (tmp & src) {
 637                         ast_format_cap_add(dst, ast_format_from_old_bitfield(&tmp_format, tmp));
 638                 }
 639         }
 640 }