git migration: Refactor the ASTERISK_FILE_VERSION macro
[asterisk/asterisk.git] / channels / iax2 / codec_pref.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2014, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@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 /*! \file
20  *
21  * \brief Media Format Bitfield Compatibility API
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_REGISTER_FILE()
33
34 #include "asterisk/logger.h"
35 #include "asterisk/astobj2.h"
36 #include "asterisk/codec.h"
37 #include "asterisk/format.h"
38 #include "asterisk/format_compatibility.h"
39 #include "asterisk/format_cache.h"
40 #include "asterisk/format_cap.h"
41 #include "asterisk/utils.h"
42
43 #include "include/codec_pref.h"
44 #include "include/format_compatibility.h"
45
46 void iax2_codec_pref_convert(struct iax2_codec_pref *pref, char *buf, size_t size, int right)
47 {
48         static int differential = (int) 'A';
49         int x;
50
51         if (right) {
52                 --size;/* Save room for the nul string terminator. */
53                 for (x = 0; x < ARRAY_LEN(pref->order) && x < size; ++x) {
54                         if (!pref->order[x]) {
55                                 break;
56                         }
57
58                         buf[x] = pref->order[x] + differential;
59                 }
60
61                 buf[x] = '\0';
62         } else {
63                 for (x = 0; x < ARRAY_LEN(pref->order) && x < size; ++x) {
64                         if (buf[x] == '\0') {
65                                 break;
66                         }
67
68                         pref->order[x] = buf[x] - differential;
69                         pref->framing[x] = 0;
70                 }
71
72                 if (x < ARRAY_LEN(pref->order)) {
73                         pref->order[x] = 0;
74                         pref->framing[x] = 0;
75                 }
76         }
77 }
78
79 struct ast_format *iax2_codec_pref_index(struct iax2_codec_pref *pref, int idx, struct ast_format **result)
80 {
81         if (0 <= idx && idx < ARRAY_LEN(pref->order) && pref->order[idx]) {
82                 uint64_t pref_bitfield;
83
84                 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
85                 *result = ast_format_compatibility_bitfield2format(pref_bitfield);
86         } else {
87                 *result = NULL;
88         }
89
90         return *result;
91 }
92
93 int iax2_codec_pref_to_cap(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
94 {
95         int idx;
96
97         for (idx = 0; idx < ARRAY_LEN(pref->order); ++idx) {
98                 uint64_t pref_bitfield;
99                 struct ast_format *pref_format;
100
101                 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
102                 if (!pref_bitfield) {
103                         break;
104                 }
105
106                 pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
107                 if (pref_format && ast_format_cap_append(cap, pref_format, pref->framing[idx])) {
108                         return -1;
109                 }
110         }
111         return 0;
112 }
113
114 int iax2_codec_pref_best_bitfield2cap(uint64_t bitfield, struct iax2_codec_pref *prefs, struct ast_format_cap *cap)
115 {
116         uint64_t best_bitfield;
117         struct ast_format *format;
118
119         /* Add any user preferred codecs first. */
120         if (prefs) {
121                 int idx;
122
123                 for (idx = 0; bitfield && idx < ARRAY_LEN(prefs->order); ++idx) {
124                         best_bitfield = iax2_codec_pref_order_value_to_format_bitfield(prefs->order[idx]);
125                         if (!best_bitfield) {
126                                 break;
127                         }
128
129                         if (best_bitfield & bitfield) {
130                                 format = ast_format_compatibility_bitfield2format(best_bitfield);
131                                 if (format && ast_format_cap_append(cap, format, prefs->framing[idx])) {
132                                         return -1;
133                                 }
134
135                                 /* Remove just added codec. */
136                                 bitfield &= ~best_bitfield;
137                         }
138                 }
139         }
140
141         /* Add the hard coded "best" codecs. */
142         while (bitfield) {
143                 best_bitfield = iax2_format_compatibility_best(bitfield);
144                 if (!best_bitfield) {
145                         /* No more codecs considered best. */
146                         break;
147                 }
148
149                 format = ast_format_compatibility_bitfield2format(best_bitfield);
150                 /* The best_bitfield should always be convertible to a format. */
151                 ast_assert(format != NULL);
152
153                 if (ast_format_cap_append(cap, format, 0)) {
154                         return -1;
155                 }
156
157                 /* Remove just added "best" codec to find the next "best". */
158                 bitfield &= ~best_bitfield;
159         }
160
161         /* Add any remaining codecs. */
162         if (bitfield) {
163                 int bit;
164
165                 for (bit = 0; bit < 64; ++bit) {
166                         uint64_t mask = (1ULL << bit);
167
168                         if (mask & bitfield) {
169                                 format = ast_format_compatibility_bitfield2format(mask);
170                                 if (format && ast_format_cap_append(cap, format, 0)) {
171                                         return -1;
172                                 }
173                         }
174                 }
175         }
176
177         return 0;
178 }
179
180 int iax2_codec_pref_string(struct iax2_codec_pref *pref, char *buf, size_t size)
181 {
182         int x;
183         struct ast_format_cap *cap;
184         size_t total_len;
185         char *cur;
186
187         /* This function is useless if you have less than a 6 character buffer.
188          * '(...)' is six characters. */
189         if (size < 6) {
190                 return -1;
191         }
192
193         /* Convert the preferences into a format cap so that we can read the format names */
194         cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
195         if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
196                 strcpy(buf, "(...)"); /* Safe */
197                 ao2_cleanup(cap);
198                 return -1;
199         }
200
201         /* We know that at a minimum, 3 characters are used - (, ), and \0 */
202         total_len = size - 3;
203
204         /* This character has already been accounted for total_len purposes */
205         buf[0] = '(';
206         cur = buf + 1;
207
208         /* Loop through the formats and write as many into the buffer as we can */
209         for (x = 0; x < ast_format_cap_count(cap); x++) {
210                 size_t name_len;
211                 struct ast_format *fmt = ast_format_cap_get_format(cap, x);
212                 const char *name = ast_format_get_name(fmt);
213
214                 name_len = strlen(name);
215
216                 /* all entries after the first need a delimiter character */
217                 if (x) {
218                         name_len++;
219                 }
220
221                 /* Terminate the list early if we don't have room for the entry.
222                  * If it's not the last entry in the list, save enough room to write '...'.
223                  */
224                 if (((x == ast_format_cap_count(cap) - 1) && (total_len < name_len)) ||
225                                 ((x < ast_format_cap_count(cap) - 1) && (total_len < name_len + 3))) {
226                         strcpy(cur, "...");
227                         cur += 3;
228                         total_len -= 3;
229                         ao2_ref(fmt, -1);
230                         break;
231                 }
232
233                 sprintf(cur, "%s%s", x ? "|" : "", name);
234                 cur += name_len;
235                 total_len -= name_len;
236
237                 ao2_ref(fmt, -1);
238         }
239         ao2_ref(cap, -1);
240
241         /* These two characters have already been accounted for total_len purposes */
242         cur[0] = ')';
243         cur[1] = '\0';
244
245         return size - total_len;
246 }
247
248 static void codec_pref_remove_index(struct iax2_codec_pref *pref, int codec_pref_index)
249 {
250         int idx;
251
252         idx = codec_pref_index;
253         if (idx == ARRAY_LEN(pref->order) - 1) {
254                 /* Remove from last array entry. */
255                 pref->order[idx] = 0;
256                 pref->framing[idx] = 0;
257                 return;
258         }
259
260         for (; idx < ARRAY_LEN(pref->order); ++idx) {
261                 pref->order[idx] = pref->order[idx + 1];
262                 pref->framing[idx] = pref->framing[idx + 1];
263                 if (!pref->order[idx]) {
264                         return;
265                 }
266         }
267 }
268
269 /*! \brief Remove codec from pref list */
270 static void codec_pref_remove(struct iax2_codec_pref *pref, int format_index)
271 {
272         int x;
273
274         if (!pref->order[0]) {
275                 return;
276         }
277
278         for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
279                 if (!pref->order[x]) {
280                         break;
281                 }
282
283                 if (pref->order[x] == format_index) {
284                         codec_pref_remove_index(pref, x);
285                         break;
286                 }
287         }
288 }
289
290 void iax2_codec_pref_remove_missing(struct iax2_codec_pref *pref, uint64_t bitfield)
291 {
292         int idx;
293
294         if (!pref->order[0]) {
295                 return;
296         }
297
298         /*
299          * Work from the end of the list so we always deal with
300          * unmodified entries in case we have to remove a pref.
301          */
302         for (idx = ARRAY_LEN(pref->order); idx--;) {
303                 uint64_t pref_bitfield;
304
305                 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[idx]);
306                 if (!pref_bitfield) {
307                         continue;
308                 }
309
310                 /* If this format isn't in the bitfield, remove it from the prefs. */
311                 if (!(pref_bitfield & bitfield)) {
312                         codec_pref_remove_index(pref, idx);
313                 }
314         }
315 }
316
317 /*!
318  * \brief Formats supported by IAX2.
319  *
320  * \note All AST_FORMAT_xxx compatibility bit defines must be
321  *  represented here.
322  *
323  * \note The order is important because the array index+1 values
324  * go out over the wire.
325  */
326 static const uint64_t iax2_supported_formats[] = {
327         AST_FORMAT_G723,
328         AST_FORMAT_GSM,
329         AST_FORMAT_ULAW,
330         AST_FORMAT_ALAW,
331         AST_FORMAT_G726,
332         AST_FORMAT_ADPCM,
333         AST_FORMAT_SLIN,
334         AST_FORMAT_LPC10,
335         AST_FORMAT_G729,
336         AST_FORMAT_SPEEX,
337         AST_FORMAT_SPEEX16,
338         AST_FORMAT_ILBC,
339         AST_FORMAT_G726_AAL2,
340         AST_FORMAT_G722,
341         AST_FORMAT_SLIN16,
342         AST_FORMAT_JPEG,
343         AST_FORMAT_PNG,
344         AST_FORMAT_H261,
345         AST_FORMAT_H263,
346         AST_FORMAT_H263P,
347         AST_FORMAT_H264,
348         AST_FORMAT_MP4,
349         AST_FORMAT_T140_RED,
350         AST_FORMAT_T140,
351         AST_FORMAT_SIREN7,
352         AST_FORMAT_SIREN14,
353         AST_FORMAT_TESTLAW,
354         AST_FORMAT_G719,
355         0, /* Place holder */
356         0, /* Place holder */
357         0, /* Place holder */
358         0, /* Place holder */
359         0, /* Place holder */
360         0, /* Place holder */
361         0, /* Place holder */
362         0, /* Place holder */
363         AST_FORMAT_OPUS,
364         AST_FORMAT_VP8,
365         /* ONLY ADD TO THE END OF THIS LIST */
366         /* XXX Use up the place holder slots first. */
367 };
368
369 uint64_t iax2_codec_pref_order_value_to_format_bitfield(int order_value)
370 {
371         if (order_value < 1 || ARRAY_LEN(iax2_supported_formats) < order_value) {
372                 return 0;
373         }
374
375         return iax2_supported_formats[order_value - 1];
376 }
377
378 int iax2_codec_pref_format_bitfield_to_order_value(uint64_t bitfield)
379 {
380         int idx;
381
382         if (bitfield) {
383                 for (idx = 0; idx < ARRAY_LEN(iax2_supported_formats); ++idx) {
384                         if (iax2_supported_formats[idx] == bitfield) {
385                                 return idx + 1;
386                         }
387                 }
388         }
389         return 0;
390 }
391
392 /*!
393  * \internal
394  * \brief Append the bitfield format to the codec preference list.
395  * \since 13.0.0
396  *
397  * \param pref Codec preference list to append the given bitfield.
398  * \param bitfield Format bitfield to append.
399  * \param framing Framing size of the codec.
400  *
401  * \return Nothing
402  */
403 static void iax2_codec_pref_append_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield, unsigned int framing)
404 {
405         int format_index;
406         int x;
407
408         format_index = iax2_codec_pref_format_bitfield_to_order_value(bitfield);
409         if (!format_index) {
410                 return;
411         }
412
413         codec_pref_remove(pref, format_index);
414
415         for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
416                 if (!pref->order[x]) {
417                         pref->order[x] = format_index;
418                         pref->framing[x] = framing;
419                         break;
420                 }
421         }
422 }
423
424 void iax2_codec_pref_append(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing)
425 {
426         uint64_t bitfield;
427
428         bitfield = ast_format_compatibility_format2bitfield(format);
429         if (!bitfield) {
430                 return;
431         }
432
433         iax2_codec_pref_append_bitfield(pref, bitfield, framing);
434 }
435
436 void iax2_codec_pref_prepend(struct iax2_codec_pref *pref, struct ast_format *format, unsigned int framing,
437         int only_if_existing)
438 {
439         uint64_t bitfield;
440         int format_index;
441         int x;
442
443         bitfield = ast_format_compatibility_format2bitfield(format);
444         if (!bitfield) {
445                 return;
446         }
447         format_index = iax2_codec_pref_format_bitfield_to_order_value(bitfield);
448         if (!format_index) {
449                 return;
450         }
451
452         /* Now find any existing occurrence, or the end */
453         for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
454                 if (!pref->order[x] || pref->order[x] == format_index)
455                         break;
456         }
457
458         /*
459          * The array can never be full without format_index
460          * also being in the array.
461          */
462         ast_assert(x < ARRAY_LEN(pref->order));
463
464         /* If we failed to find any occurrence, set to the end for safety. */
465         if (ARRAY_LEN(pref->order) <= x) {
466                 x = ARRAY_LEN(pref->order) - 1;
467         }
468
469         if (only_if_existing && !pref->order[x]) {
470                 return;
471         }
472
473         /* Move down to make space to insert - either all the way to the end,
474            or as far as the existing location (which will be overwritten) */
475         for (; x > 0; --x) {
476                 pref->order[x] = pref->order[x - 1];
477                 pref->framing[x] = pref->framing[x - 1];
478         }
479
480         /* And insert the new entry */
481         pref->order[0] = format_index;
482         pref->framing[0] = framing;
483 }
484
485 uint64_t iax2_codec_pref_from_bitfield(struct iax2_codec_pref *pref, uint64_t bitfield)
486 {
487         int bit;
488         uint64_t working_bitfield;
489         uint64_t best_bitfield;
490         struct ast_format *format;
491
492         /* Init the preference list. */
493         memset(pref, 0, sizeof(*pref));
494
495         working_bitfield = bitfield;
496
497         /* Add the "best" codecs first. */
498         while (working_bitfield) {
499                 best_bitfield = iax2_format_compatibility_best(working_bitfield);
500                 if (!best_bitfield) {
501                         /* No more codecs considered best. */
502                         break;
503                 }
504
505                 /* Remove current "best" codec to find the next "best". */
506                 working_bitfield &= ~best_bitfield;
507
508                 format = ast_format_compatibility_bitfield2format(best_bitfield);
509                 /* The best_bitfield should always be convertible to a format. */
510                 ast_assert(format != NULL);
511
512                 iax2_codec_pref_append_bitfield(pref, best_bitfield, 0);
513         }
514
515         /* Add any remaining codecs. */
516         if (working_bitfield) {
517                 for (bit = 0; bit < 64; ++bit) {
518                         uint64_t mask = (1ULL << bit);
519
520                         if (mask & working_bitfield) {
521                                 format = ast_format_compatibility_bitfield2format(mask);
522                                 if (!format) {
523                                         /* The bit is not associated with any format. */
524                                         bitfield &= ~mask;
525                                         continue;
526                                 }
527
528                                 iax2_codec_pref_append_bitfield(pref, mask, 0);
529                         }
530                 }
531         }
532
533         return bitfield;
534 }