| /* |
| * GStreamer |
| * Copyright (C) 2009 Luc Deschenaux <luc.deschenaux@freesurf.ch> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "gstglshadervariables.h" |
| |
| #if !defined(strtok_r) && defined(G_OS_WIN32) |
| #if defined(_MSC_VER) |
| #define strtok_r strtok_s |
| #else |
| #define strtok_r(s,d,p) strtok(s,d) |
| #endif |
| #endif |
| |
| #define trimleft(s,chars) while(s[0] && strchr(chars,s[0])) ++s; |
| #define trimright(s,chars) { \ |
| char *end; \ |
| end=s+strlen(s)-1; \ |
| while(end>=s && strchr(chars,end[0])) (end--)[0]=0; \ |
| } |
| |
| const char *gst_gl_shadervariable_datatype[] = { |
| "bool", |
| "int", |
| "uint", |
| "float", |
| "vec2", |
| "vec3", |
| "vec4", |
| "bvec2", |
| "bvec3", |
| "bvec4", |
| "ivec2", |
| "ivec3", |
| "ivec4", |
| "uvec2", |
| "uvec3", |
| "uvec4", |
| "mat2", |
| "mat3", |
| "mat4", |
| "mat2x2", |
| "mat2x3", |
| "mat2x4", |
| "mat3x2", |
| "mat3x3", |
| "mat3x4", |
| "mat4x2", |
| "mat4x3", |
| "mat4x4", |
| 0 |
| }; |
| |
| typedef enum |
| { |
| _bool, |
| _int, |
| _uint, |
| _float, |
| _vec2, |
| _vec3, |
| _vec4, |
| _bvec2, |
| _bvec3, |
| _bvec4, |
| _ivec2, |
| _ivec3, |
| _ivec4, |
| _uvec2, |
| _uvec3, |
| _uvec4, |
| _mat2, |
| _mat3, |
| _mat4, |
| _mat2x2, |
| _mat2x3, |
| _mat2x4, |
| _mat3x2, |
| _mat3x3, |
| _mat3x4, |
| _mat4x2, |
| _mat4x3, |
| _mat4x4, |
| _datatypecount |
| } gst_gl_shadervariable_datatypeindex; |
| |
| typedef struct gst_gl_shadervariable_desc |
| { |
| gst_gl_shadervariable_datatypeindex type; |
| char *name; |
| int arraysize; |
| int count; |
| void *value; |
| |
| } gst_gl_shadervariable_desc; |
| |
| char *parsename (char **varname, int *arraysize, char **saveptr); |
| char *parsevalue (char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| char *vec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| char *bvec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| char *ivec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| char *uvec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| char *mat_parsevalue (int n, int m, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret); |
| |
| /* |
| Function: |
| gst_gl_shadervariables_parse |
| |
| Description: |
| Parse uniform variables declarations and set their values in |
| the specified shader. |
| |
| Arguments: |
| |
| GstGLShader *shader: |
| Shader in which variables are to be set. |
| |
| char *variables: |
| The text to be parsed. |
| |
| int (*_setvariable)(): |
| Defaults to gst_gl_shadervariable_set(). |
| You can specify here a user function for managing the |
| parsed variable description. |
| |
| return values: |
| 0: No error. |
| -1: Error. |
| |
| */ |
| |
| int |
| gst_gl_shadervariables_parse (GstGLShader * shader, char *variables, |
| int (*_setvariable) (GstGLShader * shader, |
| struct gst_gl_shadervariable_desc * v)) |
| { |
| char *p = 0; |
| char *p0; |
| char *e; |
| char e1 = 0; |
| char *t = 0; |
| char *varname; |
| char *vartype; |
| char *varvalue; |
| int arraysize = 0; |
| char *saveptr = variables; |
| int line = 1; |
| char *lim; |
| int i; |
| int len; |
| struct gst_gl_shadervariable_desc ret; |
| |
| if (!_setvariable) { |
| _setvariable = gst_gl_shadervariable_set; |
| } |
| |
| if (!variables) |
| return 0; |
| |
| p0 = variables; |
| trimright (p0, " \t\n"); |
| lim = variables + strlen (variables); |
| e = strchr (p0, ';'); |
| while (p0 < lim) { |
| |
| if (!e) { |
| if (p0[0]) |
| goto parse_error; |
| break; |
| } |
| |
| e1 = e[1]; |
| e[1] = 0; |
| p = g_strdup (p0); |
| e[1] = e1; |
| |
| trimright (p, " \t"); |
| trimleft (p, " \t\n"); |
| |
| t = strtok_r (p, " \t", &saveptr); |
| if (!t) |
| goto parse_error; |
| trimleft (t, " \t"); |
| trimright (t, " \t\n"); |
| |
| if (t[0]) { |
| |
| if (!strcmp (t, "const")) { |
| t = strtok_r (0, " \t", &saveptr); |
| if (!t) |
| goto parse_error; |
| trimleft (t, " \t"); |
| if (!t[0]) |
| goto parse_error; |
| } |
| // parse data type |
| for (i = 0; i < _datatypecount; ++i) { |
| if (!strcmp (t, gst_gl_shadervariable_datatype[i])) { |
| ret.type = (gst_gl_shadervariable_datatypeindex) i; |
| break; |
| } |
| } |
| if (i == _datatypecount) |
| goto parse_error; |
| |
| vartype = g_strdup (t); |
| GST_INFO ("vartype : '%s'\n", vartype); |
| |
| trimleft (saveptr, " \t"); |
| t = saveptr; |
| if (*saveptr == '=') |
| goto parse_error; |
| |
| // parse variable name and array size |
| t = parsename (&varname, &arraysize, &saveptr); |
| if (t) |
| goto parse_error; |
| |
| trimright (varname, " \t"); |
| GST_INFO ("varname : '%s'\n", varname); |
| GST_INFO ("arraysize : %d\n", arraysize); |
| |
| // check type cast after assignement operator |
| t = strtok_r (0, "(", &saveptr); |
| if (!t) |
| goto parse_error; |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| |
| if (arraysize) { |
| gchar *s = g_strdup_printf ("%s[%d]", vartype, arraysize); |
| if (strcmp (t, s)) { |
| g_free (s); |
| goto parse_error; |
| } |
| g_free (s); |
| } else { |
| if (strcmp (t, vartype)) |
| goto parse_error; |
| } |
| |
| // extract variable value |
| t = strtok_r (0, ";", &saveptr); |
| if (!t) |
| goto parse_error; |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| |
| if (!t[0]) |
| goto parse_error; |
| if (*(saveptr - 2) != ')') |
| goto parse_error; |
| *(saveptr - 2) = 0; |
| if (!t[0]) |
| goto parse_error; |
| |
| varvalue = g_strdup (t); |
| GST_INFO ("value: %s\n\n", varvalue); |
| |
| t = saveptr; |
| if (t[0]) |
| goto parse_error; |
| |
| // parse variable value |
| len = strlen (varvalue); |
| ret.name = varname; |
| ret.arraysize = arraysize; |
| t = parsevalue (varvalue, saveptr, &ret); |
| if (t) { |
| t -= len; |
| goto parse_error; |
| } |
| // set variable value |
| _setvariable (shader, &ret); |
| |
| fflush (0); |
| } |
| // Tell me why we cannot free(p) whithout segfault. |
| //g_free(p); |
| p0 = e + 1; |
| ++line; |
| e = strchr (p0, ';'); |
| } |
| |
| return 0; |
| |
| parse_error: |
| if (!t) { |
| t = saveptr; |
| } |
| if (!e) { |
| t = p = p0; |
| } else { |
| e[1] = 0; |
| trimleft (p0, " \t\n"); |
| GST_ERROR ("\n%s", p0); |
| e[1] = e1; |
| } |
| GST_ERROR ("parse error on line %d, position %ld (%s)", line, (glong) (t - p), |
| t); |
| return -1; |
| } |
| |
| /* |
| Function: |
| parsename |
| |
| Description: |
| Parse text between the data type and the assignement operator |
| (ie: variable name and array size). |
| |
| Arguments: |
| |
| char **varname: |
| Text to parse. |
| |
| int *arraysize: |
| Pointer to array size. Set to 0 if no array. |
| |
| char **saveptr: |
| Address of char *saveptr for strtok_r() |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| parsename (char **varname, int *arraysize, char **saveptr) |
| { |
| char *t; |
| char *i; |
| gint j; |
| |
| *arraysize = 0; |
| t = strtok_r (0, "=", saveptr); |
| if (!t) |
| return *saveptr; |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| |
| i = strchr (t, '['); |
| if (!i) { // not an array |
| if (!t[0]) |
| return t; |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr (VALID_VARNAME_CHARS, t[j])) |
| return t + j; |
| } |
| *varname = g_strdup (t); |
| } else { // is an array |
| |
| char *i2; |
| char *c; |
| |
| i2 = strchr (i + 1, ']'); |
| if (!i2) |
| return i + 1; |
| *i = 0; |
| |
| if (!t[0]) |
| return t; |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr (VALID_VARNAME_CHARS, t[j])) |
| return t; |
| } |
| |
| *varname = g_strdup (t); |
| *i = '['; |
| |
| for (c = i + 1; c < i2; ++c) |
| if (*c < '0' || *c > '9') |
| return c; |
| |
| *i2 = 0; |
| *arraysize = atoi (i + 1); |
| *i2 = ']'; |
| |
| if (!*arraysize) |
| return i + 1; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| Function: |
| gst_gl_shadervariable_set |
| |
| Description: |
| Set variable value in the specified shader |
| |
| Arguments: |
| |
| GstGlShader *shader: |
| The shader where to set the variable. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description. |
| |
| return values: |
| 0: No error. |
| !0: Variable type unknown/incorrect. |
| |
| */ |
| |
| int |
| gst_gl_shadervariable_set (GstGLShader * shader, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| switch (ret->type) { |
| case _bool: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_1iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_1i (shader, ret->name, |
| ((int *) ret->value)[0]); |
| } |
| break; |
| case _int: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_1iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_1i (shader, ret->name, |
| ((int *) ret->value)[0]); |
| } |
| break; |
| |
| case _uint: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_1iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_1i (shader, ret->name, |
| ((unsigned int *) ret->value)[0]); |
| } |
| break; |
| |
| case _float: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_1fv (shader, ret->name, ret->count, |
| (float *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_1f (shader, ret->name, |
| ((float *) ret->value)[0]); |
| } |
| break; |
| |
| case _vec2: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_2fv (shader, ret->name, ret->count, |
| (float *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_2f (shader, ret->name, |
| ((float *) ret->value)[0], ((float *) ret->value)[1]); |
| } |
| break; |
| |
| case _bvec2: |
| case _ivec2: |
| case _uvec2: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_2iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_2i (shader, ret->name, |
| ((int *) ret->value)[0], ((int *) ret->value)[1]); |
| } |
| break; |
| |
| case _vec3: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_3fv (shader, ret->name, ret->count, |
| (float *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_3f (shader, ret->name, |
| ((float *) ret->value)[0], ((float *) ret->value)[1], |
| ((float *) ret->value)[2]); |
| } |
| break; |
| |
| case _bvec3: |
| case _ivec3: |
| case _uvec3: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_3iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_3i (shader, ret->name, |
| ((int *) ret->value)[0], ((int *) ret->value)[1], |
| ((int *) ret->value)[2]); |
| } |
| break; |
| |
| case _vec4: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_4fv (shader, ret->name, ret->count, |
| (float *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_4f (shader, ret->name, |
| ((float *) ret->value)[0], ((float *) ret->value)[1], |
| ((float *) ret->value)[2], ((float *) ret->value)[3]); |
| } |
| break; |
| |
| case _bvec4: |
| case _ivec4: |
| case _uvec4: |
| if (ret->arraysize) { |
| gst_gl_shader_set_uniform_4iv (shader, ret->name, ret->count, |
| (int *) ret->value); |
| } else { |
| gst_gl_shader_set_uniform_4i (shader, ret->name, |
| ((int *) ret->value)[0], ((int *) ret->value)[1], |
| ((int *) ret->value)[2], ((int *) ret->value)[3]); |
| } |
| break; |
| |
| case _mat2: |
| case _mat2x2: |
| gst_gl_shader_set_uniform_matrix_2fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat3: |
| case _mat3x3: |
| gst_gl_shader_set_uniform_matrix_3fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat4: |
| case _mat4x4: |
| gst_gl_shader_set_uniform_matrix_4fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| #if GST_GL_HAVE_OPENGL |
| case _mat2x3: |
| gst_gl_shader_set_uniform_matrix_2x3fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat3x2: |
| gst_gl_shader_set_uniform_matrix_3x2fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat2x4: |
| gst_gl_shader_set_uniform_matrix_2x4fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat4x2: |
| gst_gl_shader_set_uniform_matrix_4x2fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat3x4: |
| gst_gl_shader_set_uniform_matrix_3x4fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| |
| case _mat4x3: |
| gst_gl_shader_set_uniform_matrix_4x3fv (shader, ret->name, ret->count, 0, |
| (float *) ret->value); |
| break; |
| #endif |
| |
| default: |
| return -1; |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for scalar |
| variables or call the appropriate subroutine to parse vector |
| variables. |
| |
| Arguments: |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| parsevalue (char *value, char *_saveptr, struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i, j; |
| char *t; |
| char *saveptr = value; |
| |
| switch (ret->type) { |
| case _bool: |
| ret->count = (ret->arraysize) ? ret->arraysize : 1; |
| if (ret->count == 1) { // no array |
| if (strcmp (value, "true") && strcmp (value, "false")) |
| return _saveptr; |
| ret->value = (void *) g_malloc (sizeof (int)); |
| ((int *) ret->value)[0] = strcmp (value, "false"); |
| |
| } else { // array |
| ret->value = g_malloc (sizeof (int *) * ret->count); |
| t = strtok_r (value, ",", &saveptr); |
| for (i = 0; i < ret->count; ++i) { |
| if (!t) |
| return _saveptr + (saveptr - value); |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (strcmp (t, "true") && strcmp (t, "false")) |
| return _saveptr + (saveptr - t); |
| ((int *) ret->value)[i] = strcmp (t, "false"); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| } |
| break; |
| case _int: |
| ret->count = (ret->arraysize) ? ret->arraysize : 1; |
| if (ret->count == 1) { |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("-0123456789", value[j])) |
| return _saveptr + j; |
| } |
| ret->value = (void *) g_malloc (sizeof (int)); |
| *((int *) ret->value) = atoi (value); |
| |
| } else { |
| ret->value = g_malloc (sizeof (int) * ret->count); |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("-0123456789", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((int *) ret->value)[i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| } |
| break; |
| |
| case _uint: |
| ret->count = (ret->arraysize) ? ret->arraysize : 1; |
| if (ret->count == 1) { |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789", value[j])) |
| return _saveptr + j; |
| } |
| ret->value = (void *) g_malloc (sizeof (unsigned int)); |
| *((unsigned int *) ret->value) = atoi (value); |
| |
| } else { |
| ret->value = g_malloc (sizeof (unsigned int) * ret->count); |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((unsigned int *) ret->value)[i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| } |
| break; |
| |
| case _float: |
| ret->count = (ret->arraysize) ? ret->arraysize : 1; |
| if (ret->count == 1) { |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789.-", value[j])) |
| return _saveptr + j; |
| } |
| ret->value = (void *) g_malloc (sizeof (float)); |
| *((float *) ret->value) = (float) strtod (value, NULL); |
| |
| } else { |
| ret->value = g_malloc (sizeof (float) * ret->count); |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789.-", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((float *) ret->value)[i] = (float) strtod (t, NULL); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| } |
| break; |
| |
| case _vec2: |
| return vec_parsevalue (2, value, _saveptr, ret); |
| break; |
| |
| case _bvec2: |
| return bvec_parsevalue (2, value, _saveptr, ret); |
| break; |
| |
| case _ivec2: |
| return ivec_parsevalue (2, value, _saveptr, ret); |
| break; |
| |
| case _uvec2: |
| return uvec_parsevalue (2, value, _saveptr, ret); |
| break; |
| |
| case _vec3: |
| return vec_parsevalue (3, value, _saveptr, ret); |
| break; |
| |
| case _bvec3: |
| return bvec_parsevalue (3, value, _saveptr, ret); |
| break; |
| |
| case _ivec3: |
| return uvec_parsevalue (3, value, _saveptr, ret); |
| break; |
| |
| case _uvec3: |
| return uvec_parsevalue (3, value, _saveptr, ret); |
| break; |
| |
| case _vec4: |
| return vec_parsevalue (4, value, _saveptr, ret); |
| break; |
| |
| case _bvec4: |
| return bvec_parsevalue (4, value, _saveptr, ret); |
| break; |
| |
| case _ivec4: |
| return ivec_parsevalue (4, value, _saveptr, ret); |
| break; |
| |
| case _uvec4: |
| return uvec_parsevalue (4, value, _saveptr, ret); |
| break; |
| |
| case _mat2: |
| case _mat2x2: |
| return mat_parsevalue (2, 2, value, _saveptr, ret); |
| break; |
| |
| case _mat2x3: |
| return mat_parsevalue (2, 3, value, _saveptr, ret); |
| break; |
| |
| case _mat3x2: |
| return mat_parsevalue (3, 2, value, _saveptr, ret); |
| break; |
| |
| case _mat2x4: |
| return mat_parsevalue (2, 4, value, _saveptr, ret); |
| break; |
| |
| case _mat4x2: |
| return mat_parsevalue (4, 2, value, _saveptr, ret); |
| break; |
| |
| case _mat3: |
| case _mat3x3: |
| return mat_parsevalue (3, 3, value, _saveptr, ret); |
| break; |
| |
| case _mat3x4: |
| return mat_parsevalue (3, 4, value, _saveptr, ret); |
| break; |
| |
| case _mat4x3: |
| return mat_parsevalue (4, 3, value, _saveptr, ret); |
| break; |
| |
| case _mat4: |
| case _mat4x4: |
| return mat_parsevalue (4, 4, value, _saveptr, ret); |
| break; |
| |
| default: |
| break; |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| vec_parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for vec |
| type variables. |
| |
| Arguments: |
| |
| int n; |
| Vector dimension. |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| vec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i; |
| int j; |
| int k; |
| char *saveptr = value; |
| char *saveptr2; |
| char *t; |
| char *u; |
| |
| ret->count = (ret->arraysize) ? ret->arraysize * n : n; |
| ret->value = g_malloc (sizeof (float) * ret->count); |
| |
| if (!ret->arraysize) { |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789.-", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((float *) ret->value)[i] = (float) strtod (t, NULL); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| |
| } else { |
| |
| saveptr2 = value; |
| u = strtok_r (value, ")", &saveptr2); |
| |
| for (k = 0; k < ret->arraysize; ++k) { |
| |
| if (!u) |
| return _saveptr + (saveptr2 - value); |
| |
| trimleft (u, " \t"); |
| trimright (u, " \t"); |
| |
| if (k) { |
| if (u[0] != ',') |
| return _saveptr + (u - value); |
| ++u; |
| trimleft (u, " \t"); |
| } |
| |
| if (strncmp (u, gst_gl_shadervariable_datatype[ret->type], |
| strlen (gst_gl_shadervariable_datatype[ret->type]))) |
| return _saveptr + (u - value); |
| |
| u += strlen (gst_gl_shadervariable_datatype[ret->type]); |
| trimleft (u, " \t"); |
| if (u[0] != '(') |
| return _saveptr + (u - value); |
| ++u; |
| |
| t = strtok_r (u, ",", &saveptr); |
| if (!t) |
| return _saveptr + (u - value); |
| |
| for (i = 0; i < n; ++i) { |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (t - value); |
| |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr ("0123456789.-", t[j])) |
| return _saveptr + (t - value) + j; |
| } |
| |
| ((float *) ret->value)[k * n + i] = (float) strtod (t, NULL); |
| t = strtok_r (0, ",", &saveptr); |
| if (i < (n - 1) && !t) |
| return _saveptr + (saveptr - value); |
| |
| } |
| u = strtok_r (0, ")", &saveptr2); |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| bvec_parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for bvec |
| type variables. |
| |
| Arguments: |
| |
| int n; |
| Vector dimension. |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| bvec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i; |
| int k; |
| char *saveptr = value; |
| char *saveptr2; |
| char *t; |
| char *u; |
| |
| ret->count = (ret->arraysize) ? ret->arraysize * n : n; |
| ret->value = g_malloc (sizeof (char **) * ret->count); |
| |
| if (!ret->arraysize) { |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| if (strcmp ("true", value) || strcmp ("false", value)) |
| return _saveptr + (saveptr - t); |
| |
| ((int *) ret->value)[i] = strcmp (t, "false"); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| |
| } else { |
| |
| saveptr2 = value; |
| u = strtok_r (value, ")", &saveptr2); |
| |
| for (k = 0; k < ret->arraysize; ++k) { |
| |
| if (!u) |
| return _saveptr + (saveptr2 - value); |
| |
| trimleft (u, " \t"); |
| trimright (u, " \t"); |
| |
| if (k) { |
| if (u[0] != ',') |
| return _saveptr + (u - value); |
| ++u; |
| trimleft (u, " \t"); |
| } |
| |
| if (strncmp (u, gst_gl_shadervariable_datatype[ret->type], |
| strlen (gst_gl_shadervariable_datatype[ret->type]))) |
| return _saveptr + (u - value); |
| |
| u += strlen (gst_gl_shadervariable_datatype[ret->type]); |
| trimleft (u, " \t"); |
| if (u[0] != '(') |
| return _saveptr + (u - value); |
| ++u; |
| |
| t = strtok_r (u, ",", &saveptr); |
| if (!t) |
| return _saveptr + (u - value); |
| |
| for (i = 0; i < n; ++i) { |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (t - value); |
| |
| if (strcmp ("true", t) || strcmp ("false", t)) |
| return _saveptr + (saveptr - t); |
| |
| ((int *) ret->value)[k * n + i] = strcmp (t, "false"); |
| t = strtok_r (0, ",", &saveptr); |
| if (i < (n - 1) && !t) |
| return _saveptr + (saveptr - value); |
| |
| } |
| u = strtok_r (0, ")", &saveptr2); |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| ivec_parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for ivec |
| type variables. |
| |
| Arguments: |
| |
| int n; |
| Vector dimension. |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| ivec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i; |
| int j; |
| int k; |
| char *saveptr = value; |
| char *saveptr2; |
| char *t; |
| char *u; |
| |
| ret->count = (ret->arraysize) ? ret->arraysize * n : n; |
| ret->value = g_malloc (sizeof (int) * ret->count); |
| |
| if (!ret->arraysize) { |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789-", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((int *) ret->value)[i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| |
| } else { |
| |
| saveptr2 = value; |
| u = strtok_r (value, ")", &saveptr2); |
| |
| for (k = 0; k < ret->arraysize; ++k) { |
| |
| if (!u) |
| return _saveptr + (saveptr2 - value); |
| |
| trimleft (u, " \t"); |
| trimright (u, " \t"); |
| |
| if (k) { |
| if (u[0] != ',') |
| return _saveptr + (u - value); |
| ++u; |
| trimleft (u, " \t"); |
| } |
| |
| if (strncmp (u, gst_gl_shadervariable_datatype[ret->type], |
| strlen (gst_gl_shadervariable_datatype[ret->type]))) |
| return _saveptr + (u - value); |
| |
| u += strlen (gst_gl_shadervariable_datatype[ret->type]); |
| trimleft (u, " \t"); |
| if (u[0] != '(') |
| return _saveptr + (u - value); |
| ++u; |
| |
| t = strtok_r (u, ",", &saveptr); |
| if (!t) |
| return _saveptr + (u - value); |
| |
| for (i = 0; i < n; ++i) { |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (t - value); |
| |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr ("0123456789-", t[j])) |
| return _saveptr + (t - value) + j; |
| } |
| |
| ((int *) ret->value)[k * n + i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| if (i < (n - 1) && !t) |
| return _saveptr + (saveptr - value); |
| |
| } |
| u = strtok_r (0, ")", &saveptr2); |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| uvec_parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for uvec |
| type variables. |
| |
| Arguments: |
| |
| int n; |
| Vector dimension. |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| uvec_parsevalue (int n, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i; |
| int j; |
| int k; |
| char *saveptr = value; |
| char *saveptr2; |
| char *t; |
| char *u; |
| |
| ret->count = (ret->arraysize) ? ret->arraysize * n : n; |
| ret->value = g_malloc (sizeof (unsigned int) * ret->count); |
| |
| if (!ret->arraysize) { |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((unsigned int *) ret->value)[i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| |
| } else { |
| |
| saveptr2 = value; |
| u = strtok_r (value, ")", &saveptr2); |
| |
| for (k = 0; k < ret->arraysize; ++k) { |
| |
| if (!u) |
| return _saveptr + (saveptr2 - value); |
| |
| trimleft (u, " \t"); |
| trimright (u, " \t"); |
| |
| if (k) { |
| if (u[0] != ',') |
| return _saveptr + (u - value); |
| ++u; |
| trimleft (u, " \t"); |
| } |
| |
| if (strncmp (u, gst_gl_shadervariable_datatype[ret->type], |
| strlen (gst_gl_shadervariable_datatype[ret->type]))) |
| return _saveptr + (u - value); |
| |
| u += strlen (gst_gl_shadervariable_datatype[ret->type]); |
| trimleft (u, " \t"); |
| if (u[0] != '(') |
| return _saveptr + (u - value); |
| ++u; |
| |
| t = strtok_r (u, ",", &saveptr); |
| if (!t) |
| return _saveptr + (u - value); |
| |
| for (i = 0; i < n; ++i) { |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (t - value); |
| |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr ("0123456789", t[j])) |
| return _saveptr + (t - value) + j; |
| } |
| |
| ((unsigned int *) ret->value)[k * n + i] = atoi (t); |
| t = strtok_r (0, ",", &saveptr); |
| if (i < (n - 1) && !t) |
| return _saveptr + (saveptr - value); |
| |
| } |
| u = strtok_r (0, ")", &saveptr2); |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| Function: |
| mat_parsevalue |
| |
| Description: |
| Parse text coming after the assignement operator for matrix |
| type variables. |
| |
| Arguments: |
| |
| int n,m; |
| Matrix dimensions. |
| |
| char *value: |
| Text to be parsed. |
| |
| char *_saveptr: |
| Index of end of value. |
| |
| struct gst_gl_shadervariable_desc *ret: |
| The variable description to be completed |
| At input time it contains the data type index (type), |
| variable name (name) and array size (arraysize). |
| |
| return values: |
| 0: No error. |
| !0: Pointer to parse error. |
| |
| */ |
| |
| char * |
| mat_parsevalue (int n, int m, char *value, char *_saveptr, |
| struct gst_gl_shadervariable_desc *ret) |
| { |
| |
| int i; |
| int j; |
| int k; |
| char *saveptr = value; |
| char *saveptr2; |
| char *t; |
| char *u; |
| |
| ret->count = (ret->arraysize) ? ret->arraysize * n * m : n * m; |
| ret->value = g_malloc (sizeof (float) * ret->count); |
| |
| if (!ret->arraysize) { |
| t = strtok_r (value, ",", &saveptr); |
| |
| for (i = 0; i < ret->count; ++i) { |
| |
| if (!t) |
| return _saveptr + (saveptr - value); |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (saveptr - t); |
| |
| for (j = 0; j < (gint) strlen (value); ++j) { |
| if (!strchr ("0123456789.-", value[j])) |
| return _saveptr + (saveptr - t) + j; |
| } |
| |
| ((float *) ret->value)[i] = (float) strtod (t, NULL); |
| t = strtok_r (0, ",", &saveptr); |
| } |
| |
| } else { |
| |
| saveptr2 = value; |
| u = strtok_r (value, ")", &saveptr2); |
| |
| for (k = 0; k < ret->arraysize; ++k) { |
| |
| if (!u) |
| return _saveptr + (saveptr2 - value); |
| |
| trimleft (u, " \t"); |
| trimright (u, " \t"); |
| |
| if (k) { |
| if (u[0] != ',') |
| return _saveptr + (u - value); |
| ++u; |
| trimleft (u, " \t"); |
| } |
| |
| if (strncmp (u, gst_gl_shadervariable_datatype[ret->type], |
| strlen (gst_gl_shadervariable_datatype[ret->type]))) |
| return _saveptr + (u - value); |
| |
| u += strlen (gst_gl_shadervariable_datatype[ret->type]); |
| trimleft (u, " \t"); |
| if (u[0] != '(') |
| return _saveptr + (u - value); |
| ++u; |
| |
| t = strtok_r (u, ",", &saveptr); |
| if (!t) |
| return _saveptr + (u - value); |
| |
| for (i = 0; i < n * m; ++i) { |
| |
| trimleft (t, " \t"); |
| trimright (t, " \t"); |
| if (!t[0]) |
| return _saveptr + (t - value); |
| |
| for (j = 0; j < (gint) strlen (t); ++j) { |
| if (!strchr ("0123456789.-", t[j])) |
| return _saveptr + (t - value) + j; |
| } |
| |
| ((float *) ret->value)[k * n * m + i] = (float) strtod (t, NULL); |
| t = strtok_r (0, ",", &saveptr); |
| if (i < (n * m - 1) && !t) |
| return _saveptr + (saveptr - value); |
| |
| } |
| u = strtok_r (0, ")", &saveptr2); |
| } |
| } |
| return 0; |
| } |
