1 files changed, 165 insertions, 184 deletions

diff --git a/res/res_format_attr_h263.c b/res/res_format_attr_h263.c
index 8ec28aac9..121beb1bc 100644
--- a/res/res_format_attr_h263.c
+++ b/res/res_format_attr_h263.c
@@ -38,250 +38,231 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/module.h"
 #include "asterisk/format.h"
 
-enum h263_attr_keys {
-	H263_ATTR_KEY_SQCIF,       /*!< Minimum picture interval for SQCIF resolution */
-	H263_ATTR_KEY_QCIF,        /*!< Minimum picture interval for QCIF resolution */
-	H263_ATTR_KEY_CIF,         /*!< Minimum picture interval for CIF resolution */
-	H263_ATTR_KEY_CIF4,        /*!< Minimum picture interval for CIF4 resolution */
-	H263_ATTR_KEY_CIF16,       /*!< Minimum picture interval for CIF16 resolution */
-	H263_ATTR_KEY_VGA,         /*!< Minimum picture interval for VGA resolution */
-	H263_ATTR_KEY_CUSTOM_XMAX, /*!< Custom resolution (Xmax) */
-	H263_ATTR_KEY_CUSTOM_YMAX, /*!< Custom resolution (Ymax) */
-	H263_ATTR_KEY_CUSTOM_MPI,  /*!< Custom resolution (MPI) */
-	H263_ATTR_KEY_F,           /*!< F annex support */
-	H263_ATTR_KEY_I,           /*!< I annex support */
-	H263_ATTR_KEY_J,           /*!< J annex support */
-	H263_ATTR_KEY_T,           /*!< T annex support */
-	H263_ATTR_KEY_K,           /*!< K annex support */
-	H263_ATTR_KEY_N,           /*!< N annex support */
-	H263_ATTR_KEY_P_SUB1,      /*!< Reference picture resampling (sub mode 1) */
-	H263_ATTR_KEY_P_SUB2,      /*!< Reference picture resampling (sub mode 2) */
-	H263_ATTR_KEY_P_SUB3,      /*!< Reference picture resampling (sub mode 3) */
-	H263_ATTR_KEY_P_SUB4,      /*!< Reference picture resampling (sub mode 4) */
-	H263_ATTR_KEY_PAR_WIDTH,   /*!< Pixel aspect ratio (width) */
-	H263_ATTR_KEY_PAR_HEIGHT,  /*!< Pixel aspect ratio (height) */
-	H263_ATTR_KEY_BPP,         /*!< Bits per picture maximum */
-	H263_ATTR_KEY_HRD,         /*!< Hypothetical reference decoder status */
-	H263_ATTR_KEY_END,         /*!< End terminator for list */
+struct h263_attr {
+	unsigned int SQCIF;       /*!< Minimum picture interval for SQCIF resolution */
+	unsigned int QCIF;        /*!< Minimum picture interval for QCIF resolution */
+	unsigned int CIF;         /*!< Minimum picture interval for CIF resolution */
+	unsigned int CIF4;        /*!< Minimum picture interval for CIF4 resolution */
+	unsigned int CIF16;       /*!< Minimum picture interval for CIF16 resolution */
+	unsigned int VGA;         /*!< Minimum picture interval for VGA resolution */
+	unsigned int CUSTOM_XMAX; /*!< Custom resolution (Xmax) */
+	unsigned int CUSTOM_YMAX; /*!< Custom resolution (Ymax) */
+	unsigned int CUSTOM_MPI;  /*!< Custom resolution (MPI) */
+	unsigned int F;           /*!< F annex support */
+	unsigned int I;           /*!< I annex support */
+	unsigned int J;           /*!< J annex support */
+	unsigned int T;           /*!< T annex support */
+	unsigned int K;           /*!< K annex support */
+	unsigned int N;           /*!< N annex support */
+	unsigned int P_SUB1;      /*!< Reference picture resampling (sub mode 1) */
+	unsigned int P_SUB2;      /*!< Reference picture resampling (sub mode 2) */
+	unsigned int P_SUB3;      /*!< Reference picture resampling (sub mode 3) */
+	unsigned int P_SUB4;      /*!< Reference picture resampling (sub mode 4) */
+	unsigned int PAR_WIDTH;   /*!< Pixel aspect ratio (width) */
+	unsigned int PAR_HEIGHT;  /*!< Pixel aspect ratio (height) */
+	unsigned int BPP;         /*!< Bits per picture maximum */
+	unsigned int HRD;         /*!< Hypothetical reference decoder status */
 };
 
-static int h263_format_attr_get_joint(const struct ast_format_attr *fattr1, const struct ast_format_attr *fattr2, struct ast_format_attr *result)
+static void h263_destroy(struct ast_format *format)
 {
-	int i;
+	struct h263_attr *attr = ast_format_get_attribute_data(format);
 
-	/* These are all receiver options so we just copy over what they sent */
-	for (i = H263_ATTR_KEY_SQCIF; i < H263_ATTR_KEY_END; i++) {
-		result->format_attr[i] = fattr1->format_attr[i] ? fattr1->format_attr[i] : fattr2->format_attr[i];
+	ast_free(attr);
+}
+
+static int h263_clone(const struct ast_format *src, struct ast_format *dst)
+{
+	struct h263_attr *original = ast_format_get_attribute_data(src);
+	struct h263_attr *attr = ast_calloc(1, sizeof(*attr));
+
+	if (!attr) {
+		return -1;
+	}
+
+	if (original) {
+		*attr = *original;
 	}
 
+	ast_format_set_attribute_data(dst, attr);
+
 	return 0;
 }
 
-static int h263_format_attr_sdp_parse(struct ast_format_attr *format_attr, const char *attributes)
+static enum ast_format_cmp_res h263_cmp(const struct ast_format *format1, const struct ast_format *format2)
+{
+	struct h263_attr *attr1 = ast_format_get_attribute_data(format1);
+	struct h263_attr *attr2 = ast_format_get_attribute_data(format2);
+
+	if (!attr1 || !attr2 || (attr1 && attr2 && !memcmp(attr1, attr2, sizeof(*attr1)))) {
+		return AST_FORMAT_CMP_EQUAL;
+	}
+	return AST_FORMAT_CMP_NOT_EQUAL;
+}
+
+#define DETERMINE_JOINT(joint, attr1, attr2, field) (joint->field = (attr1 && attr1->field) ? attr1->field : (attr2 && attr2->field) ? attr2->field : 0)
+
+static struct ast_format *h263_getjoint(const struct ast_format *format1, const struct ast_format *format2)
+{
+	struct ast_format *cloned;
+	struct h263_attr *attr, *attr1, *attr2;
+
+	cloned = ast_format_clone(format1);
+	if (!cloned) {
+		return NULL;
+	}
+	attr = ast_format_get_attribute_data(cloned);
+
+	attr1 = ast_format_get_attribute_data(format1);
+	attr2 = ast_format_get_attribute_data(format2);
+
+	DETERMINE_JOINT(attr, attr1, attr2, SQCIF);
+	DETERMINE_JOINT(attr, attr1, attr2, QCIF);
+	DETERMINE_JOINT(attr, attr1, attr2, CIF);
+	DETERMINE_JOINT(attr, attr1, attr2, CIF4);
+	DETERMINE_JOINT(attr, attr1, attr2, CIF16);
+	DETERMINE_JOINT(attr, attr1, attr2, VGA);
+	DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_XMAX);
+	DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_YMAX);
+	DETERMINE_JOINT(attr, attr1, attr2, CUSTOM_MPI);
+	DETERMINE_JOINT(attr, attr1, attr2, F);
+	DETERMINE_JOINT(attr, attr1, attr2, I);
+	DETERMINE_JOINT(attr, attr1, attr2, J);
+	DETERMINE_JOINT(attr, attr1, attr2, T);
+	DETERMINE_JOINT(attr, attr1, attr2, K);
+	DETERMINE_JOINT(attr, attr1, attr2, N);
+	DETERMINE_JOINT(attr, attr1, attr2, P_SUB1);
+	DETERMINE_JOINT(attr, attr1, attr2, P_SUB2);
+	DETERMINE_JOINT(attr, attr1, attr2, P_SUB3);
+	DETERMINE_JOINT(attr, attr1, attr2, P_SUB4);
+	DETERMINE_JOINT(attr, attr1, attr2, PAR_WIDTH);
+	DETERMINE_JOINT(attr, attr1, attr2, PAR_HEIGHT);
+	DETERMINE_JOINT(attr, attr1, attr2, BPP);
+	DETERMINE_JOINT(attr, attr1, attr2, HRD);
+
+	return cloned;
+}
+
+static struct ast_format *h263_parse_sdp_fmtp(const struct ast_format *format, const char *attributes)
 {
 	char *attribs = ast_strdupa(attributes), *attrib;
+	struct ast_format *cloned;
+	struct h263_attr *attr;
+
+	cloned = ast_format_clone(format);
+	if (!cloned) {
+		return NULL;
+	}
+	attr = ast_format_get_attribute_data(cloned);
 
 	while ((attrib = strsep(&attribs, ";"))) {
 		unsigned int val, val2 = 0, val3 = 0, val4 = 0;
 
 		if (sscanf(attrib, "SQCIF=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_SQCIF] = val;
+			attr->SQCIF = val;
 		} else if (sscanf(attrib, "QCIF=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_QCIF] = val;
+			attr->QCIF = val;
 		} else if (sscanf(attrib, "CIF=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_CIF] = val;
+			attr->CIF = val;
 		} else if (sscanf(attrib, "CIF4=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_CIF4] = val;
+			attr->CIF4 = val;
 		} else if (sscanf(attrib, "CIF16=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_CIF16] = val;
+			attr->CIF16 = val;
 		} else if (sscanf(attrib, "VGA=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_VGA] = val;
+			attr->VGA = val;
 		} else if (sscanf(attrib, "CUSTOM=%30u,%30u,%30u", &val, &val2, &val3) == 3) {
-			format_attr->format_attr[H263_ATTR_KEY_CUSTOM_XMAX] = val;
-			format_attr->format_attr[H263_ATTR_KEY_CUSTOM_YMAX] = val2;
-			format_attr->format_attr[H263_ATTR_KEY_CUSTOM_MPI] = val3;
+			attr->CUSTOM_XMAX = val;
+			attr->CUSTOM_YMAX = val2;
+			attr->CUSTOM_MPI = val3;
 		} else if (sscanf(attrib, "F=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_F] = val;
+			attr->F = val;
 		} else if (sscanf(attrib, "I=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_I] = val;
+			attr->I = val;
 		} else if (sscanf(attrib, "J=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_J] = val;
+			attr->J = val;
 		} else if (sscanf(attrib, "T=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_T] = val;
+			attr->T = val;
 		} else if (sscanf(attrib, "K=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_K] = val;
+			attr->K = val;
 		} else if (sscanf(attrib, "N=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_N] = val;
+			attr->N = val;
 		} else if (sscanf(attrib, "PAR=%30u:%30u", &val, &val2) == 2) {
-			format_attr->format_attr[H263_ATTR_KEY_PAR_WIDTH] = val;
-			format_attr->format_attr[H263_ATTR_KEY_PAR_HEIGHT] = val2;
+			attr->PAR_WIDTH = val;
+			attr->PAR_HEIGHT = val2;
 		} else if (sscanf(attrib, "BPP=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_BPP] = val;
+			attr->BPP = val;
 		} else if (sscanf(attrib, "HRD=%30u", &val) == 1) {
-			format_attr->format_attr[H263_ATTR_KEY_HRD] = val;
+			attr->HRD = val;
 		} else if (sscanf(attrib, "P=%30u,%30u,%30u,%30u", &val, &val2, &val3, &val4) > 0) {
-			format_attr->format_attr[H263_ATTR_KEY_P_SUB1] = val;
-			format_attr->format_attr[H263_ATTR_KEY_P_SUB2] = val2;
-			format_attr->format_attr[H263_ATTR_KEY_P_SUB3] = val3;
-			format_attr->format_attr[H263_ATTR_KEY_P_SUB4] = val4;
+			attr->P_SUB1 = val;
+			attr->P_SUB2 = val2;
+			attr->P_SUB3 = val3;
+			attr->P_SUB4 = val4;
 		}
 	}
 
-	return 0;
+	return cloned;
 }
 
-/*! \brief Helper function which converts a key enum into a string value for SDP */
-static const char *h263_attr_key_to_str(enum h263_attr_keys key, const struct ast_format_attr *format_attr)
+static void h263_generate_sdp_fmtp(const struct ast_format *format, unsigned int payload, struct ast_str **str)
 {
-	switch (key) {
-	case H263_ATTR_KEY_SQCIF:
-		return format_attr->format_attr[key] ? "SQCIF" : NULL;
-	case H263_ATTR_KEY_QCIF:
-		return format_attr->format_attr[key] ? "QCIF" : NULL;
-	case H263_ATTR_KEY_CIF:
-		return format_attr->format_attr[key] ? "CIF" : NULL;
-	case H263_ATTR_KEY_CIF4:
-		return format_attr->format_attr[key] ? "CIF4" : NULL;
-	case H263_ATTR_KEY_CIF16:
-		return format_attr->format_attr[key] ? "CIF16" : NULL;
-	case H263_ATTR_KEY_VGA:
-		return format_attr->format_attr[key] ? "VGA" : NULL;
-	case H263_ATTR_KEY_F:
-		return "F";
-	case H263_ATTR_KEY_I:
-		return "I";
-	case H263_ATTR_KEY_J:
-		return "J";
-	case H263_ATTR_KEY_T:
-		return "T";
-	case H263_ATTR_KEY_K:
-		return "K";
-	case H263_ATTR_KEY_N:
-		return "N";
-	case H263_ATTR_KEY_BPP:
-		return "BPP";
-	case H263_ATTR_KEY_HRD:
-		return "HRD";
-	case H263_ATTR_KEY_CUSTOM_XMAX:
-	case H263_ATTR_KEY_CUSTOM_YMAX:
-	case H263_ATTR_KEY_CUSTOM_MPI:
-	case H263_ATTR_KEY_P_SUB1:
-	case H263_ATTR_KEY_P_SUB2:
-	case H263_ATTR_KEY_P_SUB3:
-	case H263_ATTR_KEY_P_SUB4:
-	case H263_ATTR_KEY_PAR_WIDTH:
-	case H263_ATTR_KEY_PAR_HEIGHT:
-	case H263_ATTR_KEY_END:
-	default:
-		return NULL;
+	struct h263_attr *attr = ast_format_get_attribute_data(format);
+
+	if (!attr) {
+		return;
 	}
 
-	return NULL;
-}
+	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",
+		payload, attr->SQCIF, attr->QCIF, attr->CIF, attr->CIF4, attr->CIF16, attr->VGA, attr->F, attr->I, attr->J,
+		attr->T, attr->K, attr->N, attr->BPP, attr->HRD);
 
-static void h263_format_attr_sdp_generate(const struct ast_format_attr *format_attr, unsigned int payload, struct ast_str **str)
-{
-	int i, added = 0;
-
-	for (i = H263_ATTR_KEY_SQCIF; i < H263_ATTR_KEY_END; i++) {
-		const char *name;
-
-		if (i == H263_ATTR_KEY_CUSTOM_XMAX) {
-			if (!format_attr->format_attr[H263_ATTR_KEY_CUSTOM_XMAX] || !format_attr->format_attr[H263_ATTR_KEY_CUSTOM_YMAX] ||
-			    !format_attr->format_attr[H263_ATTR_KEY_CUSTOM_MPI]) {
-				continue;
-			}
-
-			if (!added) {
-				ast_str_append(str, 0, "a=fmtp:%u CUSTOM=%u,%u,%u", payload, format_attr->format_attr[H263_ATTR_KEY_CUSTOM_XMAX],
-					       format_attr->format_attr[H263_ATTR_KEY_CUSTOM_YMAX], format_attr->format_attr[H263_ATTR_KEY_CUSTOM_MPI]);
-				added = 1;
-			} else {
-				ast_str_append(str, 0, ";CUSTOM=%u,%u,%u", format_attr->format_attr[H263_ATTR_KEY_CUSTOM_XMAX],
-					       format_attr->format_attr[H263_ATTR_KEY_CUSTOM_YMAX], format_attr->format_attr[H263_ATTR_KEY_CUSTOM_MPI]);
-			}
-		} else if (i == H263_ATTR_KEY_PAR_WIDTH) {
-			if (!format_attr->format_attr[H263_ATTR_KEY_PAR_WIDTH] || !format_attr->format_attr[H263_ATTR_KEY_PAR_HEIGHT]) {
-				continue;
-			}
-
-			if (!added) {
-				ast_str_append(str, 0, "a=fmtp:%u PAR=%u:%u", payload, format_attr->format_attr[H263_ATTR_KEY_PAR_WIDTH],
-					       format_attr->format_attr[H263_ATTR_KEY_PAR_HEIGHT]);
-				added = 1;
-			} else {
-				ast_str_append(str, 0, ";PAR=%u:%u", format_attr->format_attr[H263_ATTR_KEY_PAR_WIDTH],
-					       format_attr->format_attr[H263_ATTR_KEY_PAR_HEIGHT]);
-			}
-		} else if (i == H263_ATTR_KEY_P_SUB1) {
-			if (!format_attr->format_attr[H263_ATTR_KEY_P_SUB1]) {
-				continue;
-			}
-
-			if (!added) {
-				ast_str_append(str, 0, "a=fmtp:%u P=%u", payload, format_attr->format_attr[H263_ATTR_KEY_P_SUB1]);
-				added = 1;
-			} else {
-				ast_str_append(str, 0, ";P=%u", format_attr->format_attr[H263_ATTR_KEY_P_SUB1]);
-			}
-
-			if (format_attr->format_attr[H263_ATTR_KEY_P_SUB2]) {
-				ast_str_append(str, 0, ",%u", format_attr->format_attr[H263_ATTR_KEY_P_SUB2]);
-			}
-                        if (format_attr->format_attr[H263_ATTR_KEY_P_SUB3]) {
-                                ast_str_append(str, 0, ",%u", format_attr->format_attr[H263_ATTR_KEY_P_SUB3]);
-                        }
-                        if (format_attr->format_attr[H263_ATTR_KEY_P_SUB4]) {
-                                ast_str_append(str, 0, ",%u", format_attr->format_attr[H263_ATTR_KEY_P_SUB4]);
-                        }
-
-		} else if ((name = h263_attr_key_to_str(i, format_attr))) {
-			if (!added) {
-				ast_str_append(str, 0, "a=fmtp:%u %s=%u", payload, name, format_attr->format_attr[i]);
-				added = 1;
-			} else {
-				ast_str_append(str, 0, ";%s=%u", name, format_attr->format_attr[i]);
-			}
-		}
+	if (attr->CUSTOM_XMAX && attr->CUSTOM_YMAX && attr->CUSTOM_MPI) {
+		ast_str_append(str, 0, ";CUSTOM=%u,%u,%u", attr->CUSTOM_XMAX, attr->CUSTOM_YMAX, attr->CUSTOM_MPI);
 	}
 
-	if (added) {
-		ast_str_append(str, 0, "\r\n");
+	if (attr->PAR_WIDTH && attr->PAR_HEIGHT) {
+		ast_str_append(str, 0, ";PAR=%u:%u", attr->PAR_WIDTH, attr->PAR_HEIGHT);
 	}
 
+	if (attr->P_SUB1) {
+		ast_str_append(str, 0, ";P=%u", attr->P_SUB1);
+		if (attr->P_SUB2) {
+			ast_str_append(str, 0, ",%u", attr->P_SUB2);
+		}
+		if (attr->P_SUB3) {
+			ast_str_append(str, 0, ",%u", attr->P_SUB3);
+		}
+		if (attr->P_SUB4) {
+			ast_str_append(str, 0, ",%u", attr->P_SUB4);
+		}
+	}
+
+	ast_str_append(str, 0, "\r\n");
+
 	return;
 }
 
-static struct ast_format_attr_interface h263_format_attr_interface = {
-	.id = AST_FORMAT_H263,
-	.format_attr_get_joint = h263_format_attr_get_joint,
-	.format_attr_sdp_parse = h263_format_attr_sdp_parse,
-	.format_attr_sdp_generate = h263_format_attr_sdp_generate,
-};
-
-static struct ast_format_attr_interface h263p_format_attr_interface = {
-        .id = AST_FORMAT_H263_PLUS,
-	.format_attr_get_joint = h263_format_attr_get_joint,
-        .format_attr_sdp_parse = h263_format_attr_sdp_parse,
-        .format_attr_sdp_generate = h263_format_attr_sdp_generate,
+static struct ast_format_interface h263_interface = {
+	.format_destroy = h263_destroy,
+	.format_clone = h263_clone,
+	.format_cmp = h263_cmp,
+	.format_get_joint = h263_getjoint,
+	.format_parse_sdp_fmtp = h263_parse_sdp_fmtp,
+	.format_generate_sdp_fmtp = h263_generate_sdp_fmtp,
 };
 
 static int unload_module(void)
 {
-	ast_format_attr_unreg_interface(&h263_format_attr_interface);
-	ast_format_attr_unreg_interface(&h263p_format_attr_interface);
-
 	return 0;
 }
 
 static int load_module(void)
 {
-	if (ast_format_attr_reg_interface(&h263_format_attr_interface)) {
+	if (ast_format_interface_register("h263", &h263_interface)) {
 		return AST_MODULE_LOAD_DECLINE;
 	}
 
-	if (ast_format_attr_reg_interface(&h263p_format_attr_interface)) {
-		ast_format_attr_unreg_interface(&h263_format_attr_interface);
+	if (ast_format_interface_register("h263p", &h263_interface)) {
 		return AST_MODULE_LOAD_DECLINE;
 	}