annotate eval.c @ 8520:a0164882aa38 libavcodec

Generic metadata API. avi is updated as example. No version bump, the API still might change slightly ... No update to ffmpeg.c as requested by aurel.
author michael
date Sun, 04 Jan 2009 18:48:37 +0000
parents 0de488aa4fb0
children e9d9d946f213
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
1 /*
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
2 * simple arithmetic expression evaluator
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
3 *
4101
a15abf56debf update copyright year, it looks odd otherwise :)
michael
parents: 4099
diff changeset
4 * Copyright (c) 2002-2006 Michael Niedermayer <michaelni@gmx.at>
4099
5e5c34470242 I hope noone minds, adding myself to eval.c copyright...
ods15
parents: 4095
diff changeset
5 * Copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
6 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
7 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
8 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
9 * FFmpeg is free software; you can redistribute it and/or
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
10 * modify it under the terms of the GNU Lesser General Public
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
11 * License as published by the Free Software Foundation; either
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
12 * version 2.1 of the License, or (at your option) any later version.
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
13 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
14 * FFmpeg is distributed in the hope that it will be useful,
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
17 * Lesser General Public License for more details.
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
18 *
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
19 * You should have received a copy of the GNU Lesser General Public
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3920
diff changeset
20 * License along with FFmpeg; if not, write to the Free Software
3036
0b546eab515d Update licensing information: The FSF changed postal address.
diego
parents: 2967
diff changeset
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
22 */
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
23
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1057
diff changeset
24 /**
1e39f273ecd6 per file doxy
michaelni
parents: 1057
diff changeset
25 * @file eval.c
1e39f273ecd6 per file doxy
michaelni
parents: 1057
diff changeset
26 * simple arithmetic expression evaluator.
1e39f273ecd6 per file doxy
michaelni
parents: 1057
diff changeset
27 *
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
28 * see http://joe.hotchkiss.com/programming/eval/eval.html
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
29 */
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
30
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 627
diff changeset
31 #include "avcodec.h"
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
32 #include "eval.h"
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 627
diff changeset
33
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
34 #include <stdio.h>
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
35 #include <stdlib.h>
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
36 #include <string.h>
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
37 #include <math.h>
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
38
614
b786f15df503 NAN doesnt exist on FreeBSD patch by (Rmi Guyomarch <rguyom at pobox dot com>)
michaelni
parents: 612
diff changeset
39 #ifndef NAN
3753
82ceab4ada49 Define NAN -if not already defined- as 0.0/0.0
takis
parents: 3731
diff changeset
40 #define NAN 0.0/0.0
614
b786f15df503 NAN doesnt exist on FreeBSD patch by (Rmi Guyomarch <rguyom at pobox dot com>)
michaelni
parents: 612
diff changeset
41 #endif
b786f15df503 NAN doesnt exist on FreeBSD patch by (Rmi Guyomarch <rguyom at pobox dot com>)
michaelni
parents: 612
diff changeset
42
627
79c43f519d02 undefined M_PI / M_E fix
michaelni
parents: 614
diff changeset
43 #ifndef M_PI
79c43f519d02 undefined M_PI / M_E fix
michaelni
parents: 614
diff changeset
44 #define M_PI 3.14159265358979323846
79c43f519d02 undefined M_PI / M_E fix
michaelni
parents: 614
diff changeset
45 #endif
79c43f519d02 undefined M_PI / M_E fix
michaelni
parents: 614
diff changeset
46
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
47 typedef struct Parser{
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
48 int stack_index;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
49 char *s;
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
50 const double *const_value;
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
51 const char * const *const_name; // NULL terminated
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
52 double (**func1)(void *, double a); // NULL terminated
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 627
diff changeset
53 const char **func1_name; // NULL terminated
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
54 double (**func2)(void *, double a, double b); // NULL terminated
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
55 const char **func2_name; // NULL terminated
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
56 void *opaque;
6324
michael
parents: 6167
diff changeset
57 const char **error;
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
58 #define VARS 10
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
59 double var[VARS];
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
60 } Parser;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
61
7129
322023e630a6 mark read-only data as const
stefang
parents: 6840
diff changeset
62 static const int8_t si_prefixes['z' - 'E' + 1]={
3778
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
63 ['y'-'E']= -24,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
64 ['z'-'E']= -21,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
65 ['a'-'E']= -18,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
66 ['f'-'E']= -15,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
67 ['p'-'E']= -12,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
68 ['n'-'E']= - 9,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
69 ['u'-'E']= - 6,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
70 ['m'-'E']= - 3,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
71 ['c'-'E']= - 2,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
72 ['d'-'E']= - 1,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
73 ['h'-'E']= 2,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
74 ['k'-'E']= 3,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
75 ['K'-'E']= 3,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
76 ['M'-'E']= 6,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
77 ['G'-'E']= 9,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
78 ['T'-'E']= 12,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
79 ['P'-'E']= 15,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
80 ['E'-'E']= 18,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
81 ['Z'-'E']= 21,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
82 ['Y'-'E']= 24,
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
83 };
3756
9813c594dac5 Missing extern declaration for av_strtod.
takis
parents: 3755
diff changeset
84
3778
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
85 /** strtod() function extended with 'k', 'M', 'G', 'ki', 'Mi', 'Gi' and 'B'
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
86 * postfixes. This allows using f.e. kB, MiB, G and B as a postfix. This
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
87 * function assumes that the unit of numbers is bits not bytes.
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
88 */
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
89 static double av_strtod(const char *name, char **tail) {
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
90 double d;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
91 char *next;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
92 d = strtod(name, &next);
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
93 /* if parsing succeeded, check for and interpret postfixes */
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
94 if (next!=name) {
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
95
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
96 if(*next >= 'E' && *next <= 'z'){
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
97 int e= si_prefixes[*next - 'E'];
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
98 if(e){
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
99 if(next[1] == 'i'){
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
100 d*= pow( 2, e/0.3);
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
101 next+=2;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
102 }else{
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
103 d*= pow(10, e);
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
104 next++;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
105 }
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
106 }
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
107 }
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
108
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
109 if(*next=='B') {
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
110 d*=8;
4355
085f24822713 fix a gcc warning, avoid an unnecessary operation
lu_zero
parents: 4101
diff changeset
111 next++;
3778
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
112 }
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
113 }
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
114 /* if requested, fill in tail with the position after the last parsed
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
115 character */
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
116 if (tail)
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
117 *tail = next;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
118 return d;
67a63fa775a7 Make AVOption parsign code use ff_eval2()
takis
parents: 3774
diff changeset
119 }
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
120
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 627
diff changeset
121 static int strmatch(const char *s, const char *prefix){
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
122 int i;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
123 for(i=0; prefix[i]; i++){
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
124 if(prefix[i] != s[i]) return 0;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
125 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
126 return 1;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
127 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
128
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
129 struct ff_expr_s {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
130 enum {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
131 e_value, e_const, e_func0, e_func1, e_func2,
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
132 e_squish, e_gauss, e_ld,
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
133 e_mod, e_max, e_min, e_eq, e_gt, e_gte,
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
134 e_pow, e_mul, e_div, e_add,
4090
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
135 e_last, e_st, e_while,
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
136 } type;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
137 double value; // is sign in other types
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
138 union {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
139 int const_index;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
140 double (*func0)(double);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
141 double (*func1)(void *, double);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
142 double (*func2)(void *, double, double);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
143 } a;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
144 AVEvalExpr * param[2];
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
145 };
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
146
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
147 static double eval_expr(Parser * p, AVEvalExpr * e) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
148 switch (e->type) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
149 case e_value: return e->value;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
150 case e_const: return e->value * p->const_value[e->a.const_index];
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
151 case e_func0: return e->value * e->a.func0(eval_expr(p, e->param[0]));
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
152 case e_func1: return e->value * e->a.func1(p->opaque, eval_expr(p, e->param[0]));
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
153 case e_func2: return e->value * e->a.func2(p->opaque, eval_expr(p, e->param[0]), eval_expr(p, e->param[1]));
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
154 case e_squish: return 1/(1+exp(4*eval_expr(p, e->param[0])));
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
155 case e_gauss: { double d = eval_expr(p, e->param[0]); return exp(-d*d/2)/sqrt(2*M_PI); }
4594
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4355
diff changeset
156 case e_ld: return e->value * p->var[av_clip(eval_expr(p, e->param[0]), 0, VARS-1)];
4090
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
157 case e_while: {
4092
772ab2a1deaa shut gcc warning, also makes sense for NAN to be returned if the loop was never executed
ods15
parents: 4090
diff changeset
158 double d = NAN;
4090
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
159 while(eval_expr(p, e->param[0]))
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
160 d=eval_expr(p, e->param[1]);
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
161 return d;
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
162 }
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
163 default: {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
164 double d = eval_expr(p, e->param[0]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
165 double d2 = eval_expr(p, e->param[1]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
166 switch (e->type) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
167 case e_mod: return e->value * (d - floor(d/d2)*d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
168 case e_max: return e->value * (d > d2 ? d : d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
169 case e_min: return e->value * (d < d2 ? d : d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
170 case e_eq: return e->value * (d == d2 ? 1.0 : 0.0);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
171 case e_gt: return e->value * (d > d2 ? 1.0 : 0.0);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
172 case e_gte: return e->value * (d >= d2 ? 1.0 : 0.0);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
173 case e_pow: return e->value * pow(d, d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
174 case e_mul: return e->value * (d * d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
175 case e_div: return e->value * (d / d2);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
176 case e_add: return e->value * (d + d2);
4093
ca9b4b42ebf9 add missing 'e->value * '
ods15
parents: 4092
diff changeset
177 case e_last:return e->value * d2;
4594
a96d905dcbaa Add av_ prefix to clip functions
reimar
parents: 4355
diff changeset
178 case e_st : return e->value * (p->var[av_clip(d, 0, VARS-1)]= d2);
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
179 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
180 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
181 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
182 return NAN;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
183 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
184
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
185 static AVEvalExpr * parse_expr(Parser *p);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
186
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
187 void ff_eval_free(AVEvalExpr * e) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
188 if (!e) return;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
189 ff_eval_free(e->param[0]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
190 ff_eval_free(e->param[1]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
191 av_freep(&e);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
192 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
193
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
194 static AVEvalExpr * parse_primary(Parser *p) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
195 AVEvalExpr * d = av_mallocz(sizeof(AVEvalExpr));
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
196 char *next= p->s;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
197 int i;
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
198
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
199 /* number */
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
200 d->value = av_strtod(p->s, &next);
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
201 if(next != p->s){
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
202 d->type = e_value;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
203 p->s= next;
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
204 return d;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
205 }
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
206 d->value = 1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
207
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
208 /* named constants */
2433
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
209 for(i=0; p->const_name && p->const_name[i]; i++){
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
210 if(strmatch(p->s, p->const_name[i])){
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
211 p->s+= strlen(p->const_name[i]);
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
212 d->type = e_const;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
213 d->a.const_index = i;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
214 return d;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
215 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
216 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
217
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
218 p->s= strchr(p->s, '(');
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
219 if(p->s==NULL){
6840
7cb16b1c580f Improve parse_primary() error message.
benoit
parents: 6450
diff changeset
220 *p->error = "undefined constant or missing (";
3754
6f219b6839ba segfault fix
michael
parents: 3753
diff changeset
221 p->s= next;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
222 ff_eval_free(d);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
223 return NULL;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
224 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
225 p->s++; // "("
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
226 if (*next == '(') { // special case do-nothing
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
227 av_freep(&d);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
228 d = parse_expr(p);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
229 if(p->s[0] != ')'){
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
230 *p->error = "missing )";
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
231 ff_eval_free(d);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
232 return NULL;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
233 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
234 p->s++; // ")"
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
235 return d;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
236 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
237 d->param[0] = parse_expr(p);
1815
2152760d08ad avoid negative array indices
alex
parents: 1598
diff changeset
238 if(p->s[0]== ','){
2152760d08ad avoid negative array indices
alex
parents: 1598
diff changeset
239 p->s++; // ","
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
240 d->param[1] = parse_expr(p);
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
241 }
1815
2152760d08ad avoid negative array indices
alex
parents: 1598
diff changeset
242 if(p->s[0] != ')'){
3770
ea345e1e440f Introduce ff_eval2 which is equivalent to ff_eval but does not log anything.
takis
parents: 3756
diff changeset
243 *p->error = "missing )";
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
244 ff_eval_free(d);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
245 return NULL;
1815
2152760d08ad avoid negative array indices
alex
parents: 1598
diff changeset
246 }
2152760d08ad avoid negative array indices
alex
parents: 1598
diff changeset
247 p->s++; // ")"
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
248
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
249 d->type = e_func0;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
250 if( strmatch(next, "sinh" ) ) d->a.func0 = sinh;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
251 else if( strmatch(next, "cosh" ) ) d->a.func0 = cosh;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
252 else if( strmatch(next, "tanh" ) ) d->a.func0 = tanh;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
253 else if( strmatch(next, "sin" ) ) d->a.func0 = sin;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
254 else if( strmatch(next, "cos" ) ) d->a.func0 = cos;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
255 else if( strmatch(next, "tan" ) ) d->a.func0 = tan;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
256 else if( strmatch(next, "atan" ) ) d->a.func0 = atan;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
257 else if( strmatch(next, "asin" ) ) d->a.func0 = asin;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
258 else if( strmatch(next, "acos" ) ) d->a.func0 = acos;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
259 else if( strmatch(next, "exp" ) ) d->a.func0 = exp;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
260 else if( strmatch(next, "log" ) ) d->a.func0 = log;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
261 else if( strmatch(next, "abs" ) ) d->a.func0 = fabs;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
262 else if( strmatch(next, "squish") ) d->type = e_squish;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
263 else if( strmatch(next, "gauss" ) ) d->type = e_gauss;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
264 else if( strmatch(next, "mod" ) ) d->type = e_mod;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
265 else if( strmatch(next, "max" ) ) d->type = e_max;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
266 else if( strmatch(next, "min" ) ) d->type = e_min;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
267 else if( strmatch(next, "eq" ) ) d->type = e_eq;
4087
d4cdb9f6e888 possible bug of 'gte' being read as 'gt', same with 'lte'
ods15
parents: 4086
diff changeset
268 else if( strmatch(next, "gte" ) ) d->type = e_gte;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
269 else if( strmatch(next, "gt" ) ) d->type = e_gt;
4087
d4cdb9f6e888 possible bug of 'gte' being read as 'gt', same with 'lte'
ods15
parents: 4086
diff changeset
270 else if( strmatch(next, "lte" ) ) { AVEvalExpr * tmp = d->param[1]; d->param[1] = d->param[0]; d->param[0] = tmp; d->type = e_gt; }
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
271 else if( strmatch(next, "lt" ) ) { AVEvalExpr * tmp = d->param[1]; d->param[1] = d->param[0]; d->param[0] = tmp; d->type = e_gte; }
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
272 else if( strmatch(next, "ld" ) ) d->type = e_ld;
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
273 else if( strmatch(next, "st" ) ) d->type = e_st;
4090
8e35dfc4ae15 add support for while() loops again ugly syntax while(condition, statements) but very simple implementation
michael
parents: 4089
diff changeset
274 else if( strmatch(next, "while" ) ) d->type = e_while;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
275 else {
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
276 for(i=0; p->func1_name && p->func1_name[i]; i++){
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
277 if(strmatch(next, p->func1_name[i])){
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
278 d->a.func1 = p->func1[i];
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
279 d->type = e_func1;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
280 return d;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
281 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
282 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
283
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
284 for(i=0; p->func2_name && p->func2_name[i]; i++){
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
285 if(strmatch(next, p->func2_name[i])){
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
286 d->a.func2 = p->func2[i];
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
287 d->type = e_func2;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
288 return d;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
289 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
290 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
291
3770
ea345e1e440f Introduce ff_eval2 which is equivalent to ff_eval but does not log anything.
takis
parents: 3756
diff changeset
292 *p->error = "unknown function";
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
293 ff_eval_free(d);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
294 return NULL;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
295 }
2433
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
296
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
297 return d;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
298 }
2436
86d14aebd527 simplify
michael
parents: 2434
diff changeset
299
4085
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
300 static AVEvalExpr * new_eval_expr(int type, int value, AVEvalExpr *p0, AVEvalExpr *p1){
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
301 AVEvalExpr * e = av_mallocz(sizeof(AVEvalExpr));
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
302 e->type =type ;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
303 e->value =value ;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
304 e->param[0] =p0 ;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
305 e->param[1] =p1 ;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
306 return e;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
307 }
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
308
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
309 static AVEvalExpr * parse_pow(Parser *p, int *sign){
4032
0f2bb0baf6f0 fix -a^b which was interpreted as (-a)^b
michael
parents: 4031
diff changeset
310 *sign= (*p->s == '+') - (*p->s == '-');
0f2bb0baf6f0 fix -a^b which was interpreted as (-a)^b
michael
parents: 4031
diff changeset
311 p->s += *sign&1;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
312 return parse_primary(p);
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
313 }
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
314
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
315 static AVEvalExpr * parse_factor(Parser *p){
4032
0f2bb0baf6f0 fix -a^b which was interpreted as (-a)^b
michael
parents: 4031
diff changeset
316 int sign, sign2;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
317 AVEvalExpr * e = parse_pow(p, &sign);
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
318 while(p->s[0]=='^'){
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
319 p->s++;
4086
9076b11ea35f minor simplification
michael
parents: 4085
diff changeset
320 e= new_eval_expr(e_pow, 1, e, parse_pow(p, &sign2));
9076b11ea35f minor simplification
michael
parents: 4085
diff changeset
321 if (e->param[1]) e->param[1]->value *= (sign2|1);
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
322 }
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
323 if (e) e->value *= (sign|1);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
324 return e;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
325 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
326
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
327 static AVEvalExpr * parse_term(Parser *p){
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
328 AVEvalExpr * e = parse_factor(p);
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
329 while(p->s[0]=='*' || p->s[0]=='/'){
4085
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
330 int c= *p->s++;
16b88d6b3546 factorize AVEvalExpr alloc and init
michael
parents: 4081
diff changeset
331 e= new_eval_expr(c == '*' ? e_mul : e_div, 1, e, parse_factor(p));
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
332 }
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
333 return e;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
334 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
335
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
336 static AVEvalExpr * parse_subexpr(Parser *p) {
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
337 AVEvalExpr * e = parse_term(p);
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
338 while(*p->s == '+' || *p->s == '-') {
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
339 e= new_eval_expr(e_add, 1, e, parse_term(p));
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
340 };
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
341
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
342 return e;
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
343 }
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
344
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
345 static AVEvalExpr * parse_expr(Parser *p) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
346 AVEvalExpr * e;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
347
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
348 if(p->stack_index <= 0) //protect against stack overflows
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
349 return NULL;
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
350 p->stack_index--;
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
351
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
352 e = parse_subexpr(p);
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
353
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
354 while(*p->s == ';') {
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
355 p->s++;
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
356 e= new_eval_expr(e_last, 1, e, parse_subexpr(p));
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
357 };
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
358
2434
24aa9209e8b0 simplify
michael
parents: 2433
diff changeset
359 p->stack_index++;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
360
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
361 return e;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
362 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
363
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
364 static int verify_expr(AVEvalExpr * e) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
365 if (!e) return 0;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
366 switch (e->type) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
367 case e_value:
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
368 case e_const: return 1;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
369 case e_func0:
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
370 case e_func1:
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
371 case e_squish:
4089
4f5f752f732c support seperating expressons by ;
michael
parents: 4087
diff changeset
372 case e_ld:
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
373 case e_gauss: return verify_expr(e->param[0]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
374 default: return verify_expr(e->param[0]) && verify_expr(e->param[1]);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
375 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
376 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
377
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
378 AVEvalExpr * ff_parse(const char *s, const char * const *const_name,
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
379 double (**func1)(void *, double), const char **func1_name,
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
380 double (**func2)(void *, double, double), const char **func2_name,
6324
michael
parents: 6167
diff changeset
381 const char **error){
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
382 Parser p;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
383 AVEvalExpr * e;
4095
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
384 char w[strlen(s) + 1], * wp = w;
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
385
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
386 while (*s)
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
387 if (!isspace(*s++)) *wp++ = s[-1];
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
388 *wp++ = 0;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
389
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
390 p.stack_index=100;
4095
fda3ec8e96e1 ignore whitespace in ff_eval
ods15
parents: 4093
diff changeset
391 p.s= w;
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
392 p.const_name = const_name;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
393 p.func1 = func1;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
394 p.func1_name = func1_name;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
395 p.func2 = func2;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
396 p.func2_name = func2_name;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
397 p.error= error;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
398
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
399 e = parse_expr(&p);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
400 if (!verify_expr(e)) {
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
401 ff_eval_free(e);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
402 return NULL;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
403 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
404 return e;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
405 }
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
406
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
407 double ff_parse_eval(AVEvalExpr * e, const double *const_value, void *opaque) {
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
408 Parser p;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
409
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
410 p.const_value= const_value;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
411 p.opaque = opaque;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
412 return eval_expr(&p, e);
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
413 }
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
414
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
415 double ff_eval2(const char *s, const double *const_value, const char * const *const_name,
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 627
diff changeset
416 double (**func1)(void *, double), const char **func1_name,
8320
0de488aa4fb0 Add a few const qualifiers in appropriate places.
diego
parents: 8108
diff changeset
417 double (**func2)(void *, double, double), const char **func2_name,
6324
michael
parents: 6167
diff changeset
418 void *opaque, const char **error){
4081
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
419 AVEvalExpr * e = ff_parse(s, const_name, func1, func1_name, func2, func2_name, error);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
420 double d;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
421 if (!e) return NAN;
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
422 d = ff_parse_eval(e, const_value, opaque);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
423 ff_eval_free(e);
cedb63307f3d new optimized eval method, by seperating parsing and runtime
ods15
parents: 4032
diff changeset
424 return d;
612
c0005de2be59 new ratecontrol code
michaelni
parents:
diff changeset
425 }
2433
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
426
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
427 #ifdef TEST
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
428 #undef printf
2433
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
429 static double const_values[]={
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
430 M_PI,
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
431 M_E,
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
432 0
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
433 };
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
434 static const char *const_names[]={
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
435 "PI",
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
436 "E",
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
437 0
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
438 };
6167
0ae80d7e989a Fix warnings in test code:
diego
parents: 5934
diff changeset
439 int main(void){
2436
86d14aebd527 simplify
michael
parents: 2434
diff changeset
440 int i;
8108
5de6db4225d6 Fix test program build: ff_eval was replaced by ff_eval2.
diego
parents: 7824
diff changeset
441 printf("%f == 12.7\n", ff_eval2("1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)", const_values, const_names, NULL, NULL, NULL, NULL, NULL, NULL));
5de6db4225d6 Fix test program build: ff_eval was replaced by ff_eval2.
diego
parents: 7824
diff changeset
442 printf("%f == 0.931322575\n", ff_eval2("80G/80Gi", const_values, const_names, NULL, NULL, NULL, NULL, NULL, NULL));
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2436
diff changeset
443
2436
86d14aebd527 simplify
michael
parents: 2434
diff changeset
444 for(i=0; i<1050; i++){
86d14aebd527 simplify
michael
parents: 2434
diff changeset
445 START_TIMER
8108
5de6db4225d6 Fix test program build: ff_eval was replaced by ff_eval2.
diego
parents: 7824
diff changeset
446 ff_eval2("1+(5-2)^(3-1)+1/2+sin(PI)-max(-2.2,-3.1)", const_values, const_names, NULL, NULL, NULL, NULL, NULL, NULL);
5de6db4225d6 Fix test program build: ff_eval was replaced by ff_eval2.
diego
parents: 7824
diff changeset
447 STOP_TIMER("ff_eval2")
2436
86d14aebd527 simplify
michael
parents: 2434
diff changeset
448 }
6167
0ae80d7e989a Fix warnings in test code:
diego
parents: 5934
diff changeset
449 return 0;
2433
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
450 }
0934621b6453 simplify, null pointer, selftest
michael
parents: 1815
diff changeset
451 #endif