git.sesse.net Git - vlc/blob - modules/visualization/galaktos/param.c

   1 /*****************************************************************************
   2  * param.c:
   3  *****************************************************************************
   4  * Copyright (C) 2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Cyril Deguet <asmax@videolan.org>
   8  *          code from projectM http://xmms-projectm.sourceforge.net
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25
  26
  27 /* Basic Parameter Functions */
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <math.h>
  33 #include "fatal.h"
  34 #include "common.h"
  35
  36 #include "splaytree_types.h"
  37 #include "splaytree.h"
  38 #include "tree_types.h"
  39
  40 #include "param_types.h"
  41 #include "param.h"
  42
  43 #include "expr_types.h"
  44 #include "eval.h"
  45
  46 #include "engine_vars.h"
  47
  48 void reset_param(param_t * param);
  49
  50 int is_valid_param_string(char * string); /* true if string is valid variable or function name */
  51
  52
  53 /* A splay tree of builtin parameters */
  54 splaytree_t * builtin_param_tree = NULL;
  55
  56 int insert_param_alt_name(param_t * param, char * alt_name);
  57
  58 int insert_builtin_param(param_t * param);
  59
  60 /* Private function prototypes */
  61 int compare_param(char * name, char * name2);
  62
  63 int load_builtin_param_double(char * name, void * engine_val, void * matrix, short int flags,
  64                                                                 double init_val, double upper_bound, double lower_bound, char * alt_name);
  65
  66 int load_builtin_param_int(char * name, void * engine_val, short int flags,
  67                                                                 int init_val, int upper_bound, int lower_bound, char * alt_name);
  68
  69 int load_builtin_param_bool(char * name, void * engine_val, short int flags,
  70                                                                 int init_val, char * alt_name);
  71
  72
  73
  74 param_t * create_param (char * name, short int type, short int flags, void * engine_val, void * matrix,
  75                                                         value_t default_init_val, value_t upper_bound, value_t lower_bound) {
  76
  77   param_t * param = NULL;
  78
  79   param = (param_t*)malloc(sizeof(param_t));
  80
  81   if (param == NULL) {
  82         printf("create_param: out of memory!!!\n");
  83         return NULL;
  84   }
  85
  86   /* Clear name space, think the strncpy statement makes this redundant */
  87   //memset(param->name, 0, MAX_TOKEN_SIZE);
  88
  89   /* Copy given name into parameter structure */
  90   strncpy(param->name, name, MAX_TOKEN_SIZE-1);
  91
  92   /* Assign other entries in a constructor like fashion */
  93   param->type = type;
  94   param->flags = flags;
  95   param->matrix_flag = 0;
  96   param->matrix = matrix;
  97   param->engine_val = engine_val;
  98   param->default_init_val = default_init_val;
  99   //*param->init_val = default_init_val;
 100   param->upper_bound = upper_bound;
 101   param->lower_bound = lower_bound;
 102
 103   /* Return instantiated parameter */
 104   return param;
 105
 106 }
 107
 108 /* Creates a user defined parameter */
 109 param_t * create_user_param(char * name) {
 110
 111   param_t * param;
 112   value_t iv;
 113   value_t ub;
 114   value_t lb;
 115   double * engine_val;
 116
 117   /* Set initial values to default */
 118   iv.double_val = DEFAULT_DOUBLE_IV;
 119   ub.double_val = DEFAULT_DOUBLE_UB;
 120   lb.double_val = DEFAULT_DOUBLE_LB;
 121
 122   /* Argument checks */
 123   if (name == NULL)
 124     return NULL;
 125
 126   /* Allocate space for the engine variable */
 127   if ((engine_val = (double*)malloc(sizeof(double))) == NULL)
 128     return NULL;
 129
 130   (*engine_val) = iv.double_val; /* set some default init value */
 131
 132   /* Create the new user parameter */
 133   if ((param = create_param(name, P_TYPE_DOUBLE, P_FLAG_USERDEF, engine_val, NULL, iv, ub, lb)) == NULL) {
 134     free(engine_val);
 135     return NULL;
 136   }
 137   if (PARAM_DEBUG) printf("create_param: \"%s\" initialized\n", param->name);
 138   /* Return the instantiated parameter */
 139   return param;
 140 }
 141
 142 /* Initialize the builtin parameter database.
 143    Should only be necessary once */
 144 int init_builtin_param_db() {
 145
 146   /* Create the builtin parameter splay tree (go Sleator...) */
 147   if ((builtin_param_tree = create_splaytree(compare_string, copy_string, free_string)) == NULL) {
 148           if (PARAM_DEBUG) printf("init_builtin_param_db: failed to initialize database (FATAL)\n");
 149           return OUTOFMEM_ERROR;
 150   }
 151
 152   if (PARAM_DEBUG) {
 153           printf("init_builtin_param: loading database...");
 154           fflush(stdout);
 155   }
 156
 157   /* Loads all builtin parameters into the database */
 158   if (load_all_builtin_param() < 0) {
 159         if (PARAM_DEBUG) printf("failed loading builtin parameters (FATAL)\n");
 160     return ERROR;
 161   }
 162
 163   if (PARAM_DEBUG) printf("success!\n");
 164
 165   /* Finished, no errors */
 166   return SUCCESS;
 167 }
 168
 169 /* Destroy the builtin parameter database.
 170    Generally, do this on projectm exit */
 171 int destroy_builtin_param_db() {
 172
 173   splay_traverse(free_param, builtin_param_tree);
 174   destroy_splaytree(builtin_param_tree);
 175   builtin_param_tree = NULL;
 176   return SUCCESS;
 177
 178 }
 179
 180
 181 /* Insert a parameter into the database with an alternate name */
 182 int insert_param_alt_name(param_t * param, char * alt_name) {
 183
 184   if (param == NULL)
 185     return ERROR;
 186   if (alt_name == NULL)
 187           return ERROR;
 188
 189   splay_insert_link(alt_name, param->name, builtin_param_tree);
 190
 191   return SUCCESS;
 192 }
 193
 194
 195 param_t * find_builtin_param(char * name) {
 196
 197   /* Null argument checks */
 198   if (name == NULL)
 199           return NULL;
 200
 201   return splay_find(name, builtin_param_tree);
 202
 203 }
 204
 205 /* Find a parameter given its name, will create one if not found */
 206 param_t * find_param(char * name, preset_t * preset, int flags) {
 207
 208   param_t * param = NULL;
 209
 210   /* Null argument checks */
 211   if (name == NULL)
 212           return NULL;
 213   if (preset == NULL)
 214           return NULL;
 215
 216   /* First look in the builtin database */
 217   param = (param_t *)splay_find(name, builtin_param_tree);
 218
 219   /* If the search failed, check the user database */
 220   if (param == NULL) {
 221     param = (param_t*)splay_find(name, preset->user_param_tree);
 222   }
 223   /* If it doesn't exist in the user (or builtin) database and
 224           create_flag is set, then make it and insert into the database
 225   */
 226
 227   if ((param == NULL) && (flags & P_CREATE)) {
 228
 229         /* Check if string is valid */
 230     if (!is_valid_param_string(name)) {
 231       if (PARAM_DEBUG) printf("find_param: invalid parameter name:\"%s\"\n", name);
 232       return NULL;
 233     }
 234     /* Now, create the user defined parameter given the passed name */
 235     if ((param = create_user_param(name)) == NULL) {
 236       if (PARAM_DEBUG) printf("find_param: failed to create a new user parameter!\n");
 237       return NULL;
 238     }
 239     /* Finally, insert the new parameter into this preset's proper splaytree */
 240     if (splay_insert(param, param->name, preset->user_param_tree) < 0) {
 241       if (PARAM_DEBUG) printf("PARAM \"%s\" already exists in user parameter tree!\n", param->name);
 242       free_param(param);
 243       return NULL;
 244     }
 245
 246   }
 247
 248   /* Return the found (or created) parameter. Note that if P_CREATE is not set, this could be null */
 249   return param;
 250
 251 }
 252
 253 /* Compare string name with parameter name */
 254 int compare_param(char * name, char * name2) {
 255
 256   int cmpval;
 257   printf("am i used\n");
 258   /* Uses string comparison function */
 259   cmpval = strncmp(name, name2, MAX_TOKEN_SIZE-1);
 260
 261   return cmpval;
 262 }
 263
 264 /* Loads all builtin parameters, limits are also defined here */
 265 int load_all_builtin_param() {
 266
 267   load_builtin_param_double("fRating", (void*)&fRating, NULL, P_FLAG_NONE, 0.0 , 5.0, 0.0, NULL);
 268   load_builtin_param_double("fWaveScale", (void*)&fWaveScale, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 269   load_builtin_param_double("gamma", (void*)&fGammaAdj, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fGammaAdj");
 270   load_builtin_param_double("echo_zoom", (void*)&fVideoEchoZoom, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoZoom");
 271   load_builtin_param_double("echo_alpha", (void*)&fVideoEchoAlpha, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoAlpha");
 272   load_builtin_param_double("wave_a", (void*)&fWaveAlpha, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fWaveAlpha");
 273   load_builtin_param_double("fWaveSmoothing", (void*)&fWaveSmoothing, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 274   load_builtin_param_double("fModWaveAlphaStart", (void*)&fModWaveAlphaStart, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 275   load_builtin_param_double("fModWaveAlphaEnd", (void*)&fModWaveAlphaEnd, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 276   load_builtin_param_double("fWarpAnimSpeed",  (void*)&fWarpAnimSpeed, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 277   //  load_builtin_param_double("warp", (void*)&warp, warp_mesh, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 278
 279   load_builtin_param_double("fShader", (void*)&fShader, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 280   load_builtin_param_double("decay", (void*)&decay, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fDecay");
 281
 282   load_builtin_param_int("echo_orient", (void*)&nVideoEchoOrientation, P_FLAG_NONE, 0, 3, 0, "nVideoEchoOrientation");
 283   load_builtin_param_int("wave_mode", (void*)&nWaveMode, P_FLAG_NONE, 0, 7, 0, "nWaveMode");
 284
 285   load_builtin_param_bool("wave_additive", (void*)&bAdditiveWaves, P_FLAG_NONE, FALSE, "bAdditiveWaves");
 286   load_builtin_param_bool("bModWaveAlphaByVolume", (void*)&bModWaveAlphaByVolume, P_FLAG_NONE, FALSE, NULL);
 287   load_builtin_param_bool("wave_brighten", (void*)&bMaximizeWaveColor, P_FLAG_NONE, FALSE, "bMaximizeWaveColor");
 288   load_builtin_param_bool("wrap", (void*)&bTexWrap, P_FLAG_NONE, FALSE, "bTexWrap");
 289   load_builtin_param_bool("darken_center", (void*)&bDarkenCenter, P_FLAG_NONE, FALSE, "bDarkenCenter");
 290   load_builtin_param_bool("bRedBlueStereo", (void*)&bRedBlueStereo, P_FLAG_NONE, FALSE, NULL);
 291   load_builtin_param_bool("brighten", (void*)&bBrighten, P_FLAG_NONE, FALSE, "bBrighten");
 292   load_builtin_param_bool("darken", (void*)&bDarken, P_FLAG_NONE, FALSE, "bDarken");
 293   load_builtin_param_bool("solarize", (void*)&bSolarize, P_FLAG_NONE, FALSE, "bSolarize");
 294   load_builtin_param_bool("invert", (void*)&bInvert, P_FLAG_NONE, FALSE, "bInvert");
 295   load_builtin_param_bool("bMotionVectorsOn", (void*)&bMotionVectorsOn, P_FLAG_NONE, FALSE, NULL);
 296   load_builtin_param_bool("wave_dots", (void*)&bWaveDots, P_FLAG_NONE, FALSE, "bWaveDots");
 297   load_builtin_param_bool("wave_thick", (void*)&bWaveThick, P_FLAG_NONE, FALSE, "bWaveThick");
 298
 299
 300
 301   load_builtin_param_double("zoom", (void*)&zoom, zoom_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 302   load_builtin_param_double("rot", (void*)&rot, rot_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
 303   load_builtin_param_double("zoomexp", (void*)&zoomexp, zoomexp_mesh,  P_FLAG_PER_PIXEL |P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fZoomExponent");
 304
 305   load_builtin_param_double("cx", (void*)&cx, cx_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
 306   load_builtin_param_double("cy", (void*)&cy, cy_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
 307   load_builtin_param_double("dx", (void*)&dx, dx_mesh,  P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
 308   load_builtin_param_double("dy", (void*)&dy, dy_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
 309   load_builtin_param_double("sx", (void*)&sx, sx_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 310   load_builtin_param_double("sy", (void*)&sy, sy_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 311
 312   load_builtin_param_double("wave_r", (void*)&wave_r, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 313   load_builtin_param_double("wave_g", (void*)&wave_g, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 314   load_builtin_param_double("wave_b", (void*)&wave_b, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 315   load_builtin_param_double("wave_x", (void*)&wave_x, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 316   load_builtin_param_double("wave_y", (void*)&wave_y, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 317   load_builtin_param_double("wave_mystery", (void*)&wave_mystery, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, "fWaveParam");
 318
 319   load_builtin_param_double("ob_size", (void*)&ob_size, NULL, P_FLAG_NONE, 0.0, 0.5, 0, NULL);
 320   load_builtin_param_double("ob_r", (void*)&ob_r, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 321   load_builtin_param_double("ob_g", (void*)&ob_g, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 322   load_builtin_param_double("ob_b", (void*)&ob_b, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 323   load_builtin_param_double("ob_a", (void*)&ob_a, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 324
 325   load_builtin_param_double("ib_size", (void*)&ib_size,  NULL,P_FLAG_NONE, 0.0, .5, 0.0, NULL);
 326   load_builtin_param_double("ib_r", (void*)&ib_r,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 327   load_builtin_param_double("ib_g", (void*)&ib_g,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 328   load_builtin_param_double("ib_b", (void*)&ib_b,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 329   load_builtin_param_double("ib_a", (void*)&ib_a,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 330
 331   load_builtin_param_double("mv_r", (void*)&mv_r,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 332   load_builtin_param_double("mv_g", (void*)&mv_g,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 333   load_builtin_param_double("mv_b", (void*)&mv_b,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 334   load_builtin_param_double("mv_x", (void*)&mv_x,  NULL,P_FLAG_NONE, 0.0, 64.0, 0.0, "nMotionVectorsX");
 335   load_builtin_param_double("mv_y", (void*)&mv_y,  NULL,P_FLAG_NONE, 0.0, 48.0, 0.0, "nMotionVectorsY");
 336   load_builtin_param_double("mv_l", (void*)&mv_l,  NULL,P_FLAG_NONE, 0.0, 5.0, 0.0, NULL);
 337   load_builtin_param_double("mv_dy", (void*)&mv_dy, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 338   load_builtin_param_double("mv_dx", (void*)&mv_dx,  NULL,P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
 339   load_builtin_param_double("mv_a", (void*)&mv_a,  NULL,P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
 340
 341   load_builtin_param_double("time", (void*)&Time,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0.0, NULL);
 342   load_builtin_param_double("bass", (void*)&bass,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0.0, NULL);
 343   load_builtin_param_double("mid", (void*)&mid,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 344   load_builtin_param_double("bass_att", (void*)&bass_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 345   load_builtin_param_double("mid_att", (void*)&mid_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 346   load_builtin_param_double("treb_att", (void*)&treb_att,  NULL,P_FLAG_READONLY, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
 347   load_builtin_param_int("frame", (void*)&frame, P_FLAG_READONLY, 0, MAX_INT_SIZE, 0, NULL);
 348   load_builtin_param_double("progress", (void*)&progress,  NULL,P_FLAG_READONLY, 0.0, 1, 0, NULL);
 349   load_builtin_param_int("fps", (void*)&fps, P_FLAG_NONE, 15, MAX_INT_SIZE, 0, NULL);
 350
 351
 352
 353   load_builtin_param_double("x", (void*)&x_per_pixel, x_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
 354                             0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 355   load_builtin_param_double("y", (void*)&y_per_pixel, y_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX |P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
 356                             0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 357   load_builtin_param_double("ang", (void*)&ang_per_pixel, theta_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
 358                             0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 359   load_builtin_param_double("rad", (void*)&rad_per_pixel, rad_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
 360                             0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 361
 362
 363   load_builtin_param_double("q1", (void*)&q1,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 364   load_builtin_param_double("q2", (void*)&q2,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 365   load_builtin_param_double("q3", (void*)&q3,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 366   load_builtin_param_double("q4", (void*)&q4,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 367   load_builtin_param_double("q5", (void*)&q5,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 368   load_builtin_param_double("q6", (void*)&q6,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 369   load_builtin_param_double("q7", (void*)&q7,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 370   load_builtin_param_double("q8", (void*)&q8,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 371
 372
 373
 374   /* variables added in 1.04 */
 375   load_builtin_param_int("meshx", (void*)&gx, P_FLAG_READONLY, 32, 96, 8, NULL);
 376   load_builtin_param_int("meshy", (void*)&gy, P_FLAG_READONLY, 24, 72, 6, NULL);
 377
 378   return SUCCESS;
 379
 380 }
 381
 382 /* Free's a parameter type */
 383 void free_param(param_t * param) {
 384   int x;
 385   if (param == NULL)
 386         return;
 387
 388   if (param->flags & P_FLAG_USERDEF) {
 389     free(param->engine_val);
 390
 391   }
 392
 393   if (!(param->flags & P_FLAG_DONT_FREE_MATRIX)) {
 394
 395     if (param->flags & P_FLAG_PER_POINT)
 396       free(param->matrix);
 397
 398     else if (param->flags & P_FLAG_PER_PIXEL) {
 399        for(x = 0; x < gx; x++)
 400            free(((double**)param->matrix)[x]);
 401        free(param->matrix);
 402       }
 403   }
 404
 405   if (PARAM_DEBUG) printf("free_param: freeing \"%s\".\n", param->name);
 406   free(param);
 407
 408 }
 409
 410 /* Loads a double parameter into the builtin database */
 411 int load_builtin_param_double(char * name, void * engine_val, void * matrix, short int flags,
 412                                                 double init_val, double upper_bound, double lower_bound, char * alt_name) {
 413
 414   param_t * param = NULL;
 415   value_t iv, ub, lb;
 416
 417   iv.double_val = init_val;
 418   ub.double_val = upper_bound;
 419   lb.double_val = lower_bound;
 420
 421   /* Create new parameter of type double */
 422   if (PARAM_DEBUG == 2) {
 423           printf("load_builtin_param_double: (name \"%s\") (alt_name = \"%s\") ", name, alt_name);
 424           fflush(stdout);
 425   }
 426
 427  if ((param = create_param(name, P_TYPE_DOUBLE, flags, engine_val, matrix, iv, ub, lb)) == NULL) {
 428     return OUTOFMEM_ERROR;
 429   }
 430
 431   if (PARAM_DEBUG == 2) {
 432         printf("created...");
 433         fflush(stdout);
 434    }
 435
 436   /* Insert the paremeter into the database */
 437
 438   if (insert_builtin_param(param) < 0) {
 439         free_param(param);
 440     return ERROR;
 441   }
 442
 443   if (PARAM_DEBUG == 2) {
 444           printf("inserted...");
 445           fflush(stdout);
 446   }
 447
 448   /* If this parameter has an alternate name, insert it into the database as link */
 449
 450   if (alt_name != NULL) {
 451         insert_param_alt_name(param, alt_name);
 452
 453   if (PARAM_DEBUG == 2) {
 454           printf("alt_name inserted...");
 455           fflush(stdout);
 456         }
 457
 458
 459   }
 460
 461   if (PARAM_DEBUG == 2) printf("finished\n");
 462   /* Finished, return success */
 463   return SUCCESS;
 464 }
 465
 466
 467
 468 /* Loads a double parameter into the builtin database */
 469 param_t * new_param_double(char * name, short int flags, void * engine_val, void * matrix,
 470                                                 double upper_bound, double lower_bound, double init_val) {
 471
 472   param_t * param;
 473   value_t iv, ub, lb;
 474
 475   iv.double_val = init_val;
 476   ub.double_val = upper_bound;
 477   lb.double_val = lower_bound;
 478
 479   if ((param = create_param(name, P_TYPE_DOUBLE, flags, engine_val, matrix,iv, ub, lb)) == NULL)
 480     return NULL;
 481
 482
 483   /* Finished, return success */
 484   return param;
 485 }
 486
 487
 488 /* Creates a new parameter of type int */
 489 param_t * new_param_int(char * name, short int flags, void * engine_val,
 490                                                 int upper_bound, int lower_bound, int init_val) {
 491
 492   param_t * param;
 493   value_t iv, ub, lb;
 494
 495   iv.int_val = init_val;
 496   ub.int_val = upper_bound;
 497   lb.int_val = lower_bound;
 498
 499   if ((param = create_param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb)) == NULL)
 500     return NULL;
 501
 502
 503   /* Finished, return success */
 504   return param;
 505 }
 506
 507 /* Creates a new parameter of type bool */
 508 param_t * new_param_bool(char * name, short int flags, void * engine_val,
 509                                                 int upper_bound, int lower_bound, int init_val) {
 510
 511   param_t * param;
 512   value_t iv, ub, lb;
 513
 514   iv.bool_val = init_val;
 515   ub.bool_val = upper_bound;
 516   lb.bool_val = lower_bound;
 517
 518   if ((param = create_param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb)) == NULL)
 519     return NULL;
 520
 521
 522   /* Finished, return success */
 523   return param;
 524 }
 525
 526
 527 /* Loads a integer parameter into the builtin database */
 528 int load_builtin_param_int(char * name, void * engine_val, short int flags,
 529                                                 int init_val, int upper_bound, int lower_bound, char * alt_name) {
 530
 531   param_t * param;
 532   value_t iv, ub, lb;
 533
 534   iv.int_val = init_val;
 535   ub.int_val = upper_bound;
 536   lb.int_val = lower_bound;
 537
 538   param = create_param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb);
 539
 540   if (param == NULL) {
 541     return OUTOFMEM_ERROR;
 542   }
 543
 544   if (insert_builtin_param(param) < 0) {
 545         free_param(param);
 546     return ERROR;
 547   }
 548
 549   if (alt_name != NULL) {
 550         insert_param_alt_name(param, alt_name);
 551   }
 552
 553   return SUCCESS;
 554
 555 }
 556
 557 /* Loads a boolean parameter */
 558 int load_builtin_param_bool(char * name, void * engine_val, short int flags,
 559                                                                 int init_val, char * alt_name) {
 560
 561   param_t * param;
 562   value_t iv, ub, lb;
 563
 564   iv.int_val = init_val;
 565   ub.int_val = TRUE;
 566   lb.int_val = FALSE;
 567
 568   param = create_param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb);
 569
 570   if (param == NULL) {
 571     return OUTOFMEM_ERROR;
 572   }
 573
 574   if (insert_builtin_param(param) < 0) {
 575         free_param(param);
 576     return ERROR;
 577   }
 578
 579   if (alt_name != NULL) {
 580         insert_param_alt_name(param, alt_name);
 581   }
 582
 583   return SUCCESS;
 584
 585 }
 586
 587
 588
 589
 590 /* Returns nonzero if the string is valid parameter name */
 591 int is_valid_param_string(char * string) {
 592
 593   if (string == NULL)
 594     return FALSE;
 595
 596   /* This ensures the first character is non numeric */
 597   if( ((*string) >= 48) && ((*string) <= 57))
 598     return FALSE;
 599
 600   /* These probably should never happen */
 601   if (*string == '.')
 602         return FALSE;
 603
 604   if (*string == '+')
 605         return FALSE;
 606
 607   if (*string == '-')
 608         return FALSE;
 609
 610   /* Could also add checks for other symbols. May do later */
 611
 612   return TRUE;
 613
 614 }
 615
 616 /* Inserts a parameter into the builtin database */
 617 int insert_builtin_param(param_t * param) {
 618
 619         if (param == NULL)
 620                 return FAILURE;
 621
 622         return splay_insert(param, param->name, builtin_param_tree);
 623 }
 624
 625 /* Inserts a parameter into the builtin database */
 626 int insert_param(param_t * param, splaytree_t * database) {
 627
 628         if (param == NULL)
 629           return FAILURE;
 630         if (database == NULL)
 631           return FAILURE;
 632
 633         return splay_insert(param, param->name, database);
 634 }
 635
 636
 637 /* Sets the parameter engine value to value val.
 638         clipping occurs if necessary */
 639 void set_param(param_t * param, double val) {
 640
 641         switch (param->type) {
 642
 643         case P_TYPE_BOOL:
 644                 if (val < 0)
 645                         *((int*)param->engine_val) = 0;
 646                 else if (val > 0)
 647                         *((int*)param->engine_val) = 1;
 648                 else
 649                         *((int*)param->engine_val) = 0;
 650                 break;
 651         case P_TYPE_INT:
 652                 /* Make sure value is an integer */
 653                 val = floor(val);
 654                 if (val < param->lower_bound.int_val)
 655                                 *((int*)param->engine_val) = param->lower_bound.int_val;
 656                 else if (val > param->upper_bound.int_val)
 657                                 *((int*)param->engine_val) = param->upper_bound.int_val;
 658                 else
 659                                 *((int*)param->engine_val) = val;
 660                 break;
 661         case P_TYPE_DOUBLE:
 662           /* Make sure value is an integer */
 663
 664
 665           if (val < param->lower_bound.double_val)
 666             *((double*)param->engine_val) = param->lower_bound.double_val;
 667           else if (val > param->upper_bound.double_val)
 668             *((double*)param->engine_val) = param->upper_bound.double_val;
 669           else
 670             *((double*)param->engine_val) = val;
 671           break;
 672         default:
 673           break;
 674
 675         }
 676
 677         return;
 678 }
 679
 680
 681
 682
 683 /* Search for parameter 'name' in 'database', if create_flag is true, then generate the parameter
 684    and insert it into 'database' */
 685 param_t * find_param_db(char * name, splaytree_t * database, int create_flag) {
 686
 687   param_t * param = NULL;
 688
 689   /* Null argument checks */
 690   if (name == NULL)
 691     return NULL;
 692   if (database == NULL)
 693     return NULL;
 694
 695   /* First look in the builtin database */
 696   param = (param_t *)splay_find(name, database);
 697
 698
 699   if (((param = (param_t *)splay_find(name, database)) == NULL) && (create_flag == TRUE)) {
 700
 701         /* Check if string is valid */
 702         if (!is_valid_param_string(name))
 703                 return NULL;
 704
 705         /* Now, create the user defined parameter given the passed name */
 706         if ((param = create_user_param(name)) == NULL)
 707                 return NULL;
 708
 709         /* Finally, insert the new parameter into this preset's proper splaytree */
 710         if (splay_insert(param, param->name, database) < 0) {
 711                 free_param(param);
 712                 return NULL;
 713         }
 714
 715   }
 716
 717   /* Return the found (or created) parameter. Note that this could be null */
 718   return param;
 719
 720 }
 721