1 /*****************************************************************************
3 *****************************************************************************
4 * Copyright (C) 2004 VideoLAN
7 * Authors: Cyril Deguet <asmax@videolan.org>
8 * code from projectM http://xmms-projectm.sourceforge.net
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.
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.
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 *****************************************************************************/
34 #include "param_types.h"
35 #include "func_types.h"
36 #include "expr_types.h"
38 #include "engine_vars.h"
39 #include "builtin_funcs.h"
42 /* All infix operators (except '=') are prototyped here */
43 infix_op_t * infix_add, * infix_minus, * infix_div, * infix_mult,
44 * infix_or, * infix_and, * infix_mod, * infix_negative, * infix_positive;
45 int mesh_i=-1, mesh_j=-1;
47 static inline double eval_tree_expr(tree_expr_t * tree_expr);
48 static inline double eval_prefun_expr(prefun_expr_t * prefun_expr);
49 static inline double eval_val_expr(val_expr_t * val_expr);
52 inline double eval_gen_expr(gen_expr_t * gen_expr) {
58 switch(gen_expr->type) {
60 return eval_val_expr(gen_expr->item);
62 l = eval_prefun_expr(gen_expr->item);
63 //if (EVAL_DEBUG) printf("eval_gen_expr: prefix function return value: %f\n", l);
66 return eval_tree_expr(gen_expr->item);
69 printf("eval_gen_expr: general expression matched no cases!\n");
76 /* Evaluates functions in prefix form */
77 static inline double eval_prefun_expr(prefun_expr_t * prefun_expr) {
81 /* This is slightly less than safe, since
82 who knows if the passed argument is valid. For
83 speed purposes we'll go with this */
84 double arg_list[prefun_expr->num_args];
90 /* Evaluate each argument before calling the function itself */
91 for (i = 0; i < prefun_expr->num_args; i++) {
92 arg_list[i] = eval_gen_expr(prefun_expr->expr_list[i]);
94 if (i < (prefun_expr->num_args - 1))
105 /* Now we call the function, passing a list of
106 doubles as its argument */
110 return (prefun_expr->func_ptr)(arg_list);
113 /* Evaluates a value expression */
114 static inline double eval_val_expr(val_expr_t * val_expr) {
116 /* Shouldn't happen */
117 if (val_expr == NULL)
120 /* Value is a constant, return the double value */
121 if (val_expr->type == CONSTANT_TERM_T) {
123 printf("%.4f", val_expr->term.constant);
126 return (val_expr->term.constant);
129 /* Value is variable, dereference it */
130 if (val_expr->type == PARAM_TERM_T) {
131 switch (val_expr->term.param->type) {
135 printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
140 return (double)(*((int*)(val_expr->term.param->engine_val)));
143 printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
148 return (double)(*((int*)(val_expr->term.param->engine_val)));
151 printf("(%s:%.4f)", val_expr->term.param->name, (*((double*)val_expr->term.param->engine_val)));
155 if (val_expr->term.param->matrix_flag | (val_expr->term.param->flags & P_FLAG_ALWAYS_MATRIX)) {
157 return (((double**)val_expr->term.param->matrix)[mesh_i][mesh_j]);
160 return (((double*)val_expr->term.param->matrix)[mesh_i]);
163 return *((double*)(val_expr->term.param->engine_val));
168 /* Unknown type, return failure */
172 /* Evaluates an expression tree */
173 static inline double eval_tree_expr(tree_expr_t * tree_expr) {
175 double left_arg, right_arg;
176 infix_op_t * infix_op;
178 /* Shouldn't happen */
179 if (tree_expr == NULL)
182 /* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
183 if (tree_expr->infix_op == NULL) {
184 if (tree_expr->gen_expr == NULL)
187 return eval_gen_expr(tree_expr->gen_expr);
190 /* Otherwise, this node is an infix operator. Evaluate
193 infix_op = (infix_op_t*)tree_expr->infix_op;
199 left_arg = eval_tree_expr(tree_expr->left);
203 switch (infix_op->type) {
232 right_arg = eval_tree_expr(tree_expr->right);
239 switch (infix_op->type) {
241 return (left_arg + right_arg);
243 return (left_arg - right_arg);
245 return (left_arg * right_arg);
247 if ((int)right_arg == 0) {
249 printf("eval_tree_expr: modulo zero!\n");
253 return ((int)left_arg % (int)right_arg);
255 return ((int)left_arg | (int)right_arg);
257 return ((int)left_arg & (int)right_arg);
259 if (right_arg == 0) {
261 printf("eval_tree_expr: division by zero!\n");
263 return MAX_DOUBLE_SIZE;
265 return (left_arg / right_arg);
268 printf("eval_tree_expr: unknown infix operator!\n");
276 /* Converts a double value to a general expression */
277 gen_expr_t * const_to_expr(double val) {
279 gen_expr_t * gen_expr;
280 val_expr_t * val_expr;
285 if ((val_expr = new_val_expr(CONSTANT_TERM_T, term)) == NULL)
288 gen_expr = new_gen_expr(VAL_T, (void*)val_expr);
290 if (gen_expr == NULL) {
291 free_val_expr(val_expr);
297 /* Converts a regular parameter to an expression */
298 gen_expr_t * param_to_expr(param_t * param) {
300 gen_expr_t * gen_expr = NULL;
301 val_expr_t * val_expr = NULL;
307 /* This code is still a work in progress. We need
308 to figure out if the initial condition is used for
309 each per frame equation or not. I am guessing that
310 it isn't, and it is thusly implemented this way */
312 /* Current guess of true behavior (08/01/03) note from carm
313 First try to use the per_pixel_expr (with cloning).
314 If it is null however, use the engine variable instead. */
316 /* 08/20/03 : Presets are now objects, as well as per pixel equations. This ends up
317 making the parser handle the case where parameters are essentially per pixel equation
322 if ((val_expr = new_val_expr(PARAM_TERM_T, term)) == NULL)
325 if ((gen_expr = new_gen_expr(VAL_T, (void*)val_expr)) == NULL) {
326 free_val_expr(val_expr);
332 /* Converts a prefix function to an expression */
333 gen_expr_t * prefun_to_expr(double (*func_ptr)(), gen_expr_t ** expr_list, int num_args) {
335 gen_expr_t * gen_expr;
336 prefun_expr_t * prefun_expr;
339 /* Malloc a new prefix function expression */
340 prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t));
342 if (prefun_expr == NULL)
345 prefun_expr->num_args = num_args;
346 prefun_expr->func_ptr = func_ptr;
347 prefun_expr->expr_list = expr_list;
349 gen_expr = new_gen_expr(PREFUN_T, (void*)prefun_expr);
351 if (gen_expr == NULL)
352 free_prefun_expr(prefun_expr);
357 /* Creates a new tree expression */
358 tree_expr_t * new_tree_expr(infix_op_t * infix_op, gen_expr_t * gen_expr, tree_expr_t * left, tree_expr_t * right) {
360 tree_expr_t * tree_expr;
361 tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t));
363 if (tree_expr == NULL)
365 tree_expr->infix_op = infix_op;
366 tree_expr->gen_expr = gen_expr;
367 tree_expr->left = left;
368 tree_expr->right = right;
373 /* Creates a new value expression */
374 val_expr_t * new_val_expr(int type, term_t term) {
376 val_expr_t * val_expr;
377 val_expr = (val_expr_t*)malloc(sizeof(val_expr_t));
379 if (val_expr == NULL)
382 val_expr->type = type;
383 val_expr->term = term;
388 /* Creates a new general expression */
389 gen_expr_t * new_gen_expr(int type, void * item) {
391 gen_expr_t * gen_expr;
393 gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t));
394 if (gen_expr == NULL)
396 gen_expr->type = type;
397 gen_expr->item = item;
402 /* Frees a general expression */
403 int free_gen_expr(gen_expr_t * gen_expr) {
405 if (gen_expr == NULL)
408 switch (gen_expr->type) {
410 free_val_expr(gen_expr->item);
413 free_prefun_expr(gen_expr->item);
416 free_tree_expr(gen_expr->item);
428 /* Frees a function in prefix notation */
429 int free_prefun_expr(prefun_expr_t * prefun_expr) {
432 if (prefun_expr == NULL)
435 /* Free every element in expression list */
436 for (i = 0 ; i < prefun_expr->num_args; i++) {
437 free_gen_expr(prefun_expr->expr_list[i]);
444 /* Frees values of type VARIABLE and CONSTANT */
445 int free_val_expr(val_expr_t * val_expr) {
447 if (val_expr == NULL)
454 /* Frees a tree expression */
455 int free_tree_expr(tree_expr_t * tree_expr) {
457 if (tree_expr == NULL)
461 free_tree_expr(tree_expr->left);
463 /* free general expression object */
464 free_gen_expr(tree_expr->gen_expr);
466 /* Note that infix operators are always
467 stored in memory unless the program
468 exits, so we don't remove them here */
470 /* free right tree */
471 free_tree_expr(tree_expr->right);
474 /* finally, free the struct itself */
481 /* Initializes all infix operators */
482 int init_infix_ops() {
484 infix_add = new_infix_op(INFIX_ADD, 4);
485 infix_minus = new_infix_op(INFIX_MINUS, 3);
486 infix_div = new_infix_op(INFIX_DIV, 2);
487 infix_or = new_infix_op(INFIX_OR, 5);
488 infix_and = new_infix_op(INFIX_AND,4);
489 infix_mod = new_infix_op(INFIX_MOD, 1);
490 infix_mult = new_infix_op(INFIX_MULT, 2);
492 /* Prefix operators */
493 infix_positive = new_infix_op(INFIX_ADD, 0);
494 infix_negative = new_infix_op(INFIX_MINUS, 0);
499 /* Destroys the infix operator list. This should
500 be done on program exit */
501 int destroy_infix_ops()
511 free(infix_positive);
512 free(infix_negative);
517 /* Initializes an infix operator */
518 infix_op_t * new_infix_op(int type, int precedence) {
520 infix_op_t * infix_op;
522 infix_op = (infix_op_t*)malloc(sizeof(infix_op_t));
524 if (infix_op == NULL)
527 infix_op->type = type;
528 infix_op->precedence = precedence;
536 /* Clones a general expression */
537 gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {
539 gen_expr_t * new_gen_expr;
540 val_expr_t * val_expr;
541 tree_expr_t * tree_expr;
542 prefun_expr_t * prefun_expr;
544 /* Null argument check */
545 if (gen_expr == NULL)
549 if ((new_gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t))) == NULL)
552 /* Case on the type of general expression */
553 switch (new_gen_expr->type = gen_expr->type) {
555 case VAL_T: /* val expression */
556 if ((val_expr = clone_val_expr((val_expr_t*)gen_expr->item)) == NULL) {
560 new_gen_expr->item = (void*)val_expr;
563 case PREFUN_T: /* prefix function expression */
564 if ((prefun_expr = clone_prefun_expr((prefun_expr_t*)gen_expr->item)) == NULL) {
568 new_gen_expr->item = (void*)prefun_expr;
571 case TREE_T: /* tree expression */
572 if ((tree_expr = clone_tree_expr((tree_expr_t*)gen_expr->item)) == NULL) {
576 new_gen_expr->item = (void*)tree_expr;
579 default: /* unknown type, ut oh.. */
584 return new_gen_expr; /* Return the new (cloned) general expression */
588 /* Clones a tree expression */
589 tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr) {
591 tree_expr_t * new_tree_expr;
594 if (tree_expr == NULL)
598 if ((new_tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t))) == NULL)
601 /* Set each argument in tree_expr_t struct */
602 new_tree_expr->infix_op = tree_expr->infix_op; /* infix operators are in shared memory */
603 new_tree_expr->gen_expr = clone_gen_expr(tree_expr->gen_expr); /* clone the general expression */
604 new_tree_expr->left = clone_tree_expr(tree_expr->left); /* clone the left tree expression */
605 new_tree_expr->right = clone_tree_expr(tree_expr->right); /* clone the right tree expression */
607 return new_tree_expr; /* Return the new (cloned) tree expression */
610 /* Clones a value expression, currently only passes the pointer to
611 the value that this object represents, not a pointer to a copy of the value */
612 val_expr_t * clone_val_expr(val_expr_t * val_expr) {
614 val_expr_t * new_val_expr;
617 if (val_expr == NULL)
620 /* Allocate space, check for out of memory */
621 if ((new_val_expr = (val_expr_t*)malloc(sizeof(val_expr_t))) == NULL)
624 /* Set the values in the val_expr_t struct */
625 new_val_expr->type = val_expr->type;
626 new_val_expr->term = val_expr->term;
628 /* Return the new (cloned) value expression */
632 /* Clones a prefix function with its arguments */
633 prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr) {
636 prefun_expr_t * new_prefun_expr;
639 if (prefun_expr == NULL)
643 if ((new_prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t))) == NULL)
646 /* Set the function argument paired with its number of arguments */
647 new_prefun_expr->num_args = prefun_expr->num_args;
648 new_prefun_expr->func_ptr = prefun_expr->func_ptr;
650 /* Allocate space for the expression list pointers */
651 if ((new_prefun_expr->expr_list = (gen_expr_t**)malloc(sizeof(gen_expr_t*)*new_prefun_expr->num_args)) == NULL) {
652 free(new_prefun_expr);
656 /* Now copy each general expression from the argument expression list */
657 for (i = 0; i < new_prefun_expr->num_args;i++)
658 new_prefun_expr->expr_list[i] = clone_gen_expr(prefun_expr->expr_list[i]);
660 /* Finally, return the new (cloned) prefix function expression */
661 return new_prefun_expr;
664 /* Reinitializes the engine variables to a default (conservative and sane) value */
665 void reset_engine_vars() {
726 /* PER_FRAME CONSTANTS END */
729 fVideoEchoZoom = 1.0;
731 nVideoEchoOrientation = 0;
737 bModWaveAlphaByVolume = 0;
738 bMaximizeWaveColor = 0;
746 bMotionVectorsOn = 1;
752 fModWaveAlphaStart = 0;
753 fModWaveAlphaEnd = 0;
759 /* PER_PIXEL CONSTANTS BEGIN */
765 /* PER_PIXEL CONSTANT END */
768 /* Q VARIABLES START */
780 /* Q VARIABLES END */