build: Update config.guess and config.sub
[asterisk/asterisk.git] / res / res_format_attr_h263.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, 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
20 /*! \file
21  *
22  * \brief H.263 Format Attribute Module
23  *
24  * \author\verbatim Joshua Colp <jcolp@digium.com> \endverbatim
25  *
26  * This is a format attribute module for the H.263 codec.
27  * \ingroup applications
28  */
29
30 /*** MODULEINFO
31         <support_level>core</support_level>
32  ***/
33
34 #include "asterisk.h"
35
36 #include "asterisk/module.h"
37 #include "asterisk/format.h"
38
39 struct h263_attr {
40         unsigned int SQCIF;       /*!< Minimum picture interval for SQCIF resolution */
41         unsigned int QCIF;        /*!< Minimum picture interval for QCIF resolution */
42         unsigned int CIF;         /*!< Minimum picture interval for CIF resolution */
43         unsigned int CIF4;        /*!< Minimum picture interval for CIF4 resolution */
44         unsigned int CIF16;       /*!< Minimum picture interval for CIF16 resolution */
45         unsigned int VGA;         /*!< Minimum picture interval for VGA resolution */
46         unsigned int CUSTOM_XMAX; /*!< Custom resolution (Xmax) */
47         unsigned int CUSTOM_YMAX; /*!< Custom resolution (Ymax) */
48         unsigned int CUSTOM_MPI;  /*!< Custom resolution (MPI) */
49         unsigned int F;           /*!< F annex support */
50         unsigned int I;           /*!< I annex support */
51         unsigned int J;           /*!< J annex support */
52         unsigned int T;           /*!< T annex support */
53         unsigned int K;           /*!< K annex support */
54         unsigned int N;           /*!< N annex support */
55         unsigned int P_SUB1;      /*!< Reference picture resampling (sub mode 1) */
56         unsigned int P_SUB2;      /*!< Reference picture resampling (sub mode 2) */
57         unsigned int P_SUB3;      /*!< Reference picture resampling (sub mode 3) */
58         unsigned int P_SUB4;      /*!< Reference picture resampling (sub mode 4) */
59         unsigned int PAR_WIDTH;   /*!< Pixel aspect ratio (width) */
60         unsigned int PAR_HEIGHT;  /*!< Pixel aspect ratio (height) */
61         unsigned int BPP;         /*!< Bits per picture maximum */
62         unsigned int HRD;         /*!< Hypothetical reference decoder status */
63 };
64
65 static void h263_destroy(struct ast_format *format)
66 {
67         struct h263_attr *attr = ast_format_get_attribute_data(format);
68
69         ast_free(attr);
70 }
71
72 static int h263_clone(const struct ast_format *src, struct ast_format *dst)
73 {
74         struct h263_attr *original = ast_format_get_attribute_data(src);
75         struct h263_attr *attr = ast_calloc(1, sizeof(*attr));
76
77         if (!attr) {
78                 return -1;
79         }
80
81         if (original) {
82                 *attr = *original;
83         }
84
85         ast_format_set_attribute_data(dst, attr);
86
87         return 0;
88 }
89
90 static enum ast_format_cmp_res h263_cmp(const struct ast_format *format1, const struct ast_format *format2)
91 {
92         struct h263_attr *attr1 = ast_format_get_attribute_data(format1);
93         struct h263_attr *attr2 = ast_format_get_attribute_data(format2);
94
95         if (!attr1 || !attr2 || (attr1 && attr2 && !memcmp(attr1, attr2, sizeof(*attr1)))) {
96                 return AST_FORMAT_CMP_EQUAL;
97         }
98         return AST_FORMAT_CMP_NOT_EQUAL;
99 }
100
101 #define DETERMINE_JOINT(joint, attr1, attr2, field) (joint->field = (attr1 && attr1->field) ? attr1->field : (attr2 && attr2->field) ? attr2->field : 0)
102
103 static struct ast_format *h263_getjoint(const struct ast_format *format1, const struct ast_format *format2)
104 {
105         struct ast_format *cloned;
106         struct h263_attr *attr, *attr1, *attr2;
107
108         cloned = ast_format_clone(format1);
109         if (!cloned) {
110                 return NULL;
111         }
112         attr = ast_format_get_attribute_data(cloned);
113
114         attr1 = ast_format_get_attribute_data(format1);
115         attr2 = ast_format_get_attribute_data(format2);
116
117         DETERMINE_JOINT(attr, attr1, attr2, SQCIF);
118         DETERMINE_JOINT(attr, attr1, attr2, QCIF);
119         DETERMINE_JOINT(attr, attr1, attr2, CIF);
120         DETERMINE_JOINT(attr, attr1, attr2, CIF4);
121         DETERMINE_JOINT(attr, attr1, attr2, CIF16);
122         DETERMINE_JOINT(attr, attr1, attr2, VGA);
123         DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_XMAX);
124         DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_YMAX);
125         DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_MPI);
126         DETERMINE_JOINT(attr, attr1, attr2, F);
127         DETERMINE_JOINT(attr, attr1, attr2, I);
128         DETERMINE_JOINT(attr, attr1, attr2, J);
129         DETERMINE_JOINT(attr, attr1, attr2, T);
130         DETERMINE_JOINT(attr, attr1, attr2, K);
131         DETERMINE_JOINT(attr, attr1, attr2, N);
132         DETERMINE_JOINT(attr, attr1, attr2, P_SUB1);
133         DETERMINE_JOINT(attr, attr1, attr2, P_SUB2);
134         DETERMINE_JOINT(attr, attr1, attr2, P_SUB3);
135         DETERMINE_JOINT(attr, attr1, attr2, P_SUB4);
136         DETERMINE_JOINT(attr, attr1, attr2, PAR_WIDTH);
137         DETERMINE_JOINT(attr, attr1, attr2, PAR_HEIGHT);
138         DETERMINE_JOINT(attr, attr1, attr2, BPP);
139         DETERMINE_JOINT(attr, attr1, attr2, HRD);
140
141         return cloned;
142 }
143
144 static struct ast_format *h263_parse_sdp_fmtp(const struct ast_format *format, const char *attributes)
145 {
146         char *attribs = ast_strdupa(attributes), *attrib;
147         struct ast_format *cloned;
148         struct h263_attr *attr;
149
150         cloned = ast_format_clone(format);
151         if (!cloned) {
152                 return NULL;
153         }
154         attr = ast_format_get_attribute_data(cloned);
155
156         while ((attrib = strsep(&attribs, ";"))) {
157                 unsigned int val, val2 = 0, val3 = 0, val4 = 0;
158
159                 attrib = ast_strip(attrib);
160
161                 if (sscanf(attrib, "SQCIF=%30u", &val) == 1) {
162                         attr->SQCIF = val;
163                 } else if (sscanf(attrib, "QCIF=%30u", &val) == 1) {
164                         attr->QCIF = val;
165                 } else if (sscanf(attrib, "CIF=%30u", &val) == 1) {
166                         attr->CIF = val;
167                 } else if (sscanf(attrib, "CIF4=%30u", &val) == 1) {
168                         attr->CIF4 = val;
169                 } else if (sscanf(attrib, "CIF16=%30u", &val) == 1) {
170                         attr->CIF16 = val;
171                 } else if (sscanf(attrib, "VGA=%30u", &val) == 1) {
172                         attr->VGA = val;
173                 } else if (sscanf(attrib, "CUSTOM=%30u,%30u,%30u", &val, &val2, &val3) == 3) {
174                         attr->CUSTOM_XMAX = val;
175                         attr->CUSTOM_YMAX = val2;
176                         attr->CUSTOM_MPI = val3;
177                 } else if (sscanf(attrib, "F=%30u", &val) == 1) {
178                         attr->F = val;
179                 } else if (sscanf(attrib, "I=%30u", &val) == 1) {
180                         attr->I = val;
181                 } else if (sscanf(attrib, "J=%30u", &val) == 1) {
182                         attr->J = val;
183                 } else if (sscanf(attrib, "T=%30u", &val) == 1) {
184                         attr->T = val;
185                 } else if (sscanf(attrib, "K=%30u", &val) == 1) {
186                         attr->K = val;
187                 } else if (sscanf(attrib, "N=%30u", &val) == 1) {
188                         attr->N = val;
189                 } else if (sscanf(attrib, "PAR=%30u:%30u", &val, &val2) == 2) {
190                         attr->PAR_WIDTH = val;
191                         attr->PAR_HEIGHT = val2;
192                 } else if (sscanf(attrib, "BPP=%30u", &val) == 1) {
193                         attr->BPP = val;
194                 } else if (sscanf(attrib, "HRD=%30u", &val) == 1) {
195                         attr->HRD = val;
196                 } else if (sscanf(attrib, "P=%30u,%30u,%30u,%30u", &val, &val2, &val3, &val4) > 0) {
197                         attr->P_SUB1 = val;
198                         attr->P_SUB2 = val2;
199                         attr->P_SUB3 = val3;
200                         attr->P_SUB4 = val4;
201                 }
202         }
203
204         return cloned;
205 }
206
207 static void h263_generate_sdp_fmtp(const struct ast_format *format, unsigned int payload, struct ast_str **str)
208 {
209         struct h263_attr *attr = ast_format_get_attribute_data(format);
210
211         if (!attr) {
212                 return;
213         }
214
215         ast_str_append(str, 0, "a=fmtp:%u SQCIF=%u;QCIF=%u;CIF=%u;CIF4=%u;CIF16=%u;VGA=%u;F=%u;I=%u;J=%u;T=%u;K=%u;N=%u;BPP=%u;HRD=%u",
216                 payload, attr->SQCIF, attr->QCIF, attr->CIF, attr->CIF4, attr->CIF16, attr->VGA, attr->F, attr->I, attr->J,
217                 attr->T, attr->K, attr->N, attr->BPP, attr->HRD);
218
219         if (attr->CUSTOM_XMAX && attr->CUSTOM_YMAX && attr->CUSTOM_MPI) {
220                 ast_str_append(str, 0, ";CUSTOM=%u,%u,%u", attr->CUSTOM_XMAX, attr->CUSTOM_YMAX, attr->CUSTOM_MPI);
221         }
222
223         if (attr->PAR_WIDTH && attr->PAR_HEIGHT) {
224                 ast_str_append(str, 0, ";PAR=%u:%u", attr->PAR_WIDTH, attr->PAR_HEIGHT);
225         }
226
227         if (attr->P_SUB1) {
228                 ast_str_append(str, 0, ";P=%u", attr->P_SUB1);
229                 if (attr->P_SUB2) {
230                         ast_str_append(str, 0, ",%u", attr->P_SUB2);
231                 }
232                 if (attr->P_SUB3) {
233                         ast_str_append(str, 0, ",%u", attr->P_SUB3);
234                 }
235                 if (attr->P_SUB4) {
236                         ast_str_append(str, 0, ",%u", attr->P_SUB4);
237                 }
238         }
239
240         ast_str_append(str, 0, "\r\n");
241
242         return;
243 }
244
245 static struct ast_format_interface h263_interface = {
246         .format_destroy = h263_destroy,
247         .format_clone = h263_clone,
248         .format_cmp = h263_cmp,
249         .format_get_joint = h263_getjoint,
250         .format_parse_sdp_fmtp = h263_parse_sdp_fmtp,
251         .format_generate_sdp_fmtp = h263_generate_sdp_fmtp,
252 };
253
254 static int unload_module(void)
255 {
256         return 0;
257 }
258
259 static int load_module(void)
260 {
261         if (ast_format_interface_register("h263", &h263_interface)) {
262                 return AST_MODULE_LOAD_DECLINE;
263         }
264
265         if (ast_format_interface_register("h263p", &h263_interface)) {
266                 return AST_MODULE_LOAD_DECLINE;
267         }
268
269         return AST_MODULE_LOAD_SUCCESS;
270 }
271
272 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "H.263 Format Attribute Module",
273         .support_level = AST_MODULE_SUPPORT_CORE,
274         .load = load_module,
275         .unload = unload_module,
276 );