Make Zorglub less unhappy
[vlc.git] / modules / visualization / galaktos / preset.c
1 /*****************************************************************************
2  * preset.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 #include <stdio.h>
28 #include <string.h>
29 #include <stdlib.h>
30 #include <dirent.h>
31 #include <time.h>
32 #include "common.h"
33 #include "fatal.h"
34
35 #include "preset_types.h"
36 #include "preset.h"
37
38 #include "parser.h"
39
40 #include "expr_types.h"
41 #include "eval.h"
42
43 #include "splaytree_types.h"
44 #include "splaytree.h"
45 #include "tree_types.h"
46
47 #include "per_frame_eqn_types.h"
48 #include "per_frame_eqn.h"
49
50 #include "per_pixel_eqn_types.h"
51 #include "per_pixel_eqn.h"
52
53 #include "init_cond_types.h"
54 #include "init_cond.h"
55
56 #include "param_types.h"
57 #include "param.h"
58
59 #include "func_types.h"
60 #include "func.h"
61
62 #include "custom_wave_types.h"
63 #include "custom_wave.h"
64
65 #include "custom_shape_types.h"
66 #include "custom_shape.h"
67
68 #include "idle_preset.h"
69
70 /* The maximum number of preset names loaded into buffer */
71 #define MAX_PRESETS_IN_DIR 50000
72 extern int per_frame_eqn_count;
73 extern int per_frame_init_eqn_count;
74 //extern int custom_per_frame_eqn_count;
75
76 extern splaytree_t * builtin_param_tree;
77
78 preset_t * active_preset = NULL;
79 preset_t * idle_preset = NULL;
80 FILE * write_stream = NULL;
81
82
83 int preset_index = -1;
84 int preset_name_buffer_size = 0;
85 splaytree_t * chrono_order_preset_name_tree = NULL;
86 int get_preset_path(char ** preset_path_ptr, char * filepath, char * filename);
87 preset_t * load_preset(char * pathname);
88 int is_valid_extension(char * name);    
89 int load_preset_file(char * pathname, preset_t * preset);
90 int close_preset(preset_t * preset);
91
92 int write_preset_name(FILE * fs);
93 int write_per_pixel_equations(FILE * fs);
94 int write_per_frame_equations(FILE * fs);
95 int write_per_frame_init_equations(FILE * fs);
96 int write_init_conditions(FILE * fs);
97 void load_init_cond(param_t * param);
98 void load_init_conditions();
99 void write_init(init_cond_t * init_cond);
100 int init_idle_preset();
101 int destroy_idle_preset();
102 void load_custom_wave_init_conditions();
103 void load_custom_wave_init(custom_wave_t * custom_wave);
104
105 void load_custom_shape_init_conditions();
106 void load_custom_shape_init(custom_shape_t * custom_shape);
107
108 /* loadPresetDir: opens the directory buffer
109    denoted by 'dir' to load presets */
110    
111 int loadPresetDir(char * dir) {
112
113   struct dirent ** name_list;
114   char * preset_name;
115   int i, j, dir_size;
116   
117   if (dir == NULL)
118         return ERROR;
119  
120   if (chrono_order_preset_name_tree != NULL) {
121         if (PRESET_DEBUG) printf("loadPresetDir: previous directory doesn't appear to be closed!\n");
122         /* Let this slide for now */
123   }     
124   
125   /* Scan the entire directory, storing each entry in a dirent struct array that needs 
126      to be freed later. For more information, consult scandir(3) in the man pages */
127   if ((dir_size = scandir(dir, &name_list, 0, alphasort)) < 0) {
128         if (PRESET_DEBUG) printf("loadPresetDir: failed to open directory \"%s\"\n", dir);
129         return ERROR;
130   }
131   
132   chrono_order_preset_name_tree = create_splaytree(compare_int, copy_int, free_int);
133   
134   /* Iterate through entire dirent name list, adding to the preset name list if it
135      is valid */  
136   for (i = 0; ((i < dir_size) && (i < MAX_PRESETS_IN_DIR));i++) {
137
138         /* Only perform the next set of operations if the preset name 
139            contains a valid extension */
140         if (is_valid_extension(name_list[i]->d_name)) {
141                 
142                 /* Handle the out of memory case. My guess is xmms would
143                    crash before this program would, but whatever...*/
144                 if ((preset_name = (char*)malloc(MAX_PATH_SIZE)) == NULL) {
145                         if (PRESET_DEBUG) printf("loadPresetDir: out of memory! \n");
146                         
147                         /* Free the rest of the dirent name list */
148                         for (j = i; j < dir_size; j++) 
149                                 free(name_list[j]);
150                         destroy_splaytree(chrono_order_preset_name_tree);
151                         return OUTOFMEM_ERROR;
152                 }
153                                 
154                 /* Now create the full path */
155             if (get_preset_path(&preset_name, dir, name_list[i]->d_name) < 0) {
156                         if (PRESET_DEBUG) printf("loadPresetDir: failed to generate full preset path name!\n");
157                         
158                         /* Free the rest of the dirent name list */
159                         for (j = i; j < dir_size; j++) 
160                                 free(name_list[j]);
161                         destroy_splaytree(chrono_order_preset_name_tree);
162                         return OUTOFMEM_ERROR;
163                         
164                 }
165                 
166                 /* Insert the character string into the splay tree, with the key being its sequence number */
167                 splay_insert(preset_name, &preset_name_buffer_size, chrono_order_preset_name_tree);
168                 preset_name_buffer_size++;
169         }
170         
171         /* Free the dirent struct */
172         free(name_list[i]);
173         
174   }     
175   
176   free(name_list);
177   
178   /* No valid files in directory! */
179   if (chrono_order_preset_name_tree->root == NULL) {
180         if (PRESET_DEBUG) printf("loadPresetDir: no valid files in directory \"%s\"\n", dir);
181         destroy_splaytree(chrono_order_preset_name_tree);
182         chrono_order_preset_name_tree = NULL;
183         return FAILURE;   
184   }     
185           
186   /* Start the prefix index right before the first entry, so next preset
187      starts at the top of the list */
188   preset_index = -1;
189   
190   /* Start the first preset */
191
192   switchPreset(ALPHA_NEXT, HARD_CUT);
193   
194   return SUCCESS;
195 }
196
197 /* closePresetDir: closes the current
198    preset directory buffer */
199
200 int closePresetDir() {
201
202   /* No preset director appears to be loaded */ 
203   if (chrono_order_preset_name_tree == NULL) 
204     return SUCCESS;
205   
206   if (PRESET_DEBUG) {
207          printf("closePresetDir: freeing directory buffer...");
208          fflush(stdout);
209   }  
210   
211   /* Free each entry in the directory preset name tree */
212   splay_traverse(free_int, chrono_order_preset_name_tree);
213   
214   /* Destroy the chronological order splay tree */
215   destroy_splaytree(chrono_order_preset_name_tree);
216   chrono_order_preset_name_tree = NULL;
217   preset_name_buffer_size = 0;
218   if (PRESET_DEBUG) printf("finished\n");
219   
220   return SUCCESS;
221 }
222
223
224
225 /* Converts a preset file name to a full path */ 
226 int get_preset_path(char ** preset_path_ptr, char * filepath, char * filename) {
227
228   char * preset_path;
229         
230   /* An insanely paranoid sequence of argument checks */
231   if (preset_path_ptr == NULL)
232         return ERROR;
233   if (*preset_path_ptr == NULL)
234     return ERROR;
235   if (filename == NULL)
236         return ERROR;
237   if (filepath == NULL)
238         return ERROR;
239   
240   /* Mostly here for looks */
241   preset_path = *preset_path_ptr;
242
243   /* Clear the name space first */
244   memset(preset_path, 0, MAX_PATH_SIZE);
245   
246   /* Now create the string "PATH/FILENAME", where path is either absolute or relative location
247      of the .milk file, and filename is the name of the preset file itself */
248   strcat(
249         strcat(
250                 strncpy(
251                         preset_path, 
252                     filepath, 
253             MAX_PATH_SIZE-1),   
254         "/"), 
255     filename);  
256
257   return SUCCESS;
258 }       
259
260 /* switchPreset: loads the next preset from the directory stream.
261    loadPresetDir() must be called first. This is a
262    sequential load function */
263
264 int switchPreset(switch_mode_t switch_mode, int cut_type) {
265
266   preset_t * new_preset;
267         
268   int switch_index;
269         
270   /* Make sure a preset directory list is in the buffer */
271   if (chrono_order_preset_name_tree == NULL) {
272     if (PRESET_DEBUG) printf("switchPreset: it helps if you open a directory first with a loadPresetDir() call\n");
273     return ERROR;
274   }
275   
276   
277   switch (switch_mode) {
278           
279   case ALPHA_NEXT:
280   /* An index variable that iterates through the directory
281      buffer, doing wrap around when it reaches the end of
282          the buffer */
283   
284   if (preset_index == (preset_name_buffer_size - 1))
285                 switch_index = preset_index = 0;
286   else  
287                 switch_index = ++preset_index;
288   break;
289
290   case ALPHA_PREVIOUS:
291           
292   if (preset_index == 0)
293                 switch_index = preset_index = preset_name_buffer_size - 1;
294   else  
295                 switch_index = --preset_index;
296   break;
297   
298   case RANDOM_NEXT:
299         switch_index = (int) (preset_name_buffer_size*(rand()/(RAND_MAX+1.0)));
300         break;
301   case RESTART_ACTIVE:
302         switch_index = preset_index;
303         break;
304   default:
305         return FAILURE;
306   }
307   
308     
309   /* Finally, load the preset using its actual path */
310   if ((new_preset = load_preset((char*)splay_find(&switch_index, chrono_order_preset_name_tree))) == NULL) {
311         if (PRESET_DEBUG) printf("switchPreset: failed to load preset\n");
312         return ERROR;
313   }
314
315   /* Closes a preset currently loaded, if any */
316   if ((active_preset != NULL) && (active_preset != idle_preset))
317     close_preset(active_preset);
318
319   /* Sets global active_preset pointer */
320   active_preset = new_preset;
321
322  
323   /* Reinitialize the engine variables to sane defaults */
324   reset_engine_vars();
325
326   /* Add any missing initial conditions */
327   load_init_conditions();
328
329   /* Add any missing initial conditions for each wave */
330   load_custom_wave_init_conditions();
331
332 /* Add any missing initial conditions for each shape */
333   load_custom_shape_init_conditions();
334
335   /* Need to evaluate the initial conditions once */
336   evalInitConditions();
337
338  
339   //  evalInitPerFrameEquations();
340   return SUCCESS;
341 }
342
343 /* Loads a specific preset by absolute path */
344 int loadPresetByFile(char * filename) {
345
346   preset_t * new_preset;
347  
348   /* Finally, load the preset using its actual path */
349   if ((new_preset = load_preset(filename)) == NULL) {
350         if (PRESET_DEBUG) printf("loadPresetByFile: failed to load preset!\n");
351         return ERROR;     
352   }
353
354   /* Closes a preset currently loaded, if any */
355   if ((active_preset != NULL) && (active_preset != idle_preset))
356     close_preset(active_preset); 
357
358   /* Sets active preset global pointer */
359   active_preset = new_preset;
360
361   /* Reinitialize engine variables */
362   reset_engine_vars();
363
364  
365   /* Add any missing initial conditions for each wave */
366   load_custom_wave_init_conditions();
367
368  /* Add any missing initial conditions for each wave */
369   load_custom_shape_init_conditions();
370
371   /* Add any missing initial conditions */
372   load_init_conditions();
373   
374   /* Need to do this once for menu */
375   evalInitConditions();
376   //  evalPerFrameInitEquations();
377   return SUCCESS;
378
379 }
380
381 int init_idle_preset() {
382
383   preset_t * preset;
384   int i;
385
386     /* Initialize idle preset struct */
387   if ((preset = (preset_t*)malloc(sizeof(preset_t))) == NULL)
388     return FAILURE;
389
390   
391   strncpy(preset->name, "idlepreset", strlen("idlepreset"));
392
393   /* Initialize equation trees */
394   preset->init_cond_tree = create_splaytree(compare_string, copy_string, free_string);
395   preset->user_param_tree = create_splaytree(compare_string, copy_string, free_string);
396   preset->per_frame_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
397   preset->per_pixel_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
398   preset->per_frame_init_eqn_tree = create_splaytree(compare_string, copy_string, free_string);
399   preset->custom_wave_tree = create_splaytree(compare_int, copy_int, free_int);
400   preset->custom_shape_tree = create_splaytree(compare_int, copy_int, free_int);
401  
402   /* Set file path to dummy name */  
403   strncpy(preset->file_path, "IDLE PRESET", MAX_PATH_SIZE-1);
404   
405   /* Set initial index values */
406   preset->per_pixel_eqn_string_index = 0;
407   preset->per_frame_eqn_string_index = 0;
408   preset->per_frame_init_eqn_string_index = 0;
409   memset(preset->per_pixel_flag, 0, sizeof(int)*NUM_OPS);
410   
411   /* Clear string buffers */
412   memset(preset->per_pixel_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
413   memset(preset->per_frame_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
414   memset(preset->per_frame_init_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
415
416   idle_preset = preset;
417   
418   return SUCCESS;
419 }
420
421 int destroy_idle_preset() {
422
423   return close_preset(idle_preset);
424   
425 }
426
427 /* initPresetLoader: initializes the preset
428    loading library. this should be done before
429    any parsing */
430 int initPresetLoader() {
431
432   /* Initializes the builtin parameter database */
433   init_builtin_param_db();
434
435   /* Initializes the builtin function database */
436   init_builtin_func_db();
437         
438   /* Initializes all infix operators */
439   init_infix_ops();
440
441   /* Set the seed to the current time in seconds */
442   srand(time(NULL));
443
444   /* Initialize the 'idle' preset */
445   init_idle_preset();
446
447  
448
449   reset_engine_vars();
450
451   active_preset = idle_preset;
452   load_init_conditions();
453
454   /* Done */
455   if (PRESET_DEBUG) printf("initPresetLoader: finished\n");
456   return SUCCESS;
457 }
458
459 /* Sort of experimental code here. This switches
460    to a hard coded preset. Useful if preset directory
461    was not properly loaded, or a preset fails to parse */
462
463 void switchToIdlePreset() {
464
465
466   /* Idle Preset already activated */
467   if (active_preset == idle_preset)
468     return;
469
470
471   /* Close active preset */
472   if (active_preset != NULL)
473     close_preset(active_preset);
474
475   /* Sets global active_preset pointer */
476   active_preset = idle_preset;
477
478   /* Reinitialize the engine variables to sane defaults */
479   reset_engine_vars();
480
481   /* Add any missing initial conditions */
482   load_init_conditions();
483
484   /* Need to evaluate the initial conditions once */
485   evalInitConditions();
486
487 }
488
489 /* destroyPresetLoader: closes the preset
490    loading library. This should be done when 
491    projectM does cleanup */
492
493 int destroyPresetLoader() {
494   
495   if ((active_preset != NULL) && (active_preset != idle_preset)) {      
496         close_preset(active_preset);      
497   }     
498
499   active_preset = NULL;
500   
501   destroy_idle_preset();
502   destroy_builtin_param_db();
503   destroy_builtin_func_db();
504   destroy_infix_ops();
505
506   return SUCCESS;
507
508 }
509
510 /* load_preset_file: private function that loads a specific preset denoted
511    by the given pathname */
512 int load_preset_file(char * pathname, preset_t * preset) { 
513   FILE * fs;
514   int retval;
515
516   if (pathname == NULL)
517           return FAILURE;
518   if (preset == NULL)
519           return FAILURE;
520   
521   /* Open the file corresponding to pathname */
522   if ((fs = fopen(pathname, "r")) == 0) {
523     if (PRESET_DEBUG) printf("load_preset_file: loading of file %s failed!\n", pathname);
524     return ERROR;       
525   }
526
527   if (PRESET_DEBUG) printf("load_preset_file: file stream \"%s\" opened successfully\n", pathname);
528
529   /* Parse any comments */
530   if (parse_top_comment(fs) < 0) {
531     if (PRESET_DEBUG) printf("load_preset_file: no left bracket found...\n");
532     fclose(fs);
533     return FAILURE;
534   }
535   
536   /* Parse the preset name and a left bracket */
537   if (parse_preset_name(fs, preset->name) < 0) {
538     if (PRESET_DEBUG) printf("load_preset_file: loading of preset name in file \"%s\" failed\n", pathname);
539     fclose(fs);
540     return ERROR;
541   }
542   
543   if (PRESET_DEBUG) printf("load_preset_file: preset \"%s\" parsed\n", preset->name);
544
545   /* Parse each line until end of file */
546   if (PRESET_DEBUG) printf("load_preset_file: beginning line parsing...\n");
547   while ((retval = parse_line(fs, preset)) != EOF) {
548     if (retval == PARSE_ERROR) {
549       if (PRESET_DEBUG > 1) printf("load_preset_file: parse error in file \"%s\"\n", pathname);
550     }
551   }
552   
553   if (PRESET_DEBUG) printf("load_preset_file: finished line parsing successfully\n"); 
554
555   /* Now the preset has been loaded.
556      Evaluation calls can be made at appropiate
557      times in the frame loop */
558   
559   fclose(fs);
560    
561   if (PRESET_DEBUG) printf("load_preset_file: file \"%s\" closed, preset ready\n", pathname);
562   return SUCCESS;
563   
564 }
565
566 void evalInitConditions() {
567   splay_traverse(eval_init_cond, active_preset->init_cond_tree);
568   splay_traverse(eval_init_cond, active_preset->per_frame_init_eqn_tree);
569 }
570
571 void evalPerFrameEquations() {
572   splay_traverse(eval_per_frame_eqn, active_preset->per_frame_eqn_tree);
573 }
574
575 void evalPerFrameInitEquations() {
576   //printf("evalPerFrameInitEquations: per frame init unimplemented!\n");
577   //  splay_traverse(eval_per_frame_eqn, active_preset->per_frame_init_eqn_tree);
578 }       
579
580 /* Returns nonzero if string 'name' contains .milk or
581    (the better) .prjm extension. Not a very strong function currently */
582 int is_valid_extension(char * name) {
583
584         if (PRESET_DEBUG > 1) {
585                 printf("is_valid_extension: scanning string \"%s\"...", name);
586                 fflush(stdout);
587         }
588
589         if (strstr(name, MILKDROP_FILE_EXTENSION)) {
590                         if (PRESET_DEBUG > 1) printf("\".milk\" extension found in string [true]\n");
591                         return TRUE;
592         }       
593         
594         if (strstr(name, PROJECTM_FILE_EXTENSION)) {
595                     if (PRESET_DEBUG > 1) printf("\".prjm\" extension found in string [true]\n");
596                         return TRUE;
597         }
598          
599         if (PRESET_DEBUG > 1) printf("no valid extension found [false]\n");
600         return FALSE;
601 }
602
603 /* Private function to close a preset file */
604 int close_preset(preset_t * preset) {
605
606   if (preset == NULL)
607     return FAILURE;
608
609
610   splay_traverse(free_init_cond, preset->init_cond_tree);
611   destroy_splaytree(preset->init_cond_tree);
612   
613   splay_traverse(free_init_cond, preset->per_frame_init_eqn_tree);
614   destroy_splaytree(preset->per_frame_init_eqn_tree);
615   
616   splay_traverse(free_per_pixel_eqn, preset->per_pixel_eqn_tree);
617   destroy_splaytree(preset->per_pixel_eqn_tree);
618   
619   splay_traverse(free_per_frame_eqn, preset->per_frame_eqn_tree);
620   destroy_splaytree(preset->per_frame_eqn_tree);
621   
622   splay_traverse(free_param, preset->user_param_tree);
623   destroy_splaytree(preset->user_param_tree);
624   
625   splay_traverse(free_custom_wave, preset->custom_wave_tree);
626   destroy_splaytree(preset->custom_wave_tree);
627
628   splay_traverse(free_custom_shape, preset->custom_shape_tree);
629   destroy_splaytree(preset->custom_shape_tree);
630
631   free(preset); 
632   
633   return SUCCESS;
634
635 }
636
637 void reloadPerPixel(char *s, preset_t * preset) {
638   
639   FILE * fs;
640   int slen;
641   char c;
642   int i;
643
644   if (s == NULL)
645     return;
646
647   if (preset == NULL)
648     return;
649
650   /* Clear previous per pixel equations */
651   splay_traverse(free_per_pixel_eqn, preset->per_pixel_eqn_tree);
652   destroy_splaytree(preset->per_pixel_eqn_tree);
653   preset->per_pixel_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
654
655   /* Convert string to a stream */
656   fs = fmemopen (s, strlen(s), "r");
657
658   while ((c = fgetc(fs)) != EOF) {
659     ungetc(c, fs);
660     parse_per_pixel_eqn(fs, preset);
661   }
662
663   fclose(fs);
664
665   /* Clear string space */
666   memset(preset->per_pixel_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
667
668   /* Compute length of string */
669   slen = strlen(s);
670
671   /* Copy new string into buffer */
672   strncpy(preset->per_pixel_eqn_string_buffer, s, slen);
673
674   /* Yet again no bounds checking */
675   preset->per_pixel_eqn_string_index = slen;
676
677   /* Finished */
678  
679   return;
680 }
681
682 /* Obviously unwritten */
683 void reloadPerFrameInit(char *s, preset_t * preset) {
684
685 }
686
687 void reloadPerFrame(char * s, preset_t * preset) {
688
689   FILE * fs;
690   int slen;
691   char c;
692   int eqn_count = 1;
693   per_frame_eqn_t * per_frame;
694
695   if (s == NULL)
696     return;
697
698   if (preset == NULL)
699     return;
700
701   /* Clear previous per frame equations */
702   splay_traverse(free_per_frame_eqn, preset->per_frame_eqn_tree);
703   destroy_splaytree(preset->per_frame_eqn_tree);
704   preset->per_frame_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
705
706   /* Convert string to a stream */
707   fs = fmemopen (s, strlen(s), "r");
708
709   while ((c = fgetc(fs)) != EOF) {
710     ungetc(c, fs);
711     if ((per_frame = parse_per_frame_eqn(fs, eqn_count, preset)) != NULL) {
712       splay_insert(per_frame, &eqn_count, preset->per_frame_eqn_tree);
713       eqn_count++;
714     }
715   }
716
717   fclose(fs);
718
719   /* Clear string space */
720   memset(preset->per_frame_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
721
722   /* Compute length of string */
723   slen = strlen(s);
724
725   /* Copy new string into buffer */
726   strncpy(preset->per_frame_eqn_string_buffer, s, slen);
727
728   /* Yet again no bounds checking */
729   preset->per_frame_eqn_string_index = slen;
730
731   /* Finished */
732   printf("reloadPerFrame: %d eqns parsed succesfully\n", eqn_count-1);
733   return;
734
735 }
736
737 preset_t * load_preset(char * pathname) {
738
739   preset_t * preset;
740   int i;
741
742   /* Initialize preset struct */
743   if ((preset = (preset_t*)malloc(sizeof(preset_t))) == NULL)
744     return NULL;
745    
746   /* Initialize equation trees */
747   preset->init_cond_tree = create_splaytree(compare_string, copy_string, free_string);
748   preset->user_param_tree = create_splaytree(compare_string, copy_string, free_string);
749   preset->per_frame_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
750   preset->per_pixel_eqn_tree = create_splaytree(compare_int, copy_int, free_int);
751   preset->per_frame_init_eqn_tree = create_splaytree(compare_string, copy_string, free_string);
752   preset->custom_wave_tree = create_splaytree(compare_int, copy_int, free_int);
753   preset->custom_shape_tree = create_splaytree(compare_int, copy_int, free_int);
754
755   memset(preset->per_pixel_flag, 0, sizeof(int)*NUM_OPS);
756
757   /* Copy file path */  
758   strncpy(preset->file_path, pathname, MAX_PATH_SIZE-1);
759   
760   /* Set initial index values */
761   preset->per_pixel_eqn_string_index = 0;
762   preset->per_frame_eqn_string_index = 0;
763   preset->per_frame_init_eqn_string_index = 0;
764   
765   
766   /* Clear string buffers */
767   memset(preset->per_pixel_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
768   memset(preset->per_frame_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
769   memset(preset->per_frame_init_eqn_string_buffer, 0, STRING_BUFFER_SIZE);
770   
771   
772   if (load_preset_file(pathname, preset) < 0) {
773         if (PRESET_DEBUG) printf("load_preset: failed to load file \"%s\"\n", pathname);
774         close_preset(preset);
775         return NULL;
776   }
777
778   /* It's kind of ugly to reset these values here. Should definitely be placed in the parser somewhere */
779   per_frame_eqn_count = 0;
780   per_frame_init_eqn_count = 0;
781
782   /* Finished, return new preset */
783   return preset;
784 }
785
786 void savePreset(char * filename) {
787
788   FILE * fs;
789
790   if (filename == NULL)
791     return;
792   
793   /* Open the file corresponding to pathname */
794   if ((fs = fopen(filename, "w+")) == 0) {
795     if (PRESET_DEBUG) printf("savePreset: failed to create filename \"%s\"!\n", filename);
796     return;     
797   }
798
799   write_stream = fs;
800
801   if (write_preset_name(fs) < 0) {
802     write_stream = NULL;
803     fclose(fs);
804     return;
805   }
806
807   if (write_init_conditions(fs) < 0) {
808     write_stream = NULL;
809     fclose(fs);
810     return;
811   }
812
813   if (write_per_frame_init_equations(fs) < 0) {
814     write_stream = NULL;
815     fclose(fs);
816     return;
817   }
818
819   if (write_per_frame_equations(fs) < 0) {
820     write_stream = NULL;
821     fclose(fs);
822     return;
823   }
824
825   if (write_per_pixel_equations(fs) < 0) {
826     write_stream = NULL;
827     fclose(fs);
828     return;
829   }
830  
831   write_stream = NULL;
832   fclose(fs);
833
834 }
835
836 int write_preset_name(FILE * fs) {
837
838   char s[256];
839   int len;
840
841   memset(s, 0, 256);
842
843   if (fs == NULL)
844     return FAILURE;
845
846   /* Format the preset name in a string */
847   sprintf(s, "[%s]\n", active_preset->name);
848
849   len = strlen(s);
850
851   /* Write preset name to file stream */
852   if (fwrite(s, 1, len, fs) != len)
853     return FAILURE;
854
855   return SUCCESS;
856
857 }
858
859 int write_init_conditions(FILE * fs) {
860
861   if (fs == NULL)
862     return FAILURE;
863   if (active_preset == NULL)
864     return FAILURE;
865
866
867   splay_traverse(write_init, active_preset->init_cond_tree);
868   
869   return SUCCESS;
870 }
871
872 void write_init(init_cond_t * init_cond) {
873
874   char s[512];
875   int len;
876
877   if (write_stream == NULL)
878     return;
879
880   memset(s, 0, 512);
881
882   if (init_cond->param->type == P_TYPE_BOOL)
883     sprintf(s, "%s=%d\n", init_cond->param->name, init_cond->init_val.bool_val);
884
885   else if (init_cond->param->type == P_TYPE_INT)    
886     sprintf(s, "%s=%d\n", init_cond->param->name, init_cond->init_val.int_val);
887
888   else if (init_cond->param->type == P_TYPE_DOUBLE)
889     sprintf(s, "%s=%f\n", init_cond->param->name, init_cond->init_val.double_val);
890
891   else { printf("write_init: unknown parameter type!\n"); return; }
892   
893   len = strlen(s);
894
895   if ((fwrite(s, 1, len, write_stream)) != len)
896     printf("write_init: failed writing to file stream! Out of disk space?\n");
897   
898 }
899
900
901 int write_per_frame_init_equations(FILE * fs) {
902
903   int len;
904
905   if (fs == NULL)
906     return FAILURE;
907   if (active_preset == NULL)
908     return FAILURE;
909   
910   len = strlen(active_preset->per_frame_init_eqn_string_buffer);
911
912   if (fwrite(active_preset->per_frame_init_eqn_string_buffer, 1, len, fs) != len)
913     return FAILURE;
914
915   return SUCCESS;
916 }
917
918
919 int write_per_frame_equations(FILE * fs) {
920
921   int len;
922
923   if (fs == NULL)
924     return FAILURE;
925   if (active_preset == NULL)
926     return FAILURE;
927
928   len = strlen(active_preset->per_frame_eqn_string_buffer);
929
930   if (fwrite(active_preset->per_frame_eqn_string_buffer, 1, len, fs) != len)
931     return FAILURE;
932
933   return SUCCESS;
934 }
935
936
937 int write_per_pixel_equations(FILE * fs) {
938
939   int len;
940
941   if (fs == NULL)
942     return FAILURE;
943   if (active_preset == NULL)
944     return FAILURE;
945
946   len = strlen(active_preset->per_pixel_eqn_string_buffer);
947
948   if (fwrite(active_preset->per_pixel_eqn_string_buffer, 1, len, fs) != len)
949     return FAILURE;
950
951   return SUCCESS;
952 }
953
954
955 void load_init_conditions() {
956
957   splay_traverse(load_init_cond, builtin_param_tree);
958
959  
960 }
961
962 void load_init_cond(param_t * param) {
963
964   init_cond_t * init_cond;
965   value_t init_val;
966
967   /* Don't count read only parameters as initial conditions */
968   if (param->flags & P_FLAG_READONLY)
969     return;
970
971   /* If initial condition was not defined by the preset file, force a default one
972      with the following code */
973   if ((init_cond = splay_find(param->name, active_preset->init_cond_tree)) == NULL) {
974     
975     /* Make sure initial condition does not exist in the set of per frame initial equations */
976     if ((init_cond = splay_find(param->name, active_preset->per_frame_init_eqn_tree)) != NULL)
977       return;
978     
979     if (param->type == P_TYPE_BOOL)
980       init_val.bool_val = 0;
981     
982     else if (param->type == P_TYPE_INT)
983       init_val.int_val = *(int*)param->engine_val;
984
985     else if (param->type == P_TYPE_DOUBLE)
986       init_val.double_val = *(double*)param->engine_val;
987
988     //printf("%s\n", param->name);
989     /* Create new initial condition */
990     if ((init_cond = new_init_cond(param, init_val)) == NULL)
991       return;
992     
993     /* Insert the initial condition into this presets tree */
994     if (splay_insert(init_cond, init_cond->param->name, active_preset->init_cond_tree) < 0) {
995       free_init_cond(init_cond);
996       return;
997     }
998     
999   }
1000  
1001 }
1002
1003 void load_custom_wave_init_conditions() {
1004
1005   splay_traverse(load_custom_wave_init, active_preset->custom_wave_tree);
1006
1007 }
1008
1009 void load_custom_wave_init(custom_wave_t * custom_wave) {
1010
1011   load_unspecified_init_conds(custom_wave);
1012
1013 }
1014
1015
1016 void load_custom_shape_init_conditions() {
1017
1018   splay_traverse(load_custom_shape_init, active_preset->custom_shape_tree);
1019
1020 }
1021
1022 void load_custom_shape_init(custom_shape_t * custom_shape) {
1023  
1024   load_unspecified_init_conds_shape(custom_shape);
1025  
1026 }