Avoid cppcheck warnings; removing unused vars and a bit of cleanup.
[asterisk/asterisk.git] / res / res_format_attr_silk.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2011, 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 SILK format attribute interface
22  *
23  * \author David Vossel <dvossel@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include "asterisk/module.h"
35 #include "asterisk/format.h"
36
37 /*!
38  * \brief SILK attribute structure.
39  *
40  * \note The only attribute that affects compatibility here is the sample rate.
41  */
42 struct silk_attr {
43         unsigned int samplerate;
44         unsigned int maxbitrate;
45         unsigned int dtx;
46         unsigned int fec;
47         unsigned int packetloss_percentage;
48 };
49
50 static enum ast_format_cmp_res silk_cmp(const struct ast_format_attr *fattr1, const struct ast_format_attr *fattr2)
51 {
52         struct silk_attr *attr1 = (struct silk_attr *) fattr1;
53         struct silk_attr *attr2 = (struct silk_attr *) fattr2;
54
55         if (attr1->samplerate == attr2->samplerate) {
56                 return AST_FORMAT_CMP_EQUAL;
57         }
58         return AST_FORMAT_CMP_NOT_EQUAL;
59 }
60
61 static int silk_get_val(const struct ast_format_attr *fattr, int key, void *result)
62 {
63         const struct silk_attr *attr = (struct silk_attr *) fattr;
64         int *val = result;
65
66         switch (key) {
67         case SILK_ATTR_KEY_SAMP_RATE:
68                 *val = attr->samplerate;
69                 break;
70         case SILK_ATTR_KEY_MAX_BITRATE:
71                 *val = attr->maxbitrate;
72                 break;
73         case SILK_ATTR_KEY_DTX:
74                 *val = attr->dtx;
75                 break;
76         case SILK_ATTR_KEY_FEC:
77                 *val = attr->fec;
78                 break;
79         case SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE:
80                 *val = attr->packetloss_percentage;
81                 break;
82         default:
83                 ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
84                 return -1;
85         }
86         return 0;
87 }
88
89 static int silk_isset(const struct ast_format_attr *fattr, va_list ap)
90 {
91         enum silk_attr_keys key;
92         const struct silk_attr *attr = (struct silk_attr *) fattr;
93
94         for (key = va_arg(ap, int);
95                 key != AST_FORMAT_ATTR_END;
96                 key = va_arg(ap, int))
97         {
98                 switch (key) {
99                 case SILK_ATTR_KEY_SAMP_RATE:
100                         if (attr->samplerate != (va_arg(ap, int))) {
101                                 return -1;
102                         }
103                         break;
104                 case SILK_ATTR_KEY_MAX_BITRATE:
105                         if (attr->maxbitrate != (va_arg(ap, int))) {
106                                 return -1;
107                         }
108                         break;
109                 case SILK_ATTR_KEY_DTX:
110                         if (attr->dtx != (va_arg(ap, int))) {
111                                 return -1;
112                         }
113                         break;
114                 case SILK_ATTR_KEY_FEC:
115                         if (attr->fec != (va_arg(ap, int))) {
116                                 return -1;
117                         }
118                         break;
119                 case SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE:
120                         if (attr->packetloss_percentage != (va_arg(ap, int))) {
121                                 return -1;
122                         }
123                         break;
124                 default:
125                         ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
126                         return -1;
127                 }
128         }
129         return 0;
130 }
131 static int silk_getjoint(const struct ast_format_attr *fattr1, const struct ast_format_attr *fattr2, struct ast_format_attr *result)
132 {
133         struct silk_attr *attr1 = (struct silk_attr *) fattr1;
134         struct silk_attr *attr2 = (struct silk_attr *) fattr2;
135         struct silk_attr *attr_res = (struct silk_attr *) result;
136         int joint = -1;
137
138         attr_res->samplerate = attr1->samplerate & attr2->samplerate;
139         /* sample rate is the only attribute that has any bearing on if joint capabilities exist or not */
140         if (attr_res->samplerate) {
141                 joint = 0;
142         }
143         /* Take the lowest max bitrate */
144         attr_res->maxbitrate = MIN(attr1->maxbitrate, attr2->maxbitrate);
145
146         /* Only do dtx if both sides want it. DTX is a trade off between
147          * computational complexity and bandwidth. */
148         attr_res->dtx = attr1->dtx && attr2->dtx ? 1 : 0;
149
150         /* Only do FEC if both sides want it.  If a peer specifically requests not
151          * to receive with FEC, it may be a waste of bandwidth. */
152         attr_res->fec = attr1->fec && attr2->fec ? 1 : 0;
153
154         /* Use the maximum packetloss percentage between the two attributes. This affects how
155          * much redundancy is used in the FEC. */
156         attr_res->packetloss_percentage = MAX(attr1->packetloss_percentage, attr2->packetloss_percentage);
157         return joint;
158 }
159
160 static void silk_set(struct ast_format_attr *fattr, va_list ap)
161 {
162         enum silk_attr_keys key;
163         struct silk_attr *attr = (struct silk_attr *) fattr;
164
165         for (key = va_arg(ap, int);
166                 key != AST_FORMAT_ATTR_END;
167                 key = va_arg(ap, int))
168         {
169                 switch (key) {
170                 case SILK_ATTR_KEY_SAMP_RATE:
171                         attr->samplerate = (va_arg(ap, int));
172                         break;
173                 case SILK_ATTR_KEY_MAX_BITRATE:
174                         attr->maxbitrate = (va_arg(ap, int));
175                         break;
176                 case SILK_ATTR_KEY_DTX:
177                         attr->dtx = (va_arg(ap, int));
178                         break;
179                 case SILK_ATTR_KEY_FEC:
180                         attr->fec = (va_arg(ap, int));
181                         break;
182                 case SILK_ATTR_KEY_PACKETLOSS_PERCENTAGE:
183                         attr->packetloss_percentage = (va_arg(ap, int));
184                         break;
185                 default:
186                         ast_log(LOG_WARNING, "unknown attribute type %d\n", key);
187                 }
188         }
189 }
190
191 static struct ast_format_attr_interface silk_interface = {
192         .id = AST_FORMAT_SILK,
193         .format_attr_cmp = silk_cmp,
194         .format_attr_get_joint = silk_getjoint,
195         .format_attr_set = silk_set,
196         .format_attr_isset = silk_isset,
197         .format_attr_get_val = silk_get_val,
198 };
199
200 static int load_module(void)
201 {
202         if (ast_format_attr_reg_interface(&silk_interface)) {
203                 return AST_MODULE_LOAD_DECLINE;
204         }
205
206         return AST_MODULE_LOAD_SUCCESS;
207 }
208
209 static int unload_module(void)
210 {
211         ast_format_attr_unreg_interface(&silk_interface);
212         return 0;
213 }
214
215 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "SILK Format Attribute Module",
216         .load = load_module,
217         .unload = unload_module,
218         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
219 );