开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
custom_wave.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：21k
源码类别：

midi

开发平台：

Unix_Linux

custom_wave.c：源码内容
  1. /*****************************************************************************
  2.  * custom_wave.c:
  3.  *****************************************************************************
  4.  * Copyright (C) 2004 the VideoLAN team
  5.  * $Id: 8ccb9573cf57f865680be604959678b9e30c3183 $
  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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  29. #include "common.h"
  30. #include "fatal.h"
  32. #include "param_types.h"
  33. #include "param.h"
  35. #include "expr_types.h"
  36. #include "eval.h"
  38. #include "splaytree_types.h"
  39. #include "splaytree.h"
  40. #include "tree_types.h"
  42. #include "per_frame_eqn_types.h"
  43. #include "per_frame_eqn.h"
  45. #include "init_cond_types.h"
  46. #include "init_cond.h"
  48. #include "preset_types.h"
  50. #include "custom_wave_types.h"
  51. #include "custom_wave.h"
  53. #include "init_cond_types.h"
  54. #include "init_cond.h"
  56. #include "engine_vars.h"
  57. #define MAX_SAMPLE_SIZE 4096
  59. extern int mesh_i;
  61. custom_wave_t * interface_wave = NULL;
  62. int interface_id = 0;
  63. extern preset_t * active_preset;
  64. static inline void eval_custom_wave_init_conds(custom_wave_t * custom_wave);
  65. void load_unspec_init_cond(param_t * param);
  66. void destroy_per_point_eqn_tree(splaytree_t * tree);
  67. void destroy_param_db_tree(splaytree_t * tree);
  68. void destroy_per_frame_eqn_tree(splaytree_t * tree);
  69. void destroy_per_frame_init_eqn_tree(splaytree_t * tree);
  70. void destroy_init_cond_tree(splaytree_t * tree);
  71. static inline void evalPerPointEqn(per_point_eqn_t * per_point_eqn);
  73. custom_wave_t * new_custom_wave(int id) {
  75.   custom_wave_t * custom_wave;
  76.   param_t * param;
  77.   
  78.   if ((custom_wave = (custom_wave_t*)malloc(sizeof(custom_wave_t))) == NULL)
  79.     return NULL;
  81.   custom_wave->id = id;
  82.   custom_wave->per_frame_count = 0;
  84.   custom_wave->samples = 512;
  85.   custom_wave->bSpectrum = 0;
  86.   custom_wave->enabled = 1;
  87.   custom_wave->sep = 1;
  88.   custom_wave->smoothing = 0.0;
  89.   custom_wave->bUseDots = 0;
  90.   custom_wave->bAdditive = 0;
  91.   custom_wave->r = custom_wave->g = custom_wave->b = custom_wave->a = 0.0;
  92.   custom_wave->scaling = 1.0;
  93.   custom_wave->per_frame_eqn_string_index = 0;
  94.   custom_wave->per_frame_init_eqn_string_index = 0;
  95.   custom_wave->per_point_eqn_string_index = 0;
  97.   custom_wave->r_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  98.   custom_wave->g_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  99.   custom_wave->b_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  100.   custom_wave->a_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  101.   custom_wave->x_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  102.   custom_wave->y_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  103.   custom_wave->value1 = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  104.   custom_wave->value2 = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  105.   custom_wave->sample_mesh = malloc(MAX_SAMPLE_SIZE*sizeof(double));
  107.   /* Initialize tree data structures */
  108.   
  109.   if ((custom_wave->param_tree = 
  110.        create_splaytree(compare_string, copy_string, free_string)) == NULL) {
  111.     free_custom_wave(custom_wave);
  112.     return NULL;
  113.   }
  115.   if ((custom_wave->per_point_eqn_tree = 
  116.        create_splaytree(compare_int, copy_int, free_int)) == NULL) {
  117.     free_custom_wave(custom_wave);
  118.     return NULL;
  119.   }
  121.   if ((custom_wave->per_frame_eqn_tree = 
  122.        create_splaytree(compare_int, copy_int, free_int)) == NULL) {
  123.     free_custom_wave(custom_wave);
  124.     return NULL;
  125.   }
  127.   if ((custom_wave->init_cond_tree = 
  128.        create_splaytree(compare_string, copy_string, free_string)) == NULL) {
  129.     free_custom_wave(custom_wave);
  130.     return NULL;
  131.   }
  132.   
  133.   if ((custom_wave->per_frame_init_eqn_tree = 
  134.        create_splaytree(compare_string, copy_string, free_string)) == NULL) {
  135.     free_custom_wave(custom_wave);
  136.     return NULL;
  137.   }
  139.   
  140.   /* Start: Load custom wave parameters */
  142.   if ((param = new_param_double("r", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->r, custom_wave->r_mesh, 1.0, 0.0, .5)) == NULL) {
  143.     free_custom_wave(custom_wave);
  144.     return NULL;
  145.   }
  147.   if (insert_param(param, custom_wave->param_tree) < 0) {
  148.     free_custom_wave(custom_wave);
  149.     return NULL;
  150.   }
  151.  
  152.   if ((param = new_param_double("g", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->g,  custom_wave->g_mesh, 1.0, 0.0, .5)) == NULL){
  153.     free_custom_wave(custom_wave);
  154.     return NULL;
  155.   }
  157.   if (insert_param(param, custom_wave->param_tree) < 0) {
  158.     free_custom_wave(custom_wave);
  159.     return NULL;
  160.   }
  162.   if ((param = new_param_double("b", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->b,  custom_wave->b_mesh, 1.0, 0.0, .5)) == NULL){
  163.     free_custom_wave(custom_wave);
  164.     return NULL;        
  165.   }
  167.   if (insert_param(param, custom_wave->param_tree) < 0) {
  168.     free_custom_wave(custom_wave);
  169.     return NULL;
  170.   }
  172.   if ((param = new_param_double("a", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->a,  custom_wave->a_mesh, 1.0, 0.0, .5)) == NULL){
  173.     free_custom_wave(custom_wave);
  174.     return NULL;
  175.   }
  176.   
  177.   if (insert_param(param, custom_wave->param_tree) < 0) {
  178.     free_custom_wave(custom_wave);
  179.     return NULL;
  180.   }
  182.   if ((param = new_param_double("x", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->x,  custom_wave->x_mesh, 1.0, 0.0, .5)) == NULL) {
  183.     free_custom_wave(custom_wave);
  184.     return NULL;
  185.   }
  187.   if (insert_param(param, custom_wave->param_tree) < 0) {
  188.     free_custom_wave(custom_wave);
  189.     return NULL;
  190.   }
  192.   if ((param = new_param_double("y", P_FLAG_DONT_FREE_MATRIX | P_FLAG_PER_POINT, &custom_wave->y,  custom_wave->y_mesh, 1.0, 0.0, .5)) == NULL) {
  193.     free_custom_wave(custom_wave);
  194.     return NULL;
  195.   }
  197.   if (insert_param(param, custom_wave->param_tree) < 0) {
  198.     free_custom_wave(custom_wave);
  199.     return NULL;
  200.   }
  202.   if ((param = new_param_bool("enabled", P_FLAG_NONE, &custom_wave->enabled, 1, 0, 0)) == NULL) {
  203.     free_custom_wave(custom_wave);
  204.     return NULL;
  205.   }
  207.   if (insert_param(param, custom_wave->param_tree) < 0) {
  208.     free_custom_wave(custom_wave);
  209.     return NULL;
  210.   }
  212.   if ((param = new_param_int("sep", P_FLAG_NONE, &custom_wave->sep, 100, -100, 0)) == NULL) {
  213.     free_custom_wave(custom_wave);
  214.     return NULL;
  215.   }
  217.   if (insert_param(param, custom_wave->param_tree) < 0) {
  218.     free_custom_wave(custom_wave);
  219.     return NULL;
  220.   }
  222.   if ((param = new_param_bool("bSpectrum", P_FLAG_NONE, &custom_wave->bSpectrum, 1, 0, 0)) == NULL) {
  223.     free_custom_wave(custom_wave);
  224.     return NULL;
  225.   }
  227.   if (insert_param(param, custom_wave->param_tree) < 0) {
  228.     free_custom_wave(custom_wave);
  229.     return NULL;
  230.   }
  232.   if ((param = new_param_bool("bDrawThick", P_FLAG_NONE, &custom_wave->bDrawThick, 1, 0, 0)) == NULL) {
  233.     free_custom_wave(custom_wave);
  234.     return NULL;
  235.   }
  237.   if (insert_param(param, custom_wave->param_tree) < 0) {
  238.     free_custom_wave(custom_wave);
  239.     return NULL;
  240.   }
  242.   if ((param = new_param_bool("bUseDots", P_FLAG_NONE, &custom_wave->bUseDots, 1, 0, 0)) == NULL) {
  243.     free_custom_wave(custom_wave);
  244.     return NULL;
  245.   }
  247.   if (insert_param(param, custom_wave->param_tree) < 0) {
  248.     free_custom_wave(custom_wave);
  249.     return NULL;
  250.   }
  251.  
  252.   if ((param = new_param_bool("bAdditive", P_FLAG_NONE, &custom_wave->bAdditive, 1, 0, 0)) == NULL) {
  253.     free_custom_wave(custom_wave);
  254.     return NULL;
  255.   }
  257.   if (insert_param(param, custom_wave->param_tree) < 0) {
  258.     free_custom_wave(custom_wave);
  259.     return NULL;
  260.   }
  262.   if ((param = new_param_int("samples", P_FLAG_NONE, &custom_wave->samples, 2048, 1, 512)) == NULL) {
  263.     free_custom_wave(custom_wave);
  264.     return NULL;
  265.   }
  266.  
  267.   if (insert_param(param, custom_wave->param_tree) < 0) {
  268.     free_custom_wave(custom_wave);
  269.     return NULL;
  270.   }
  272.   if ((param = new_param_double("sample", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT,
  273. &custom_wave->sample, custom_wave->sample_mesh, 1.0, 0.0, 0.0)) == NULL) {
  274.     free_custom_wave(custom_wave);
  275.     return NULL;
  276.   }
  277.  
  278.  if (insert_param(param, custom_wave->param_tree) < 0) {
  279.     printf("failed to insert samplen");
  280.     free_custom_wave(custom_wave);
  281.     return NULL;
  282.   }
  284.   if ((param = new_param_double("value1", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT, &custom_wave->v1, custom_wave->value1, 1.0, -1.0, 0.0)) == NULL) {
  285.     free_custom_wave(custom_wave);
  286.     return NULL;
  287.   }
  289.   if (insert_param(param, custom_wave->param_tree) < 0) {
  290.     free_custom_wave(custom_wave);
  291.     return NULL;
  292.   }
  294.   if ((param = new_param_double("value2", P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX | P_FLAG_ALWAYS_MATRIX | P_FLAG_PER_POINT, &custom_wave->v2, custom_wave->value2, 1.0, -1.0, 0.0)) == NULL) {
  295.     free_custom_wave(custom_wave);
  296.     return NULL;
  297.   }
  299.   if (insert_param(param, custom_wave->param_tree) < 0) {
  300.     free_custom_wave(custom_wave);
  301.     return NULL;
  302.   }
  304.   if ((param = new_param_double("smoothing", P_FLAG_NONE, &custom_wave->smoothing, NULL, 1.0, 0.0, 0.0)) == NULL) {
  305.     free_custom_wave(custom_wave);
  306.     return NULL;
  307.   }
  309.   if (insert_param(param, custom_wave->param_tree) < 0) {
  310.     free_custom_wave(custom_wave);
  311.     return NULL;
  312.   }
  314.   if ((param = new_param_double("scaling", P_FLAG_NONE, &custom_wave->scaling, NULL, MAX_DOUBLE_SIZE, 0.0, 1.0)) == NULL) {
  315.     free_custom_wave(custom_wave);
  316.     return NULL;
  317.   }
  319.   if (insert_param(param, custom_wave->param_tree) < 0) {
  320.     free_custom_wave(custom_wave);
  321.     return NULL;
  322.   }
  323.  
  324.   if ((param = new_param_double("t1", P_FLAG_PER_POINT | P_FLAG_TVAR, &custom_wave->t1, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  325.     free_custom_wave(custom_wave);
  326.     return NULL;
  327.   }
  329.   if (insert_param(param, custom_wave->param_tree) < 0) {
  330.     free_custom_wave(custom_wave);
  331.     return NULL;
  332.   }
  334.   if ((param = new_param_double("t2",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t2, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  335.     free_custom_wave(custom_wave);
  336.     return NULL;
  337.   }
  339.   if (insert_param(param, custom_wave->param_tree) < 0) {
  340.     free_custom_wave(custom_wave);
  341.     return NULL;
  342.   }
  344.   if ((param = new_param_double("t3",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t3, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  345.     free_custom_wave(custom_wave);
  346.     return NULL;
  347.   }
  349.   if (insert_param(param, custom_wave->param_tree) < 0) {
  350.     free_custom_wave(custom_wave);
  351.     return NULL;
  352.   }
  353.   if ((param = new_param_double("t4",  P_FLAG_PER_POINT |P_FLAG_TVAR, &custom_wave->t4, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  354.     free_custom_wave(custom_wave);
  355.     return NULL;
  356.   }
  358.   if (insert_param(param, custom_wave->param_tree) < 0) {
  359.     free_custom_wave(custom_wave);
  360.     return NULL;
  361.   }
  362.   if ((param = new_param_double("t5", P_FLAG_TVAR, &custom_wave->t5, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  363.     free_custom_wave(custom_wave);
  364.     return NULL;
  365.   }
  366.  
  367.   if (insert_param(param, custom_wave->param_tree) < 0) {
  368.     free_custom_wave(custom_wave);
  369.     return NULL;
  370.   }
  371.   if ((param = new_param_double("t6", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t6, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  372.     free_custom_wave(custom_wave);
  373.     return NULL;
  374.   }
  376.   if (insert_param(param, custom_wave->param_tree) < 0) {
  377.     free_custom_wave(custom_wave);
  378.     return NULL;
  379.   }
  380.   if ((param = new_param_double("t7", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t7, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  381.     free_custom_wave(custom_wave);
  382.     return NULL;
  383.   }
  385.   if (insert_param(param, custom_wave->param_tree) < 0) {
  386.     free_custom_wave(custom_wave);
  387.     return NULL;
  388.   }
  390.   if ((param = new_param_double("t8", P_FLAG_TVAR | P_FLAG_PER_POINT, &custom_wave->t8, NULL, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, 0.0)) == NULL) {
  391.     free_custom_wave(custom_wave);
  392.     return NULL;
  393.   }
  395.   if (insert_param(param, custom_wave->param_tree) < 0) {
  396.     free_custom_wave(custom_wave);
  397.     return NULL;
  398.   }
  399.   
  400.   /* End of parameter loading. Note that the read only parameters associated
  401.      with custom waves (ie, sample) are global variables, and not specific to 
  402.      the custom wave datastructure. */
  405.   return custom_wave;
  407. }
  409. void destroy_per_frame_init_eqn_tree(splaytree_t * tree) {
  411.   if (!tree)
  412.     return;
  414.   splay_traverse(free_init_cond, tree);
  415.   destroy_splaytree(tree);
  417. }
  420. void destroy_per_point_eqn_tree(splaytree_t * tree) {
  422.   if (!tree)
  423.     return;
  425.   splay_traverse(free_per_point_eqn, tree);
  426.   destroy_splaytree(tree);
  428. }
  430. void destroy_init_cond_tree(splaytree_t * tree) {
  432.   if (!tree)
  433.     return;
  435.   splay_traverse(free_init_cond, tree);
  436.   destroy_splaytree(tree);
  438. }
  440. void destroy_per_frame_eqn_tree(splaytree_t * tree) {
  443.   if (!tree)
  444.     return;
  446.   splay_traverse(free_per_frame_eqn, tree);
  447.   destroy_splaytree(tree);
  449. }
  452. void destroy_param_db_tree(splaytree_t * tree) {
  454.   if (!tree)
  455.     return;
  457.   splay_traverse(free_param, tree);
  458.   destroy_splaytree(tree);
  460. }
  462. /* Frees a custom wave form object */
  463. void free_custom_wave(custom_wave_t * custom_wave) {
  465.   if (custom_wave == NULL)
  466.     return;
  468.   if (custom_wave->param_tree == NULL)
  469.     return;
  471.   destroy_per_point_eqn_tree(custom_wave->per_point_eqn_tree);
  472.   destroy_per_frame_eqn_tree(custom_wave->per_frame_eqn_tree);
  473.   destroy_init_cond_tree(custom_wave->init_cond_tree);
  474.   destroy_param_db_tree(custom_wave->param_tree);
  475.   destroy_per_frame_init_eqn_tree(custom_wave->per_frame_init_eqn_tree);
  477.   free(custom_wave->r_mesh);
  478.   free(custom_wave->g_mesh);
  479.   free(custom_wave->b_mesh);
  480.   free(custom_wave->a_mesh);
  481.   free(custom_wave->x_mesh);
  482.   free(custom_wave->y_mesh);
  483.   free(custom_wave->value1);
  484.   free(custom_wave->value2);
  485.   free(custom_wave->sample_mesh);
  487.   free(custom_wave);
  489.   return;
  491. }
  495. int add_per_point_eqn(char * name, gen_expr_t * gen_expr, custom_wave_t * custom_wave) {
  497.   per_point_eqn_t * per_point_eqn;
  498.   int index;
  499.   param_t * param = NULL;
  501.   /* Argument checks */
  502.   if (custom_wave == NULL)
  503.   return FAILURE;
  504.   if (gen_expr == NULL)
  505.   return FAILURE;
  506.   if (name == NULL)
  507.   return FAILURE;
  508.   
  509.  if (CUSTOM_WAVE_DEBUG) printf("add_per_point_eqn: per pixel equation (name = "%s")n", name);
  511.  /* Search for the parameter so we know what matrix the per pixel equation is referencing */
  513.  if ((param = find_param_db(name, custom_wave->param_tree, TRUE)) == NULL) {
  514.    if (CUSTOM_WAVE_DEBUG) printf("add_per_point_eqn: failed to allocate a new parameter!n");
  515.    return FAILURE;
  516.  
  517.  }   
  519.  /* Find most largest index in the splaytree */
  520.  if ((per_point_eqn = splay_find_max(custom_wave->per_point_eqn_tree)) == NULL)
  521.    index = 0;
  522.  else
  523.    index = per_point_eqn->index+1;
  525.  /* Create the per pixel equation given the index, parameter, and general expression */
  526.  if ((per_point_eqn = new_per_point_eqn(index, param, gen_expr)) == NULL)
  527.  return FAILURE;
  528.  if (CUSTOM_WAVE_DEBUG) 
  529.    printf("add_per_point_eqn: created new equation (index = %d) (name = "%s")n", per_point_eqn->index, per_point_eqn->param->name);
  530.  /* Insert the per pixel equation into the preset per pixel database */
  531.  if (splay_insert(per_point_eqn, &per_point_eqn->index, custom_wave->per_point_eqn_tree) < 0) {
  532. free_per_point_eqn(per_point_eqn);
  533. return FAILURE;  
  534.  }
  535.  
  536.  /* Done */ 
  537.  return SUCCESS;
  538. }
  540. per_point_eqn_t * new_per_point_eqn(int index, param_t * param, gen_expr_t * gen_expr) {
  542. per_point_eqn_t * per_point_eqn;
  544. if (param == NULL)
  545. return NULL;
  546. if (gen_expr == NULL)
  547. return NULL;
  549. if ((per_point_eqn = (per_point_eqn_t*)malloc(sizeof(per_point_eqn_t))) == NULL)
  550. return NULL;
  552.       
  553. per_point_eqn->index = index;
  554. per_point_eqn->gen_expr = gen_expr;
  555. per_point_eqn->param = param;
  556. return per_point_eqn;
  557. }
  560. void free_per_point_eqn(per_point_eqn_t * per_point_eqn) {
  562. if (per_point_eqn == NULL)
  563. return;
  565. free_gen_expr(per_point_eqn->gen_expr);
  567. free(per_point_eqn);
  569. return;
  570. }
  572. custom_wave_t * find_custom_wave(int id, preset_t * preset, int create_flag) {
  574.   custom_wave_t * custom_wave = NULL;
  576.   if (preset == NULL)
  577.     return NULL;
  578.   
  579.   if ((custom_wave = splay_find(&id, preset->custom_wave_tree)) == NULL) {
  581.     if (CUSTOM_WAVE_DEBUG) { printf("find_custom_wave: creating custom wave (id = %d)...", id);fflush(stdout);}
  583.     if (create_flag == FALSE) {
  584.       if (CUSTOM_WAVE_DEBUG) printf("you specified not to (create flag = false), returning nulln");
  585.        return NULL;
  586.     }
  588.     if ((custom_wave = new_custom_wave(id)) == NULL) {
  589.       if (CUSTOM_WAVE_DEBUG) printf("failed...out of memory?n");
  590.       return NULL;
  591.     }
  593.     if  (CUSTOM_WAVE_DEBUG) {printf("success.Inserting..."); fflush(stdout);}
  595.    if (splay_insert(custom_wave, &custom_wave->id, preset->custom_wave_tree) < 0) {
  596.      if (CUSTOM_WAVE_DEBUG) printf("failed!n");
  597.      free_custom_wave(custom_wave);
  598.      return NULL;
  599.     }
  600.  
  601.    if (CUSTOM_WAVE_DEBUG) printf("done.n");
  602.   }
  603.  
  604.   return custom_wave;
  605. }
  607. /* Interface function. Makes another custom wave the current
  608.    concern for per frame / point equations */
  609. custom_wave_t * nextCustomWave() {
  611.   if ((interface_wave = splay_find(&interface_id, active_preset->custom_wave_tree)) == NULL) {
  612.     interface_id = 0;
  613.     return NULL;
  614.   }
  616.   interface_id++;
  618.   /* Evaluate all per frame equations associated with this wave */
  619.   splay_traverse(eval_per_frame_eqn, interface_wave->per_frame_eqn_tree);
  620.   return interface_wave;
  621. }
  624. void evalPerPointEqns() { 
  626.   int x;
  628.   for (x = 0; x < interface_wave->samples; x++)
  629.     interface_wave->r_mesh[x] = interface_wave->r;
  630.   for (x = 0; x < interface_wave->samples; x++)
  631.     interface_wave->g_mesh[x] = interface_wave->g;
  632.   for (x = 0; x < interface_wave->samples; x++)
  633.     interface_wave->b_mesh[x] = interface_wave->b;
  634.   for (x = 0; x < interface_wave->samples; x++)
  635.     interface_wave->a_mesh[x] = interface_wave->a;
  636.   for (x = 0; x < interface_wave->samples; x++)
  637.     interface_wave->x_mesh[x] = interface_wave->x;
  638.   for (x = 0; x < interface_wave->samples; x++)
  639.     interface_wave->y_mesh[x] = interface_wave->y;
  641.  
  642.   /* Evaluate per pixel equations */
  643.   splay_traverse(evalPerPointEqn, interface_wave->per_point_eqn_tree);
  645.   /* Reset index */
  646.   mesh_i = -1;
  647. }
  649. /* Evaluates a per point equation for the current custom wave given by interface_wave ptr */
  650. static inline void evalPerPointEqn(per_point_eqn_t * per_point_eqn) {
  651.   
  652.   
  653.   int samples, size;
  654.   double * param_matrix;
  655.   gen_expr_t * eqn_ptr;
  657.   samples = interface_wave->samples;
  658.   eqn_ptr = per_point_eqn->gen_expr;
  659.  
  660.   if (per_point_eqn->param->matrix == NULL) {
  661.     if ((param_matrix = per_point_eqn->param->matrix = malloc(size = samples*sizeof(double))) == NULL)
  662.       return;
  663.     memset(param_matrix, 0, size);
  664.   }
  665.   else 
  666.     param_matrix = (double*)per_point_eqn->param->matrix;
  667.   
  668.   for (mesh_i = 0; mesh_i < samples; mesh_i++) {    
  669.       param_matrix[mesh_i] = eval_gen_expr(eqn_ptr);
  670.   }
  671.   
  672.   /* Now that this parameter has been referenced with a per
  673.      point equation, we let the evaluator know by setting
  674.      this flag */
  675.   per_point_eqn->param->matrix_flag = 1; 
  677. }
  680. void load_unspecified_init_conds(custom_wave_t * custom_wave) {
  682.   interface_wave = custom_wave;
  683.   splay_traverse(load_unspec_init_cond, interface_wave->param_tree);
  684.   interface_wave = NULL;
  685.  
  686. }
  688. void load_unspec_init_cond(param_t * param) {
  690.   init_cond_t * init_cond;
  691.   value_t init_val;
  693.   /* Don't count these parameters as initial conditions */
  694.   if (param->flags & P_FLAG_READONLY)
  695.     return;
  696.   if (param->flags & P_FLAG_QVAR)
  697.     return;
  698.   if (param->flags & P_FLAG_TVAR)
  699.     return;
  700.   if (param->flags & P_FLAG_USERDEF)
  701.     return;
  703.   /* If initial condition was not defined by the preset file, force a default one
  704.      with the following code */
  705.   if ((init_cond = splay_find(param->name, interface_wave->init_cond_tree)) == NULL) {
  706.     
  707.     /* Make sure initial condition does not exist in the set of per frame initial equations */
  708.     if ((init_cond = splay_find(param->name, interface_wave->per_frame_init_eqn_tree)) != NULL)
  709.       return;
  710.     
  711.     if (param->type == P_TYPE_BOOL)
  712.       init_val.bool_val = 0;
  713.     
  714.     else if (param->type == P_TYPE_INT)
  715.       init_val.int_val = *(int*)param->engine_val;
  717.     else if (param->type == P_TYPE_DOUBLE)
  718.       init_val.double_val = *(double*)param->engine_val;
  720.     //printf("%sn", param->name);
  721.     /* Create new initial condition */
  722.     if ((init_cond = new_init_cond(param, init_val)) == NULL)
  723.       return;
  724.     
  725.     /* Insert the initial condition into this presets tree */
  726.     if (splay_insert(init_cond, init_cond->param->name, interface_wave->init_cond_tree) < 0) {
  727.       free_init_cond(init_cond);
  728.       return;
  729.     }
  730.     
  731.   }
  732.  
  733. }
  735. void evalCustomWaveInitConditions() {
  736.   splay_traverse(eval_custom_wave_init_conds, active_preset->custom_wave_tree);
  737. }