res_format_attr_vp8: In SDP, forward max-fr and max-fs for video-codec VP8.
[asterisk/asterisk.git] / res / res_format_attr_vp8.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2015, Alexander Traud
5  *
6  * Alexander Traud <pabstraud@compuserve.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 VP8 format attribute interface
22  *
23  * \author Alexander Traud <pabstraud@compuserve.com>
24  *
25  * \note http://tools.ietf.org/html/draft-ietf-payload-vp8
26  */
27
28 /*** MODULEINFO
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_REGISTER_FILE()
35
36 #include "asterisk/module.h"
37 #include "asterisk/format.h"
38 #include "asterisk/logger.h"            /* for ast_log, LOG_WARNING */
39 #include "asterisk/strings.h"           /* for ast_str_append */
40 #include "asterisk/utils.h"             /* for MIN, ast_malloc, ast_free */
41
42 struct vp8_attr {
43         unsigned int maximum_frame_rate;
44         unsigned int maximum_frame_size;
45 };
46
47 static struct vp8_attr default_vp8_attr = {
48         .maximum_frame_rate = UINT_MAX,
49         .maximum_frame_size = UINT_MAX,
50 };
51
52 static void vp8_destroy(struct ast_format *format)
53 {
54         struct vp8_attr *attr = ast_format_get_attribute_data(format);
55
56         ast_free(attr);
57 }
58
59 static int vp8_clone(const struct ast_format *src, struct ast_format *dst)
60 {
61         struct vp8_attr *original = ast_format_get_attribute_data(src);
62         struct vp8_attr *attr = ast_malloc(sizeof(*attr));
63
64         if (!attr) {
65                 return -1;
66         }
67
68         if (original) {
69                 *attr = *original;
70         } else {
71                 *attr = default_vp8_attr;
72         }
73
74         ast_format_set_attribute_data(dst, attr);
75
76         return 0;
77 }
78
79 static struct ast_format *vp8_parse_sdp_fmtp(const struct ast_format *format, const char *attributes)
80 {
81         struct ast_format *cloned;
82         struct vp8_attr *attr;
83         const char *kvp;
84         unsigned int val;
85
86         cloned = ast_format_clone(format);
87         if (!cloned) {
88                 return NULL;
89         }
90         attr = ast_format_get_attribute_data(cloned);
91
92         if ((kvp = strstr(attributes, "max-fr")) && sscanf(kvp, "max-fr=%30u", &val) == 1) {
93                 attr->maximum_frame_rate = val;
94         } else {
95                 attr->maximum_frame_rate = UINT_MAX;
96         }
97
98         if ((kvp = strstr(attributes, "max-fs")) && sscanf(kvp, "max-fs=%30u", &val) == 1) {
99                 attr->maximum_frame_size = val;
100         } else {
101                 attr->maximum_frame_size = UINT_MAX;
102         }
103
104         return cloned;
105 }
106
107 static void vp8_generate_sdp_fmtp(const struct ast_format *format, unsigned int payload, struct ast_str **str)
108 {
109         struct vp8_attr *attr = ast_format_get_attribute_data(format);
110         int added = 0;
111
112         if (!attr) {
113                 /*
114                  * (Only) cached formats do not have attribute data assigned because
115                  * they were created before this attribute module was registered.
116                  * Therefore, we assume the default attribute values here.
117                  */
118                 attr = &default_vp8_attr;
119         }
120
121         if (UINT_MAX != attr->maximum_frame_rate) {
122                 if (added) {
123                         ast_str_append(str, 0, ";");
124                 } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
125                         added = 1;
126                 }
127                 ast_str_append(str, 0, "max-fr=%u", attr->maximum_frame_rate);
128         }
129
130         if (UINT_MAX != attr->maximum_frame_size) {
131                 if (added) {
132                         ast_str_append(str, 0, ";");
133                 } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
134                         added = 1;
135                 }
136                 ast_str_append(str, 0, "max-fs=%u", attr->maximum_frame_size);
137         }
138
139         if (added) {
140                 ast_str_append(str, 0, "\r\n");
141         }
142 }
143
144 static struct ast_format *vp8_getjoint(const struct ast_format *format1, const struct ast_format *format2)
145 {
146         struct vp8_attr *attr1 = ast_format_get_attribute_data(format1);
147         struct vp8_attr *attr2 = ast_format_get_attribute_data(format2);
148         struct ast_format *jointformat;
149         struct vp8_attr *attr_res;
150
151         if (!attr1) {
152                 attr1 = &default_vp8_attr;
153         }
154
155         if (!attr2) {
156                 attr2 = &default_vp8_attr;
157         }
158
159         jointformat = ast_format_clone(format1);
160         if (!jointformat) {
161                 return NULL;
162         }
163         attr_res = ast_format_get_attribute_data(jointformat);
164
165         attr_res->maximum_frame_rate = MIN(attr1->maximum_frame_rate, attr2->maximum_frame_rate);
166         attr_res->maximum_frame_size = MIN(attr1->maximum_frame_size, attr2->maximum_frame_size);
167
168         return jointformat;
169 }
170
171 static struct ast_format *vp8_set(const struct ast_format *format, const char *name, const char *value)
172 {
173         struct ast_format *cloned;
174         struct vp8_attr *attr;
175         unsigned int val;
176
177         if (sscanf(value, "%30u", &val) != 1) {
178                 ast_log(LOG_WARNING, "Unknown value '%s' for attribute type '%s'\n",
179                         value, name);
180                 return NULL;
181         }
182
183         cloned = ast_format_clone(format);
184         if (!cloned) {
185                 return NULL;
186         }
187         attr = ast_format_get_attribute_data(cloned);
188
189         if (!strcasecmp(name, "maximum_frame_rate")) {
190                 attr->maximum_frame_rate = val;
191         } else if (!strcasecmp(name, "maximum_frame_size")) {
192                 attr->maximum_frame_size = val;
193         } else {
194                 ast_log(LOG_WARNING, "unknown attribute type %s\n", name);
195         }
196
197         return cloned;
198 }
199
200 static struct ast_format_interface vp8_interface = {
201         .format_destroy = vp8_destroy,
202         .format_clone = vp8_clone,
203         .format_get_joint = vp8_getjoint,
204         .format_attribute_set = vp8_set,
205         .format_parse_sdp_fmtp = vp8_parse_sdp_fmtp,
206         .format_generate_sdp_fmtp = vp8_generate_sdp_fmtp,
207 };
208
209 static int load_module(void)
210 {
211         if (ast_format_interface_register("vp8", &vp8_interface)) {
212                 return AST_MODULE_LOAD_DECLINE;
213         }
214
215         return AST_MODULE_LOAD_SUCCESS;
216 }
217
218 static int unload_module(void)
219 {
220         return 0;
221 }
222
223 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "VP8 Format Attribute Module",
224         .support_level = AST_MODULE_SUPPORT_CORE,
225         .load = load_module,
226         .unload = unload_module,
227         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
228 );