Merge "res_odbc: fix missing SQL error diagnostic"
[asterisk/asterisk.git] / res / res_format_attr_h263.c
index 2ca39a9..b49f1d6 100644 (file)
 
 #include "asterisk.h"
 
-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)
+{
+       struct h263_attr *attr = ast_format_get_attribute_data(format);
+
+       ast_free(attr);
+}
+
+static int h263_clone(const struct ast_format *src, struct ast_format *dst)
 {
-       int i;
+       struct h263_attr *original = ast_format_get_attribute_data(src);
+       struct h263_attr *attr = ast_calloc(1, sizeof(*attr));
 
-       /* 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];
+       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;
 
+               attrib = ast_strip(attrib);
+
                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:%d 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:%d 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:%d 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:%d %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;
        }
 
        return AST_MODULE_LOAD_SUCCESS;
 }
 
-AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "H.263 Format Attribute Module",
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "H.263 Format Attribute Module",
+       .support_level = AST_MODULE_SUPPORT_CORE,
        .load = load_module,
        .unload = unload_module,
-       .load_pri = AST_MODPRI_DEFAULT,
 );