* @fieldname: the name of the field
*
* Finds the field with the given name, and returns the type of the
- * value it contains. If the field is not found, G_TYPE_NONE is
+ * value it contains. If the field is not found, G_TYPE_INVALID is
* returned.
*
* Returns: the #GValue of the field
{
GstStructureField *field;
- g_return_val_if_fail(structure != NULL, G_TYPE_NONE);
- g_return_val_if_fail(fieldname != NULL, G_TYPE_NONE);
+ g_return_val_if_fail(structure != NULL, G_TYPE_INVALID);
+ g_return_val_if_fail(fieldname != NULL, G_TYPE_INVALID);
field = gst_structure_get_field(structure, fieldname);
- if(field == NULL) return G_TYPE_NONE;
+ if(field == NULL) return G_TYPE_INVALID;
return G_VALUE_TYPE(&field->value);
}
return g_value_get_string(&field->value);
}
+typedef struct _GstStructureAbbreviation {
+ char *type_name;
+ GType type;
+} GstStructureAbbreviation;
+
+static GstStructureAbbreviation _gst_structure_abbrs[] = {
+ { "int", G_TYPE_INT },
+ { "i", G_TYPE_INT },
+ { "float", G_TYPE_FLOAT },
+ { "f", G_TYPE_FLOAT },
+ { "double", G_TYPE_DOUBLE },
+ { "d", G_TYPE_DOUBLE },
+//{ "fourcc", GST_TYPE_FOURCC },
+ { "boolean", G_TYPE_BOOLEAN },
+ { "bool", G_TYPE_BOOLEAN },
+ { "b", G_TYPE_BOOLEAN },
+ { "string", G_TYPE_STRING },
+ { "str", G_TYPE_STRING },
+ { "s", G_TYPE_STRING }
+};
+
+static GType _gst_structure_from_abbr(const char *type_name)
+{
+ int i;
+
+ g_return_val_if_fail(type_name != NULL, G_TYPE_INVALID);
+
+ for(i=0;i<G_N_ELEMENTS(_gst_structure_abbrs);i++){
+ if(strcmp(type_name,_gst_structure_abbrs[i].type_name)==0){
+ return _gst_structure_abbrs[i].type;
+ }
+ }
+
+ /* FIXME shouldn't be a special case */
+ if (strcmp (type_name,"fourcc") == 0 || strcmp (type_name, "4") == 0) {
+ return GST_TYPE_FOURCC;
+ }
+
+ return g_type_from_name (type_name);
+}
+
+static const char *_gst_structure_to_abbr(GType type)
+{
+ int i;
+
+ g_return_val_if_fail(type != G_TYPE_INVALID, NULL);
+
+ for(i=0;i<G_N_ELEMENTS(_gst_structure_abbrs);i++){
+ if(type == _gst_structure_abbrs[i].type){
+ return _gst_structure_abbrs[i].type_name;
+ }
+ }
+
+ /* FIXME shouldn't be a special case */
+ if (type == GST_TYPE_FOURCC) {
+ return "fourcc";
+ }
+
+ return g_type_name(type);
+}
+
/**
* gst_structure_to_string:
* @structure: a #GstStructure
g_string_append_printf(s, "\"%s\"", g_quark_to_string(structure->name));
for(i=0;i<structure->fields->len;i++){
GValue s_val = { 0 };
+ GType type;
field = GST_STRUCTURE_FIELD(structure, i);
g_value_init(&s_val, G_TYPE_STRING);
+ g_value_transform (&field->value, &s_val);
- g_value_transform(&field->value, &s_val);
- g_string_append_printf(s, ", %s:%s", g_quark_to_string(field->name),
- g_value_get_string(&s_val));
- g_value_unset(&s_val);
+ type = G_VALUE_TYPE (&field->value);
+
+ if (type == GST_TYPE_LIST) {
+ GPtrArray *ptr_array = g_value_peek_pointer (&field->value);
+ if (ptr_array->len > 0){
+ GValue *value = g_ptr_array_index (ptr_array, 0);
+
+ type = G_VALUE_TYPE (value);
+ } else {
+ type = G_TYPE_INT;
+ }
+ } else if (G_VALUE_TYPE(&field->value) == GST_TYPE_INT_RANGE) {
+ type = G_TYPE_INT;
+ } else if (G_VALUE_TYPE(&field->value) == GST_TYPE_DOUBLE_RANGE) {
+ type = G_TYPE_DOUBLE;
+ }
+ g_string_append_printf(s, ", %s:%s=%s", g_quark_to_string(field->name),
+ _gst_structure_to_abbr(type), g_value_get_string(&s_val));
+ g_value_unset (&s_val);
}
return g_string_free(s, FALSE);
}
+/*
+ * r will still point to the string. if end == next, the string will not be
+ * null-terminated. In all other cases it will be.
+ * end = pointer to char behind end of string, next = pointer to start of
+ * unread data.
+ * THIS FUNCTION MODIFIES THE STRING AND DETECTS INSIDE A NONTERMINATED STRING
+ */
+static gboolean
+_gst_structure_parse_string (gchar *r, gchar **end, gchar **next)
+{
+ gchar *w;
+ gchar c = '\0';
+
+ w = r;
+ if (*r == '\'' || *r == '\"') {
+ c = *r;
+ r++;
+ }
+
+ for (;;r++) {
+ if (*r == '\0') {
+ if (c) {
+ goto error;
+ } else {
+ goto found;
+ }
+ }
+
+ if (*r == '\\') {
+ r++;
+ if (*r == '\0')
+ goto error;
+ *w++ = *r;
+ continue;
+ }
+
+ if (*r == c) {
+ r++;
+ if (*r == '\0')
+ goto found;
+ break;
+ }
+
+ if (!c) {
+ if (g_ascii_isspace (*r))
+ break;
+ /* this needs to be escaped */
+ if (*r == ',' || *r == ')' || *r == ']' || *r == ':' ||
+ *r == ';' || *r == '(' || *r == '[')
+ break;
+ }
+ *w++ = *r;
+ }
+
+found:
+ while (g_ascii_isspace (*r)) r++;
+ if (w != r)
+ *w++ = '\0';
+ *end = w;
+ *next = r;
+ return TRUE;
+
+error:
+ return FALSE;
+}
+
+static gboolean
+_gst_structure_parse_value (gchar *s, gchar **after, GType type,
+ GValue *value)
+{
+ gboolean ret = FALSE;
+ gchar *val;
+ gchar *end;
+
+ if (type == G_TYPE_INVALID) return FALSE;
+
+ while (g_ascii_isspace (*s)) s++;
+
+ g_value_init(value, type);
+
+ val = s;
+ switch (type) {
+ case G_TYPE_INT:
+ {
+ int x;
+ x = strtol (val, &s, 0);
+ if (val != s) {
+ g_value_set_int (value, x);
+ ret = TRUE;
+ }
+ }
+ break;
+ case G_TYPE_FLOAT:
+ {
+ double x;
+ x = g_ascii_strtod (val, &s);
+ if (val != s) {
+ g_value_set_float (value, x);
+ ret = TRUE;
+ }
+ }
+ break;
+ case G_TYPE_DOUBLE:
+ {
+ double x;
+ x = g_ascii_strtod (val, &s);
+ if (val != s) {
+ g_value_set_double (value, x);
+ ret = TRUE;
+ }
+ }
+ break;
+ case G_TYPE_BOOLEAN:
+ {
+ int len;
+
+ ret = _gst_structure_parse_string (val, &end, &s);
+ len = end - val;
+ if (ret && len > 0) {
+ if (g_ascii_strncasecmp (val, "true", len) == 0 ||
+ g_ascii_strncasecmp (val, "yes", len) == 0 ||
+ g_ascii_strncasecmp (val, "t", len) == 0 ||
+ strncmp (val, "1", len)) {
+ g_value_set_boolean (value, TRUE);
+ } else if (g_ascii_strncasecmp (val, "false", len) == 0 ||
+ g_ascii_strncasecmp (val, "no", len) == 0 ||
+ g_ascii_strncasecmp (val, "f", len) == 0 ||
+ strncmp (val, "0", len)) {
+ g_value_set_boolean (value, FALSE);
+ } else {
+ ret = FALSE;
+ }
+ }
+ }
+ break;
+ case G_TYPE_STRING:
+ {
+ ret = _gst_structure_parse_string (val, &end, &s);
+ if (ret) {
+ g_value_set_string_take_ownership (value,
+ g_strndup(val, end - val));
+ ret = TRUE;
+ }
+ }
+ break;
+ default:
+ /* FIXME: make more general */
+ if (type == GST_TYPE_FOURCC) {
+ guint32 fourcc = 0;
+ if (g_ascii_isdigit (*s)) {
+ fourcc = strtoul (val, &s, 0);
+ if (val != s) {
+ ret = TRUE;
+ }
+ } else {
+ ret = _gst_structure_parse_string (val, &end, &s);
+g_print("end - val = %d\n", end - val);
+ if (end - val >= 4) {
+ fourcc = GST_MAKE_FOURCC(val[0], val[1], val[2], val[3]);
+ ret = TRUE;
+ }
+ }
+ gst_value_set_fourcc (value, fourcc);
+ } else {
+ g_critical("type %s not handled", g_type_name(type));
+ }
+ break;
+ }
+
+ *after = s;
+
+ return ret;
+}
+
+static gboolean
+_gst_structure_parse_range (gchar *s, gchar **after, GType type,
+ GValue *value)
+{
+ GValue value1 = { 0 };
+ GValue value2 = { 0 };
+ GType range_type;
+ gboolean ret;
+
+ if (type == G_TYPE_DOUBLE) {
+ range_type = GST_TYPE_DOUBLE_RANGE;
+ } else if (type == G_TYPE_INT) {
+ range_type = GST_TYPE_INT_RANGE;
+ } else {
+ return FALSE;
+ }
+
+g_print("%d \"%s\"\n", __LINE__, s);
+ if (*s != '[') return FALSE;
+ s++;
+
+g_print("%d \"%s\"\n", __LINE__, s);
+ ret = _gst_structure_parse_value(s, &s, type, &value1);
+ if (ret == FALSE) return FALSE;
+
+ while (g_ascii_isspace (*s)) s++;
+
+g_print("%d \"%s\"\n", __LINE__, s);
+ if (*s != ',') return FALSE;
+ s++;
+
+ while (g_ascii_isspace (*s)) s++;
+
+g_print("%d \"%s\"\n", __LINE__, s);
+ ret = _gst_structure_parse_value(s, &s, type, &value2);
+ if (ret == FALSE) return FALSE;
+
+ while (g_ascii_isspace (*s)) s++;
+
+g_print("%d \"%s\"\n", __LINE__, s);
+ if (*s != ']') return FALSE;
+ s++;
+
+ g_value_init(value, range_type);
+ if (range_type == GST_TYPE_DOUBLE_RANGE) {
+ gst_value_set_double_range(value, g_value_get_double(&value1),
+ g_value_get_double(&value2));
+ } else {
+ gst_value_set_int_range(value, g_value_get_int(&value1),
+ g_value_get_int(&value2));
+ }
+
+ *after = s;
+ return TRUE;
+}
+
+static gboolean
+_gst_structure_parse_list (gchar *s, gchar **after, GType type, GValue *value)
+{
+ GValue list_value = { 0 };
+ gboolean ret;
+
+ g_value_init(value, GST_TYPE_LIST);
+
+ if (*s != '(') return FALSE;
+ s++;
+
+ while (g_ascii_isspace (*s)) s++;
+ if (*s == ')') {
+ s++;
+ *after = s;
+ return TRUE;
+ }
+
+ ret = _gst_structure_parse_value(s, &s, type, &list_value);
+ if (ret == FALSE) return FALSE;
+
+ while (g_ascii_isspace (*s)) s++;
+
+ while (*s != ')') {
+ if (*s != ',') return FALSE;
+ s++;
+
+ while (g_ascii_isspace (*s)) s++;
+
+ memset (&list_value, 0, sizeof (list_value));
+ ret = _gst_structure_parse_value(s, &s, type, &list_value);
+ if (ret == FALSE) return FALSE;
+
+ while (g_ascii_isspace (*s)) s++;
+ }
+
+ s++;
+
+ *after = s;
+ return TRUE;
+}
+
+static gboolean
+_gst_structure_parse_field (gchar *str, gchar **after, GstStructureField *field)
+{
+ /* NAME[:TYPE]=VALUE */
+ gchar *name;
+ gchar *type_name;
+ gchar *s, *del;
+ gboolean have_type = FALSE;
+ GType type = G_TYPE_INVALID;
+ int ret;
+
+g_print("parsing: \"%s\"\n", str);
+ name = s = str;
+ while (g_ascii_isalnum (*s) || *s == '_' || *s == '-') s++;
+ del = s;
+ while (g_ascii_isspace (*s)) s++;
+ if (!(*s == '=' || *s == ':')) return FALSE;
+ if (*s == ':') have_type = TRUE;
+ s++;
+ while (g_ascii_isspace (*s)) s++;
+ *del = '\0';
+
+ field->name = g_quark_from_string (name);
+
+ if (have_type) {
+ while (g_ascii_isspace (*s)) s++;
+ type_name = s;
+ while (g_ascii_isalnum (*s) || *s == '_' || *s == '-') s++;
+ del = s;
+ while (g_ascii_isspace (*s)) s++;
+ if (*s != '=') return FALSE;
+ s++;
+ while (g_ascii_isspace (*s)) s++;
+ *del = '\0';
+
+g_print("type name is \"%s\"\n",type_name);
+ type = _gst_structure_from_abbr(type_name);
+g_print("type n is \"%s\"\n",g_type_name(type));
+
+ if (type == G_TYPE_INVALID) return FALSE;
+
+ } else {
+ if (g_ascii_isdigit (*s) ||
+ ((*s == '-' || *s == '+') && g_ascii_isdigit (s[1]))) {
+ char *t = s;
+ while (g_ascii_isdigit (*t)) t++;
+ if (*t == '.'){
+ type = G_TYPE_DOUBLE;
+ } else {
+ type = G_TYPE_INT;
+ }
+ } else if (g_ascii_isalpha (*s) || *s == '"' || *s == '\'') {
+ type = G_TYPE_STRING;
+ }
+ }
+
+ if (*s == '[') {
+ ret = _gst_structure_parse_range (s, &s, type, &field->value);
+ } else if (*s == '(') {
+ ret = _gst_structure_parse_list (s, &s, type, &field->value);
+ } else {
+ ret = _gst_structure_parse_value(s, &s, type, &field->value);
+ }
+
+ *after = s;
+
+ return ret;
+}
+
/**
* gst_structure_from_string:
* @structure: a #GstStructure
* Returns: a new #GstStructure
*/
GstStructure *
-gst_structure_from_string (const gchar *string)
+gst_structure_from_string (const gchar *string, gchar **end)
{
- /* FIXME */
+ char *name;
+ char *copy;
+ char *w;
+ char *r;
+ char save;
+ GstStructure *structure;
+ GstStructureField field = { 0 };
+ gboolean res;
g_return_val_if_fail(string != NULL, NULL);
- g_assert_not_reached();
+ copy = g_strdup(string);
+ r = copy;
- return NULL;
+ name = r;
+ res = _gst_structure_parse_string (r, &w, &r);
+ if (!res) return NULL;
+
+ while (g_ascii_isspace(*r)) r++;
+ if(*r != 0 && *r != ';' && *r != ',') return NULL;
+
+ save = *w;
+ *w = 0;
+ structure = gst_structure_empty_new(name);
+ *w = save;
+
+ while (*r && (*r != ';')){
+ if(*r != ',') {
+ return NULL;
+ }
+ r++;
+ while (*r && g_ascii_isspace(*r)) r++;
+
+ memset(&field,0,sizeof(field));
+ res = _gst_structure_parse_field (r, &r, &field);
+g_print("returned %d \"%s\"\n", res, r);
+ if (!res) {
+ gst_structure_free (structure);
+ return NULL;
+ }
+ gst_structure_set_field(structure, &field);
+ while (*r && g_ascii_isspace(*r)) r++;
+ }
+
+ if (end) *end = (char *)string + (r - copy);
+ return structure;
}
static void
GstStructure *gst_structure_copy(GstStructure *structure);
void gst_structure_free(GstStructure *structure);
-const gchar *gst_structure_get_name(GstStructure *structure);
+G_CONST_RETURN gchar *gst_structure_get_name(GstStructure *structure);
void gst_structure_set_name(GstStructure *structure, const gchar *name);
void gst_structure_set_field_copy (GstStructure *structure,
const GstStructureField *field);
void gst_structure_set(GstStructure *structure, const gchar *field, ...);
void gst_structure_set_valist(GstStructure *structure, const gchar *field,
va_list varargs);
-const GValue *gst_structure_get_value(const GstStructure *structure, const gchar *field);
+G_CONST_RETURN GValue *gst_structure_get_value(const GstStructure *structure,
+ const gchar *field);
GstStructureField *gst_structure_get_field(const GstStructure *structure,
const gchar *fieldname);
GstStructureField *gst_structure_id_get_field(const GstStructure *structure,
guint32 *value);
gboolean gst_structure_get_double(const GstStructure *structure, const gchar *field,
gdouble *value);
-const gchar *gst_structure_get_string(const GstStructure *structure,
+G_CONST_RETURN gchar *gst_structure_get_string(const GstStructure *structure,
const gchar *field);
gchar * gst_structure_to_string(const GstStructure *structure);
-GstStructure * gst_structure_from_string (const gchar *string);
+GstStructure * gst_structure_from_string (const gchar *string, gchar **end);
G_END_DECLS
g_return_if_fail (name != NULL);
g_return_if_fail (nick != NULL);
g_return_if_fail (blurb != NULL);
- g_return_if_fail (type != 0 && type != GST_VALUE_TYPE_LIST);
+ g_return_if_fail (type != 0 && type != GST_TYPE_LIST);
key = g_quark_from_string (name);
info = gst_tag_lookup (key);
value = gst_structure_get_value ((GstStructure *) list, tag);
if (value == NULL)
return 0;
- if (G_VALUE_TYPE (value) != GST_VALUE_TYPE_LIST)
+ if (G_VALUE_TYPE (value) != GST_TYPE_LIST)
return 1;
return gst_value_list_get_size (value);
src = gst_structure_get_value ((GstStructure *) list, tag);
if (!src) return FALSE;
- if (G_VALUE_TYPE (src) == GST_VALUE_TYPE_LIST) {
+ if (G_VALUE_TYPE (src) == GST_TYPE_LIST) {
GstTagInfo *info = gst_tag_lookup (g_quark_from_string (tag));
/* must be there or lists aren't allowed */
g_assert (info->merge_func);
g_return_if_fail (name != NULL);
g_return_if_fail (nick != NULL);
g_return_if_fail (blurb != NULL);
- g_return_if_fail (type != 0 && type != GST_VALUE_TYPE_LIST);
+ g_return_if_fail (type != 0 && type != GST_TYPE_LIST);
key = g_quark_from_string (name);
info = gst_tag_lookup (key);
value = gst_structure_get_value ((GstStructure *) list, tag);
if (value == NULL)
return 0;
- if (G_VALUE_TYPE (value) != GST_VALUE_TYPE_LIST)
+ if (G_VALUE_TYPE (value) != GST_TYPE_LIST)
return 1;
return gst_value_list_get_size (value);
src = gst_structure_get_value ((GstStructure *) list, tag);
if (!src) return FALSE;
- if (G_VALUE_TYPE (src) == GST_VALUE_TYPE_LIST) {
+ if (G_VALUE_TYPE (src) == GST_TYPE_LIST) {
GstTagInfo *info = gst_tag_lookup (g_quark_from_string (tag));
/* must be there or lists aren't allowed */
g_assert (info->merge_func);
GType gst_type_fourcc;
GType gst_type_int_range;
GType gst_type_double_range;
-GType gst_value_type_list;
+GType gst_type_list;
GArray *gst_value_compare_funcs;
GArray *gst_value_union_funcs;
return (const GValue *) &g_array_index ((GArray *) value->data[0].v_pointer, GValue, index);
}
+/* special case function for any union */
+static gboolean
+gst_value_union_lists (GValue *dest, const GValue *value1, const GValue *value2)
+{
+ guint i, value1_length, value2_length;
+ GArray *array;
+
+ value1_length = (GST_VALUE_HOLDS_LIST (value1) ? gst_value_list_get_size (value1) : 1);
+ value2_length = (GST_VALUE_HOLDS_LIST (value2) ? gst_value_list_get_size (value2) : 1);
+ g_value_init (dest, GST_TYPE_LIST);
+ array = (GArray *) dest->data[0].v_pointer;
+ g_array_set_size (array, value1_length + value2_length);
+
+ if (GST_VALUE_HOLDS_LIST (value1)) {
+ for (i = 0; i < value1_length; i++) {
+ g_value_init (&g_array_index(array, GValue, i), G_VALUE_TYPE (gst_value_list_get_value (value1, i)));
+ g_value_copy (gst_value_list_get_value (value1, i), &g_array_index(array, GValue, i));
+ }
+ } else {
+ g_value_init (&g_array_index(array, GValue, 0), G_VALUE_TYPE (value1));
+ g_value_copy (value1, &g_array_index(array, GValue, 0));
+ }
+
+ if (GST_VALUE_HOLDS_LIST (value2)) {
+ for (i = 0; i < value2_length; i++) {
+ g_value_init (&g_array_index(array, GValue, i + value1_length), G_VALUE_TYPE (gst_value_list_get_value (value2, i)));
+ g_value_copy (gst_value_list_get_value (value2, i), &g_array_index(array, GValue, i + value1_length));
+ }
+ } else {
+ g_value_init (&g_array_index(array, GValue, value1_length), G_VALUE_TYPE (value2));
+ g_value_copy (value2, &g_array_index(array, GValue, value1_length));
+ }
+
+ return TRUE;
+}
+
/**
* gst_value_list_concat:
* @dest: an uninitialized #GValue to take the result
* @value2: second value to put into the union
*
* Concatenates copies of value1 and value2 into a list. dest will be
- * initialized to the type GST_VALUE_TYPE_LIST.
+ * initialized to the type GST_TYPE_LIST.
*/
void
gst_value_list_concat (GValue *dest, const GValue *value1, const GValue *value2)
value1_length = (GST_VALUE_HOLDS_LIST (value1) ? gst_value_list_get_size (value1) : 1);
value2_length = (GST_VALUE_HOLDS_LIST (value2) ? gst_value_list_get_size (value2) : 1);
- g_value_init (dest, GST_VALUE_TYPE_LIST);
+ g_value_init (dest, GST_TYPE_LIST);
array = (GArray *) dest->data[0].v_pointer;
g_array_set_size (array, value1_length + value2_length);
return value->data[1].v_double;
}
+/* GstCaps */
+
+#if 0
+void
+gst_value_set_caps (GValue *value, const GstCaps2 *caps)
+{
+ g_return_if_fail (GST_VALUE_HOLDS_CAPS (value));
+
+ value->data[0].v_pointer = gst_caps2_copy (caps);
+}
+
+const GstCaps2 *
+gst_value_get_caps (const GValue *value)
+{
+ g_return_val_if_fail (GST_VALUE_HOLDS_CAPS (value), 0);
+
+ return value->data[0].v_pointer;
+}
+#endif
+
/* fourcc */
static void
gst_value_transform_fourcc_string (const GValue *src_value,
GValue *dest_value)
{
- dest_value->data[0].v_pointer = g_strdup_printf(GST_FOURCC_FORMAT,
- GST_FOURCC_ARGS(src_value->data[0].v_long));
+ guint32 fourcc = src_value->data[0].v_long;
+
+ if (g_ascii_isprint ((fourcc>>0) & 0xff) &&
+ g_ascii_isprint ((fourcc>>8) & 0xff) &&
+ g_ascii_isprint ((fourcc>>16) & 0xff) &&
+ g_ascii_isprint ((fourcc>>24) & 0xff)){
+ dest_value->data[0].v_pointer = g_strdup_printf(
+ "\"" GST_FOURCC_FORMAT "\"", GST_FOURCC_ARGS(fourcc));
+ } else {
+ dest_value->data[0].v_pointer = g_strdup_printf("0x%08x", fourcc);
+ }
}
static void
(int)src_value->data[0].v_long, (int)src_value->data[1].v_long);
}
+static void
+gst_value_transform_double_range_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ dest_value->data[0].v_pointer = g_strdup_printf("[%g,%g]",
+ src_value->data[0].v_double, src_value->data[1].v_double);
+}
+
+static void
+gst_value_transform_list_string (const GValue *src_value,
+ GValue *dest_value)
+{
+ GValue *list_value;
+ GArray *array;
+ GString *s;
+ int i;
+ char *list_s;
+
+ array = src_value->data[0].v_pointer;
+
+ s = g_string_new("(");
+ for(i=0;i<array->len;i++){
+ list_value = &g_array_index(array, GValue, i);
+
+ if (i != 0) {
+ g_string_append (s, ", ");
+ }
+ list_s = g_strdup_value_contents (list_value);
+ g_string_append (s, list_s);
+ g_free (list_s);
+ }
+ g_string_append (s, ")");
+
+ dest_value->data[0].v_pointer = g_string_free (s, FALSE);
+}
+
/* comparison functions */
static int
}
static int
+gst_value_compare_float (const GValue *value1, const GValue *value2)
+{
+ if (value1->data[0].v_float > value2->data[0].v_float)
+ return GST_VALUE_GREATER_THAN;
+ if (value1->data[0].v_float < value2->data[0].v_float)
+ return GST_VALUE_LESS_THAN;
+ if (value1->data[0].v_float == value2->data[0].v_float)
+ return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static int
gst_value_compare_string (const GValue *value1, const GValue *value2)
{
int x = strcmp(value1->data[0].v_pointer, value2->data[0].v_pointer);
static int
gst_value_compare_fourcc (const GValue *value1, const GValue *value2)
{
+g_print("comparing fourccs\n");
if (value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
return GST_VALUE_UNORDERED;
}
+static int
+gst_value_compare_int_range (const GValue *value1, const GValue *value2)
+{
+ if (value2->data[0].v_int == value1->data[0].v_int &&
+ value2->data[0].v_int == value1->data[0].v_int) return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static int
+gst_value_compare_double_range (const GValue *value1, const GValue *value2)
+{
+ if (value2->data[0].v_double == value1->data[0].v_double &&
+ value2->data[0].v_double == value1->data[0].v_double)
+ return GST_VALUE_EQUAL;
+ return GST_VALUE_UNORDERED;
+}
+
+static int
+gst_value_compare_list (const GValue *value1, const GValue *value2)
+{
+ int i,j;
+ GArray *array1 = value1->data[0].v_pointer;
+ GArray *array2 = value2->data[0].v_pointer;
+ GValue *v1;
+ GValue *v2;
+
+ if (array1->len != array2->len) return GST_VALUE_UNORDERED;
+
+ for(i=0;i<array1->len;i++){
+ v1 = &g_array_index (array1, GValue, i);
+ for(j=0;j<array1->len;j++){
+ v2 = &g_array_index (array2, GValue, j);
+ if (gst_value_compare(v1, v2) == GST_VALUE_EQUAL) break;
+ }
+ if (j==array1->len) {
+ return GST_VALUE_UNORDERED;
+ }
+ }
+
+ return GST_VALUE_EQUAL;
+}
+
gboolean
gst_value_can_compare (const GValue *value1, const GValue *value2)
{
GstValueCompareInfo *compare_info;
int i;
- g_return_val_if_fail(G_VALUE_TYPE(value1) == G_VALUE_TYPE(value2), 0);
+ if (G_VALUE_TYPE(value1) != G_VALUE_TYPE(value2)) return GST_VALUE_UNORDERED;
+
for(i=0;i<gst_value_compare_funcs->len;i++){
compare_info = &g_array_index(gst_value_compare_funcs,
GstValueCompareInfo, i);
return compare_info->func(value1, value2);
}
- g_return_val_if_fail(0 /* type not found */, GST_VALUE_UNORDERED);
+ g_critical("unable to compare values of type %s\n",
+ g_type_name (G_VALUE_TYPE (value1)));
return GST_VALUE_UNORDERED;
}
return union_info->func(dest, value1, value2);
}
}
- gst_value_list_concat (dest, value1, value2);
- return TRUE;
+ return gst_value_union_lists (dest, value1, value2);
}
void
{
GstValueIntersectInfo *intersect_info;
int i;
+ int ret = FALSE;
+g_print("intersecting %s=%s and %s=%s\n",
+ g_type_name(G_VALUE_TYPE(value1)), g_strdup_value_contents(value1),
+ g_type_name(G_VALUE_TYPE(value2)), g_strdup_value_contents(value2));
for(i=0;i<gst_value_intersect_funcs->len;i++){
intersect_info = &g_array_index(gst_value_intersect_funcs,
GstValueIntersectInfo, i);
if(intersect_info->type1 == G_VALUE_TYPE(value1) &&
intersect_info->type2 == G_VALUE_TYPE(value2)) {
- return intersect_info->func(dest, value1, value2);
+ ret = intersect_info->func(dest, value1, value2);
+g_print("result is %d %s\n", ret, ret?g_strdup_value_contents(dest):"none1");
+ return ret;
}
}
if(gst_value_compare(value1, value2) == GST_VALUE_EQUAL){
g_value_init(dest, G_VALUE_TYPE(value1));
g_value_copy(value1, dest);
- return TRUE;
+ ret = TRUE;
+g_print("result is %d %s\n", ret, ret?g_strdup_value_contents(dest):"none2");
}
- return FALSE;
+g_print("result is %d %s\n", ret, ret?g_strdup_value_contents(dest):"none3");
+ return ret;
}
void
gst_value_lcopy_list
};
info.value_table = &value_table;
- gst_value_type_list = g_type_register_static (G_TYPE_BOXED, "GstValueList", &info, 0);
+ gst_type_list = g_type_register_static (G_TYPE_BOXED, "GstValueList", &info, 0);
}
g_value_register_transform_func (GST_TYPE_FOURCC, G_TYPE_STRING,
gst_value_transform_fourcc_string);
g_value_register_transform_func (GST_TYPE_INT_RANGE, G_TYPE_STRING,
gst_value_transform_int_range_string);
+ g_value_register_transform_func (GST_TYPE_DOUBLE_RANGE, G_TYPE_STRING,
+ gst_value_transform_double_range_string);
+ g_value_register_transform_func (GST_TYPE_LIST, G_TYPE_STRING,
+ gst_value_transform_list_string);
gst_value_compare_funcs = g_array_new(FALSE, FALSE,
sizeof(GstValueCompareInfo));
gst_value_register_compare_func (G_TYPE_INT, gst_value_compare_int);
+ gst_value_register_compare_func (G_TYPE_FLOAT, gst_value_compare_float);
gst_value_register_compare_func (G_TYPE_DOUBLE, gst_value_compare_double);
gst_value_register_compare_func (G_TYPE_STRING, gst_value_compare_string);
gst_value_register_compare_func (GST_TYPE_FOURCC, gst_value_compare_fourcc);
+ gst_value_register_compare_func (GST_TYPE_INT_RANGE, gst_value_compare_int_range);
+ gst_value_register_compare_func (GST_TYPE_DOUBLE_RANGE, gst_value_compare_double_range);
+ gst_value_register_compare_func (GST_TYPE_LIST, gst_value_compare_list);
gst_value_union_funcs = g_array_new(FALSE, FALSE,
sizeof(GstValueUnionInfo));
#define __GST_VALUE_H__
#include <gst/gstconfig.h>
+#include <gst/gstcaps2.h>
G_BEGIN_DECLS
((gchar) (((fourcc)>>16)&0xff)), \
((gchar) (((fourcc)>>24)&0xff))
+#define GST_VALUE_HOLDS_FOURCC(x) (G_VALUE_HOLDS(x, gst_type_fourcc))
+#define GST_VALUE_HOLDS_INT_RANGE(x) (G_VALUE_HOLDS(x, gst_type_int_range))
+#define GST_VALUE_HOLDS_DOUBLE_RANGE(x) (G_VALUE_HOLDS(x, gst_type_double_range))
+#define GST_VALUE_HOLDS_LIST(x) (G_VALUE_HOLDS(x, gst_type_list))
+#define GST_VALUE_HOLDS_CAPS(x) TRUE /* FIXME */
+
#define GST_TYPE_FOURCC gst_type_fourcc
#define GST_TYPE_INT_RANGE gst_type_int_range
#define GST_TYPE_DOUBLE_RANGE gst_type_double_range
-#define GST_VALUE_TYPE_LIST gst_value_type_list
-
-#define GST_VALUE_HOLDS_FOURCC(x) (G_VALUE_TYPE(x) == gst_type_fourcc)
-#define GST_VALUE_HOLDS_INT_RANGE(x) (G_VALUE_TYPE(x) == gst_type_int_range)
-#define GST_VALUE_HOLDS_DOUBLE_RANGE(x) (G_VALUE_TYPE(x) == gst_type_double_range)
-#define GST_VALUE_HOLDS_LIST(x) (G_VALUE_TYPE(x) == GST_VALUE_TYPE_LIST)
-#define GST_VALUE_HOLDS_CAPS(x) TRUE /* FIXME */
+#define GST_TYPE_LIST gst_type_list
#define GST_VALUE_LESS_THAN (-1)
#define GST_VALUE_EQUAL 0
extern GType gst_type_fourcc;
extern GType gst_type_int_range;
extern GType gst_type_double_range;
-extern GType gst_value_type_list;
+extern GType gst_type_list;
void gst_value_set_fourcc (GValue *value, guint32 fourcc);
guint32 gst_value_get_fourcc (const GValue *value);
double gst_value_get_double_range_min (const GValue *value);
double gst_value_get_double_range_max (const GValue *value);
+const GstCaps2 *gst_value_get_caps (const GValue *value);
+void gst_value_set_caps (GValue *calue, const GstCaps2 *caps);
+
void gst_value_list_prepend_value (GValue *value, const GValue *prepend_value);
void gst_value_list_append_value (GValue *value, const GValue *prepend_value);
guint gst_value_list_get_size (const GValue *value);
projects / platform / upstream / gstreamer.git / commitdiff