FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavutil/eval.c
Date: 2026-07-19 01:11:25
Exec Total Coverage
Lines: 437 488 89.5%
Functions: 18 20 90.0%
Branches: 389 475 81.9%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2002-2006 Michael Niedermayer <michaelni@gmx.at>
3 * Copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * simple arithmetic expression evaluator.
25 *
26 * see http://joe.hotchkiss.com/programming/eval/eval.html
27 */
28
29 #include <float.h>
30 #include "attributes.h"
31 #include "avassert.h"
32 #include "avutil.h"
33 #include "common.h"
34 #include "eval.h"
35 #include "ffmath.h"
36 #include "log.h"
37 #include "mathematics.h"
38 #include "mem.h"
39 #include "sfc64.h"
40 #include "time.h"
41 #include "avstring.h"
42 #include "reverse.h"
43
44 #define MAX_DEPTH 100
45
46 typedef struct Parser {
47 const AVClass *class;
48 int stack_index;
49 char *s;
50 const double *const_values;
51 const char * const *const_names; // NULL terminated
52 double (* const *funcs1)(void *, double a); // NULL terminated
53 const char * const *func1_names; // NULL terminated
54 double (* const *funcs2)(void *, double a, double b); // NULL terminated
55 const char * const *func2_names; // NULL terminated
56 void *opaque;
57 int log_offset;
58 void *log_ctx;
59 #define VARS 10
60 double *var;
61 FFSFC64 *prng_state;
62 } Parser;
63
64 static const AVClass eval_class = {
65 .class_name = "Eval",
66 .item_name = av_default_item_name,
67 .option = NULL,
68 .version = LIBAVUTIL_VERSION_INT,
69 .log_level_offset_offset = offsetof(Parser, log_offset),
70 .parent_log_context_offset = offsetof(Parser, log_ctx),
71 };
72
73 static const struct {
74 double bin_val;
75 double dec_val;
76 int8_t exp;
77 } si_prefixes['z' - 'E' + 1] = {
78 ['y'-'E']= { 8.271806125530276749e-25, 1e-24, -24 },
79 ['z'-'E']= { 8.4703294725430034e-22, 1e-21, -21 },
80 ['a'-'E']= { 8.6736173798840355e-19, 1e-18, -18 },
81 ['f'-'E']= { 8.8817841970012523e-16, 1e-15, -15 },
82 ['p'-'E']= { 9.0949470177292824e-13, 1e-12, -12 },
83 ['n'-'E']= { 9.3132257461547852e-10, 1e-9, -9 },
84 ['u'-'E']= { 9.5367431640625e-7, 1e-6, -6 },
85 ['m'-'E']= { 9.765625e-4, 1e-3, -3 },
86 ['c'-'E']= { 9.8431332023036951e-3, 1e-2, -2 },
87 ['d'-'E']= { 9.921256574801246e-2, 1e-1, -1 },
88 ['h'-'E']= { 1.0159366732596479e2, 1e2, 2 },
89 ['k'-'E']= { 1.024e3, 1e3, 3 },
90 ['K'-'E']= { 1.024e3, 1e3, 3 },
91 ['M'-'E']= { 1.048576e6, 1e6, 6 },
92 ['G'-'E']= { 1.073741824e9, 1e9, 9 },
93 ['T'-'E']= { 1.099511627776e12, 1e12, 12 },
94 ['P'-'E']= { 1.125899906842624e15, 1e15, 15 },
95 ['E'-'E']= { 1.152921504606847e18, 1e18, 18 },
96 ['Z'-'E']= { 1.1805916207174113e21, 1e21, 21 },
97 ['Y'-'E']= { 1.2089258196146292e24, 1e24, 24 },
98 };
99
100 static const struct {
101 const char *name;
102 double value;
103 } constants[] = {
104 { "E", M_E },
105 { "PI", M_PI },
106 { "PHI", M_PHI },
107 { "QP2LAMBDA", FF_QP2LAMBDA },
108 };
109
110 124091 double av_strtod(const char *numstr, char **tail)
111 {
112 double d;
113 char *next;
114
4/4
✓ Branch 0 taken 36125 times.
✓ Branch 1 taken 87966 times.
✓ Branch 2 taken 139 times.
✓ Branch 3 taken 35986 times.
 124091 if(numstr[0]=='0' && (numstr[1]|0x20)=='x') {
115 139 d = strtoul(numstr, &next, 16);
116 } else
117 123952 d = strtod(numstr, &next);
118 /* if parsing succeeded, check for and interpret postfixes */
119
2/2
✓ Branch 0 taken 94876 times.
✓ Branch 1 taken 29215 times.
 124091 if (next!=numstr) {
120
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 94870 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 94876 if (next[0] == 'd' && next[1] == 'B') {
121 /* treat dB as decibels instead of decibytes */
122 6 d = ff_exp10(d / 20);
123 6 next += 2;
124
3/4
✓ Branch 0 taken 189 times.
✓ Branch 1 taken 94681 times.
✓ Branch 2 taken 189 times.
✗ Branch 3 not taken.
 94870 } else if (*next >= 'E' && *next <= 'z') {
125 189 int e= si_prefixes[*next - 'E'].exp;
126
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 2 times.
 189 if (e) {
127
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 181 times.
 187 if (next[1] == 'i') {
128 6 d*= si_prefixes[*next - 'E'].bin_val;
129 6 next+=2;
130 } else {
131 181 d*= si_prefixes[*next - 'E'].dec_val;
132 181 next++;
133 }
134 }
135 }
136
137
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 94875 times.
 94876 if (*next=='B') {
138 1 d*=8;
139 1 next++;
140 }
141 }
142 /* if requested, fill in tail with the position after the last parsed
143 character */
144
2/2
✓ Branch 0 taken 124086 times.
✓ Branch 1 taken 5 times.
 124091 if (tail)
145 124086 *tail = next;
146 124091 return d;
147 }
148
149 #define IS_IDENTIFIER_CHAR(c) ((c) - '0' <= 9U || (c) - 'a' <= 25U || (c) - 'A' <= 25U || (c) == '_')
150
151 426890 static int strmatch(const char *s, const char *prefix)
152 {
153 int i;
154
2/2
✓ Branch 0 taken 514317 times.
✓ Branch 1 taken 29191 times.
 543508 for (i=0; prefix[i]; i++) {
155
2/2
✓ Branch 0 taken 397699 times.
✓ Branch 1 taken 116618 times.
 514317 if (prefix[i] != s[i]) return 0;
156 }
157 /* return 1 only if the s identifier is terminated */
158
6/8
✓ Branch 0 taken 29191 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 29163 times.
✓ Branch 3 taken 28 times.
✓ Branch 4 taken 29150 times.
✓ Branch 5 taken 13 times.
✓ Branch 6 taken 29150 times.
✗ Branch 7 not taken.
 29191 return !IS_IDENTIFIER_CHAR(s[i]);
159 }
160
161 enum {
162 e_value, e_const, e_func0, e_func1, e_func2,
163 e_squish, e_gauss, e_ld, e_isnan, e_isinf,
164 e_mod, e_max, e_min, e_eq, e_gt, e_gte, e_lte, e_lt,
165 e_pow, e_mul, e_div, e_add,
166 e_last, e_st, e_while, e_taylor, e_root, e_floor, e_ceil, e_trunc, e_round,
167 e_sqrt, e_not, e_random, e_hypot, e_gcd,
168 e_if, e_ifnot, e_print, e_bitand, e_bitor, e_between, e_clip, e_atan2, e_lerp,
169 e_sgn, e_randomi
170 };
171 struct AVExpr {
172 unsigned char type;
173 unsigned char root;
174 short depth;
175 int const_index;
176 double value; // is sign in other types
177 union {
178 double (*func0)(double);
179 double (*func1)(void *, double);
180 double (*func2)(void *, double, double);
181 } ;
182 struct AVExpr *param[3];
183 };
184
185 typedef struct {
186 AVExpr avexpr;
187 double *var;
188 FFSFC64 *prng_state;
189 } AVExprRoot;
190
191 ✗ static double etime(double v)
192 {
193 ✗ return av_gettime() * 0.000001;
194 }
195
196 228867092 static double eval_expr(Parser *p, AVExpr *e)
197 {
198
26/29
✓ Branch 0 taken 73532319 times.
✓ Branch 1 taken 42243486 times.
✓ Branch 2 taken 19627700 times.
✓ Branch 3 taken 280986 times.
✓ Branch 4 taken 6 times.
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 1695 times.
✓ Branch 8 taken 4 times.
✓ Branch 9 taken 3 times.
✓ Branch 10 taken 20 times.
✓ Branch 11 taken 2 times.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✓ Branch 15 taken 2 times.
✓ Branch 16 taken 301 times.
✓ Branch 17 taken 32885 times.
✓ Branch 18 taken 4 times.
✓ Branch 19 taken 3 times.
✓ Branch 20 taken 1323200 times.
✓ Branch 21 taken 2 times.
✓ Branch 22 taken 2 times.
✓ Branch 23 taken 264913 times.
✗ Branch 24 not taken.
✓ Branch 25 taken 4 times.
✓ Branch 26 taken 2 times.
✓ Branch 27 taken 2 times.
✓ Branch 28 taken 91559545 times.
 228867092 switch (e->type) {
199 73532319 case e_value: return e->value;
200 42243486 case e_const: return e->value * p->const_values[e->const_index];
201 19627700 case e_func0: return e->value * e->func0(eval_expr(p, e->param[0]));
202 280986 case e_func1: return e->value * e->func1(p->opaque, eval_expr(p, e->param[0]));
203 6 case e_func2: return e->value * e->func2(p->opaque, eval_expr(p, e->param[0]), eval_expr(p, e->param[1]));
204 2 case e_squish: return e->value/(1+exp(4*eval_expr(p, e->param[0])));
205 2 case e_gauss: { double d = eval_expr(p, e->param[0]); return e->value * exp(-d*d/2)/sqrt(2*M_PI); }
206 1695 case e_ld: return e->value * p->var[av_clip(eval_expr(p, e->param[0]), 0, VARS-1)];
207
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
 4 case e_isnan: return e->value * !!isnan(eval_expr(p, e->param[0]));
208
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
 3 case e_isinf: return e->value * !!isinf(eval_expr(p, e->param[0]));
209 20 case e_floor: return e->value * floor(eval_expr(p, e->param[0]));
210 2 case e_ceil : return e->value * ceil (eval_expr(p, e->param[0]));
211 2 case e_trunc: return e->value * trunc(eval_expr(p, e->param[0]));
212 ✗ case e_round: return e->value * round(eval_expr(p, e->param[0]));
213 ✗ case e_sgn: return e->value * FFDIFFSIGN(eval_expr(p, e->param[0]), 0);
214 2 case e_sqrt: return e->value * sqrt (eval_expr(p, e->param[0]));
215
2/2
✓ Branch 1 taken 203 times.
✓ Branch 2 taken 98 times.
 301 case e_not: return e->value * (eval_expr(p, e->param[0]) == 0);
216
2/2
✓ Branch 1 taken 16391 times.
✓ Branch 2 taken 16494 times.
 49379 case e_if: return e->value * (eval_expr(p, e->param[0]) ? eval_expr(p, e->param[1]) :
217
2/2
✓ Branch 0 taken 16493 times.
✓ Branch 1 taken 1 times.
 16494 e->param[2] ? eval_expr(p, e->param[2]) : 0);
218
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2 times.
 6 case e_ifnot: return e->value * (!eval_expr(p, e->param[0]) ? eval_expr(p, e->param[1]) :
219
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 e->param[2] ? eval_expr(p, e->param[2]) : 0);
220 3 case e_clip: {
221 3 double x = eval_expr(p, e->param[0]);
222 3 double min = eval_expr(p, e->param[1]), max = eval_expr(p, e->param[2]);
223
6/8
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
 3 if (isnan(min) || isnan(max) || isnan(x) || min > max)
224 3 return NAN;
225 ✗ return e->value * av_clipd(eval_expr(p, e->param[0]), min, max);
226 }
227 1323200 case e_between: {
228 1323200 double d = eval_expr(p, e->param[0]);
229
4/4
✓ Branch 1 taken 793895 times.
✓ Branch 2 taken 529305 times.
✓ Branch 3 taken 176442 times.
✓ Branch 4 taken 617453 times.
 2117095 return e->value * (d >= eval_expr(p, e->param[1]) &&
230 793895 d <= eval_expr(p, e->param[2]));
231 }
232 2 case e_lerp: {
233 2 double v0 = eval_expr(p, e->param[0]);
234 2 double v1 = eval_expr(p, e->param[1]);
235 2 double f = eval_expr(p, e->param[2]);
236 2 return e->value * (v0 + (v1 - v0) * f);
237 }
238 2 case e_print: {
239 2 double x = eval_expr(p, e->param[0]);
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 int level = e->param[1] ? av_clip(eval_expr(p, e->param[1]), INT_MIN, INT_MAX) : AV_LOG_INFO;
241 2 av_log(p, level, "%f\n", x);
242 2 return e->value * x;
243 }
244
245 #define COMPUTE_NEXT_RANDOM() \
246 int idx = av_clip(eval_expr(p, e->param[0]), 0, VARS-1); \
247 FFSFC64 *s = p->prng_state + idx; \
248 uint64_t r; \
249 \
250 if (!s->counter) { \
251 r = isnan(p->var[idx]) ? 0 : p->var[idx]; \
252 ff_sfc64_init(s, r, r, r, 12); \
253 } \
254 r = ff_sfc64_get(s); \
255 p->var[idx] = r; \
256
257 264913 case e_random: {
258
3/4
✓ Branch 1 taken 54 times.
✓ Branch 2 taken 264859 times.
✓ Branch 3 taken 54 times.
✗ Branch 4 not taken.
 264913 COMPUTE_NEXT_RANDOM();
259 264913 return r * (1.0/UINT64_MAX);
260 }
261 ✗ case e_randomi: {
262 ✗ double min = eval_expr(p, e->param[1]);
263 ✗ double max = eval_expr(p, e->param[2]);
264 ✗ COMPUTE_NEXT_RANDOM();
265 ✗ return min + (max - min) * r / UINT64_MAX;
266 }
267 4 case e_while: {
268 4 double d = NAN;
269
2/2
✓ Branch 1 taken 210 times.
✓ Branch 2 taken 4 times.
 214 while (eval_expr(p, e->param[0]))
270 210 d=eval_expr(p, e->param[1]);
271 4 return d;
272 }
273 2 case e_taylor: {
274 2 double t = 1, d = 0, v;
275 2 double x = eval_expr(p, e->param[1]);
276
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 int id = e->param[2] ? av_clip(eval_expr(p, e->param[2]), 0, VARS-1) : 0;
277 int i;
278 2 double var0 = p->var[id];
279
1/2
✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
 43 for(i=0; i<1000; i++) {
280 43 double ld = d;
281 43 p->var[id] = i;
282 43 v = eval_expr(p, e->param[0]);
283 43 d += t*v;
284
4/4
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 12 times.
 43 if(ld==d && v)
285 2 break;
286 41 t *= x / (i+1);
287 }
288 2 p->var[id] = var0;
289 2 return d;
290 }
291 2 case e_root: {
292 int i, j;
293 2 double low = -1, high = -1, v, low_v = -DBL_MAX, high_v = DBL_MAX;
294 2 double var0 = p->var[0];
295 2 double x_max = eval_expr(p, e->param[1]);
296
1/2
✓ Branch 0 taken 491 times.
✗ Branch 1 not taken.
 491 for(i=-1; i<1024; i++) {
297
2/2
✓ Branch 0 taken 315 times.
✓ Branch 1 taken 176 times.
 491 if(i<255) {
298 315 p->var[0] = ff_reverse[i&255]*x_max/255;
299 } else {
300 176 p->var[0] = x_max*pow(0.9, i-255);
301
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 88 times.
 176 if (i&1) p->var[0] *= -1;
302
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 88 times.
 176 if (i&2) p->var[0] += low;
303 88 else p->var[0] += high;
304 }
305 491 v = eval_expr(p, e->param[0]);
306
4/4
✓ Branch 0 taken 433 times.
✓ Branch 1 taken 58 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 403 times.
 491 if (v<=0 && v>low_v) {
307 30 low = p->var[0];
308 30 low_v = v;
309 }
310
4/4
✓ Branch 0 taken 59 times.
✓ Branch 1 taken 432 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 53 times.
 491 if (v>=0 && v<high_v) {
311 6 high = p->var[0];
312 6 high_v = v;
313 }
314
4/4
✓ Branch 0 taken 433 times.
✓ Branch 1 taken 58 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 431 times.
 491 if (low>=0 && high>=0){
315
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 for (j=0; j<1000; j++) {
316 48 p->var[0] = (low+high)*0.5;
317
3/4
✓ Branch 0 taken 46 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 46 times.
✗ Branch 3 not taken.
 48 if (low == p->var[0] || high == p->var[0])
318 break;
319 46 v = eval_expr(p, e->param[0]);
320
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 25 times.
 46 if (v<=0) low = p->var[0];
321
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 20 times.
 46 if (v>=0) high= p->var[0];
322
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
 46 if (isnan(v)) {
323 ✗ low = high = v;
324 ✗ break;
325 }
326 }
327 2 break;
328 }
329 }
330 2 p->var[0] = var0;
331
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 return -low_v<high_v ? low : high;
332 }
333 91559545 default: {
334 91559545 double d = eval_expr(p, e->param[0]);
335 91559545 double d2 = eval_expr(p, e->param[1]);
336
18/20
✓ Branch 0 taken 198 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 234 times.
✓ Branch 5 taken 1333 times.
✓ Branch 6 taken 1116 times.
✓ Branch 7 taken 1117 times.
✓ Branch 8 taken 216 times.
✓ Branch 9 taken 5215 times.
✓ Branch 10 taken 75703747 times.
✓ Branch 11 taken 3612283 times.
✓ Branch 12 taken 12233371 times.
✓ Branch 13 taken 243 times.
✓ Branch 14 taken 464 times.
✓ Branch 15 taken 1 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 2 times.
✓ Branch 18 taken 1 times.
✗ Branch 19 not taken.
 91559545 switch (e->type) {
337
1/2
✓ Branch 0 taken 198 times.
✗ Branch 1 not taken.
 198 case e_mod: return e->value * (d - floor(d2 ? d / d2 : d * INFINITY) * d2);
338 1 case e_gcd: return e->value * av_gcd(d,d2);
339
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 case e_max: return e->value * (d > d2 ? d : d2);
340
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 case e_min: return e->value * (d < d2 ? d : d2);
341
2/2
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 177 times.
 234 case e_eq: return e->value * (d == d2 ? 1.0 : 0.0);
342
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1321 times.
 1333 case e_gt: return e->value * (d > d2 ? 1.0 : 0.0);
343
2/2
✓ Branch 0 taken 355 times.
✓ Branch 1 taken 761 times.
 1116 case e_gte: return e->value * (d >= d2 ? 1.0 : 0.0);
344
2/2
✓ Branch 0 taken 773 times.
✓ Branch 1 taken 344 times.
 1117 case e_lt: return e->value * (d < d2 ? 1.0 : 0.0);
345
2/2
✓ Branch 0 taken 212 times.
✓ Branch 1 taken 4 times.
 216 case e_lte: return e->value * (d <= d2 ? 1.0 : 0.0);
346 5215 case e_pow: return e->value * pow(d, d2);
347 75703747 case e_mul: return e->value * (d * d2);
348
2/2
✓ Branch 0 taken 3612275 times.
✓ Branch 1 taken 8 times.
 3612283 case e_div: return e->value * (d2 ? (d / d2) : d * INFINITY);
349 12233371 case e_add: return e->value * (d + d2);
350 243 case e_last:return e->value * d2;
351 464 case e_st : {
352 464 int index = av_clip(d, 0, VARS-1);
353 464 p->prng_state[index].counter = 0;
354 464 return e->value * (p->var[index]= d2);
355 }
356 1 case e_hypot:return e->value * hypot(d, d2);
357 ✗ case e_atan2:return e->value * atan2(d, d2);
358
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 2 case e_bitand: return isnan(d) || isnan(d2) ? NAN : e->value * ((long int)d & (long int)d2);
359
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 case e_bitor: return isnan(d) || isnan(d2) ? NAN : e->value * ((long int)d | (long int)d2);
360 }
361 }
362 }
363 ✗ return NAN;
364 }
365
366 static int parse_expr(AVExpr **e, Parser *p);
367
368 520159 void av_expr_free(AVExpr *e)
369 {
370
2/2
✓ Branch 0 taken 434211 times.
✓ Branch 1 taken 85948 times.
 520159 if (!e) return;
371 85948 av_expr_free(e->param[0]);
372 85948 av_expr_free(e->param[1]);
373 85948 av_expr_free(e->param[2]);
374
2/2
✓ Branch 0 taken 82301 times.
✓ Branch 1 taken 3647 times.
 85948 if (e->root) {
375 82301 AVExprRoot *r = (AVExprRoot*)e;
376 82301 av_freep(&r->var);
377 82301 av_freep(&r->prng_state);
378 }
379 85948 av_freep(&e);
380 }
381
382 84423 static int parse_primary(AVExpr **e, Parser *p)
383 {
384 84423 AVExpr *d = av_mallocz(sizeof(AVExpr));
385 84423 char *next = p->s, *s0 = p->s;
386 int ret, i;
387
388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84423 times.
 84423 if (!d)
389 ✗ return AVERROR(ENOMEM);
390
391 /* number */
392 84423 d->value = av_strtod(p->s, &next);
393
2/2
✓ Branch 0 taken 55208 times.
✓ Branch 1 taken 29215 times.
 84423 if (next != p->s) {
394 55208 d->type = e_value;
395 55208 p->s= next;
396 55208 *e = d;
397 55208 return 0;
398 }
399 29215 d->value = 1;
400
401 /* named constants */
402
4/4
✓ Branch 0 taken 415478 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 415027 times.
✓ Branch 3 taken 451 times.
 415493 for (i=0; p->const_names && p->const_names[i]; i++) {
403
2/2
✓ Branch 1 taken 28749 times.
✓ Branch 2 taken 386278 times.
 415027 if (strmatch(p->s, p->const_names[i])) {
404 28749 p->s+= strlen(p->const_names[i]);
405 28749 d->type = e_const;
406 28749 d->const_index = i;
407 28749 *e = d;
408 28749 return 0;
409 }
410 }
411
2/2
✓ Branch 0 taken 1734 times.
✓ Branch 1 taken 401 times.
 2135 for (i = 0; i < FF_ARRAY_ELEMS(constants); i++) {
412
2/2
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 1669 times.
 1734 if (strmatch(p->s, constants[i].name)) {
413 65 p->s += strlen(constants[i].name);
414 65 d->type = e_value;
415 65 d->value = constants[i].value;
416 65 *e = d;
417 65 return 0;
418 }
419 }
420
421 401 p->s= strchr(p->s, '(');
422
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 373 times.
 401 if (!p->s) {
423 28 av_log(p, AV_LOG_ERROR, "Undefined constant or missing '(' in '%s'\n", s0);
424 28 p->s= next;
425 28 av_expr_free(d);
426 28 return AVERROR(EINVAL);
427 }
428 373 p->s++; // "("
429
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 341 times.
 373 if (*next == '(') { // special case do-nothing
430 32 av_freep(&d);
431
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = parse_expr(&d, p)) < 0)
432 ✗ return ret;
433
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
 32 if (p->s[0] != ')') {
434 ✗ av_log(p, AV_LOG_ERROR, "Missing ')' in '%s'\n", s0);
435 ✗ av_expr_free(d);
436 ✗ return AVERROR(EINVAL);
437 }
438 32 p->s++; // ")"
439 32 *e = d;
440 32 return 0;
441 }
442
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 337 times.
 341 if ((ret = parse_expr(&(d->param[0]), p)) < 0) {
443 4 av_expr_free(d);
444 4 return ret;
445 }
446
2/2
✓ Branch 0 taken 122 times.
✓ Branch 1 taken 215 times.
 337 if (p->s[0]== ',') {
447 122 p->s++; // ","
448 122 parse_expr(&d->param[1], p);
449 }
450
2/2
✓ Branch 0 taken 31 times.
✓ Branch 1 taken 306 times.
 337 if (p->s[0]== ',') {
451 31 p->s++; // ","
452 31 parse_expr(&d->param[2], p);
453 }
454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 337 times.
 337 if (p->s[0] != ')') {
455 ✗ av_log(p, AV_LOG_ERROR, "Missing ')' or too many args in '%s'\n", s0);
456 ✗ av_expr_free(d);
457 ✗ return AVERROR(EINVAL);
458 }
459 337 p->s++; // ")"
460
461
2/2
✓ Branch 0 taken 1011 times.
✓ Branch 1 taken 337 times.
 1348 for (int i = 0; i<3; i++)
462
2/2
✓ Branch 0 taken 490 times.
✓ Branch 1 taken 521 times.
 1011 if (d->param[i])
463 490 d->depth = FFMAX(d->depth, d->param[i]->depth+1);
464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 337 times.
 337 if (d->depth > MAX_DEPTH) {
465 ✗ av_expr_free(d);
466 ✗ return AVERROR(EINVAL);
467 }
468
469 337 d->type = e_func0;
470
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 337 times.
 337 if (strmatch(next, "sinh" )) d->func0 = sinh;
471
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 337 times.
 337 else if (strmatch(next, "cosh" )) d->func0 = cosh;
472
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 337 times.
 337 else if (strmatch(next, "tanh" )) d->func0 = tanh;
473
2/2
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 307 times.
 337 else if (strmatch(next, "sin" )) d->func0 = sin;
474
2/2
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 294 times.
 307 else if (strmatch(next, "cos" )) d->func0 = cos;
475
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 294 times.
 294 else if (strmatch(next, "tan" )) d->func0 = tan;
476
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 294 times.
 294 else if (strmatch(next, "atan" )) d->func0 = atan;
477
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 294 times.
 294 else if (strmatch(next, "asin" )) d->func0 = asin;
478
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 294 times.
 294 else if (strmatch(next, "acos" )) d->func0 = acos;
479
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 294 times.
 294 else if (strmatch(next, "exp" )) d->func0 = exp;
480
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 293 times.
 294 else if (strmatch(next, "log" )) d->func0 = log;
481
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 293 times.
 293 else if (strmatch(next, "abs" )) d->func0 = fabs;
482
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 293 times.
 293 else if (strmatch(next, "time" )) d->func0 = etime;
483
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 291 times.
 293 else if (strmatch(next, "squish")) d->type = e_squish;
484
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 289 times.
 291 else if (strmatch(next, "gauss" )) d->type = e_gauss;
485
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 281 times.
 289 else if (strmatch(next, "mod" )) d->type = e_mod;
486
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 279 times.
 281 else if (strmatch(next, "max" )) d->type = e_max;
487
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 278 times.
 279 else if (strmatch(next, "min" )) d->type = e_min;
488
2/2
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 267 times.
 278 else if (strmatch(next, "eq" )) d->type = e_eq;
489
2/2
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 260 times.
 267 else if (strmatch(next, "gte" )) d->type = e_gte;
490
2/2
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 255 times.
 260 else if (strmatch(next, "gt" )) d->type = e_gt;
491
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 249 times.
 255 else if (strmatch(next, "lte" )) d->type = e_lte;
492
2/2
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 241 times.
 249 else if (strmatch(next, "lt" )) d->type = e_lt;
493
2/2
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 216 times.
 241 else if (strmatch(next, "ld" )) d->type = e_ld;
494
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 212 times.
 216 else if (strmatch(next, "isnan" )) d->type = e_isnan;
495
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 209 times.
 212 else if (strmatch(next, "isinf" )) d->type = e_isinf;
496
2/2
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 193 times.
 209 else if (strmatch(next, "st" )) d->type = e_st;
497
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 189 times.
 193 else if (strmatch(next, "while" )) d->type = e_while;
498
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 187 times.
 189 else if (strmatch(next, "taylor")) d->type = e_taylor;
499
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 185 times.
 187 else if (strmatch(next, "root" )) d->type = e_root;
500
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 181 times.
 185 else if (strmatch(next, "floor" )) d->type = e_floor;
501
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 179 times.
 181 else if (strmatch(next, "ceil" )) d->type = e_ceil;
502
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 177 times.
 179 else if (strmatch(next, "trunc" )) d->type = e_trunc;
503
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 177 times.
 177 else if (strmatch(next, "round" )) d->type = e_round;
504
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 175 times.
 177 else if (strmatch(next, "sqrt" )) d->type = e_sqrt;
505
2/2
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 162 times.
 175 else if (strmatch(next, "not" )) d->type = e_not;
506
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 159 times.
 162 else if (strmatch(next, "pow" )) d->type = e_pow;
507
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 157 times.
 159 else if (strmatch(next, "print" )) d->type = e_print;
508
2/2
✓ Branch 1 taken 107 times.
✓ Branch 2 taken 50 times.
 157 else if (strmatch(next, "random")) d->type = e_random;
509
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 50 times.
 50 else if (strmatch(next, "randomi")) d->type = e_randomi;
510
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 49 times.
 50 else if (strmatch(next, "hypot" )) d->type = e_hypot;
511
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 48 times.
 49 else if (strmatch(next, "gcd" )) d->type = e_gcd;
512
2/2
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 35 times.
 48 else if (strmatch(next, "if" )) d->type = e_if;
513
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 31 times.
 35 else if (strmatch(next, "ifnot" )) d->type = e_ifnot;
514
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 29 times.
 31 else if (strmatch(next, "bitand")) d->type = e_bitand;
515
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 28 times.
 29 else if (strmatch(next, "bitor" )) d->type = e_bitor;
516
2/2
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 16 times.
 28 else if (strmatch(next, "between"))d->type = e_between;
517
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 13 times.
 16 else if (strmatch(next, "clip" )) d->type = e_clip;
518
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
 13 else if (strmatch(next, "atan2" )) d->type = e_atan2;
519
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 11 times.
 13 else if (strmatch(next, "lerp" )) d->type = e_lerp;
520
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 else if (strmatch(next, "sgn" )) d->type = e_sgn;
521 else {
522
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 11 for (i=0; p->func1_names && p->func1_names[i]; i++) {
523
1/2
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
 4 if (strmatch(next, p->func1_names[i])) {
524 4 d->func1 = p->funcs1[i];
525 4 d->type = e_func1;
526 4 d->const_index = i;
527 4 *e = d;
528 4 return 0;
529 }
530 }
531
532
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 7 for (i=0; p->func2_names && p->func2_names[i]; i++) {
533
1/2
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
 6 if (strmatch(next, p->func2_names[i])) {
534 6 d->func2 = p->funcs2[i];
535 6 d->type = e_func2;
536 6 d->const_index = i;
537 6 *e = d;
538 6 return 0;
539 }
540 }
541
542 1 av_log(p, AV_LOG_ERROR, "Unknown function in '%s'\n", s0);
543 1 av_expr_free(d);
544 1 return AVERROR(EINVAL);
545 }
546
547 326 *e = d;
548 326 return 0;
549 }
550
551 1557 static AVExpr *make_eval_expr(int type, int value, AVExpr *p0, AVExpr *p1)
552 {
553 1557 int depth = FFMAX(p0->depth, p1->depth) + 1;
554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1557 times.
 1557 if (depth > MAX_DEPTH)
555 ✗ return NULL;
556 1557 AVExpr *e = av_mallocz(sizeof(AVExpr));
557
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1557 times.
 1557 if (!e)
558 ✗ return NULL;
559 1557 e->type =type ;
560 1557 e->value =value ;
561 1557 e->param[0] =p0 ;
562 1557 e->param[1] =p1 ;
563 1557 e->depth = depth;
564 1557 return e;
565 }
566
567 84420 static int parse_pow(AVExpr **e, Parser *p, int *sign)
568 {
569 84420 *sign= (*p->s == '+') - (*p->s == '-');
570 84420 p->s += *sign&1;
571 84420 return parse_primary(e, p);
572 }
573
574 84423 static int parse_dB(AVExpr **e, Parser *p, int *sign)
575 {
576 /* do not filter out the negative sign when parsing a dB value.
577 for example, -3dB is not the same as -(3dB) */
578
2/2
✓ Branch 0 taken 520 times.
✓ Branch 1 taken 83903 times.
 84423 if (*p->s == '-') {
579 char *next;
580 520 av_unused double ignored = strtod(p->s, &next);
581
5/6
✓ Branch 0 taken 497 times.
✓ Branch 1 taken 23 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 494 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 520 if (next != p->s && next[0] == 'd' && next[1] == 'B') {
582 3 *sign = 0;
583 3 return parse_primary(e, p);
584 }
585 }
586 84420 return parse_pow(e, p, sign);
587 }
588
589 84191 static int parse_factor(AVExpr **e, Parser *p)
590 {
591 int sign, sign2, ret;
592 AVExpr *e0, *e1, *e2;
593
2/2
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 84158 times.
 84191 if ((ret = parse_dB(&e0, p, &sign)) < 0)
594 33 return ret;
595
2/2
✓ Branch 0 taken 232 times.
✓ Branch 1 taken 84158 times.
 168548 while(p->s[0]=='^'){
596 232 e1 = e0;
597 232 p->s++;
598
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 232 times.
 232 if ((ret = parse_dB(&e2, p, &sign2)) < 0) {
599 ✗ av_expr_free(e1);
600 ✗ return ret;
601 }
602 232 e0 = make_eval_expr(e_pow, 1, e1, e2);
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 232 times.
 232 if (!e0) {
604 ✗ av_expr_free(e1);
605 ✗ av_expr_free(e2);
606 ✗ return AVERROR(ENOMEM);
607 }
608
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 232 times.
 232 if (e0->param[1]) e0->param[1]->value *= (sign2|1);
609 }
610
1/2
✓ Branch 0 taken 84158 times.
✗ Branch 1 not taken.
 84158 if (e0) e0->value *= (sign|1);
611
612 84158 *e = e0;
613 84158 return 0;
614 }
615
616 83262 static int parse_term(AVExpr **e, Parser *p)
617 {
618 int ret;
619 AVExpr *e0, *e1, *e2;
620
2/2
✓ Branch 1 taken 31 times.
✓ Branch 2 taken 83231 times.
 83262 if ((ret = parse_factor(&e0, p)) < 0)
621 31 return ret;
622
4/4
✓ Branch 0 taken 568 times.
✓ Branch 1 taken 83590 times.
✓ Branch 2 taken 361 times.
✓ Branch 3 taken 83229 times.
 84158 while (p->s[0]=='*' || p->s[0]=='/') {
623 929 int c= *p->s++;
624 929 e1 = e0;
625
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 927 times.
 929 if ((ret = parse_factor(&e2, p)) < 0) {
626 2 av_expr_free(e1);
627 2 return ret;
628 }
629
2/2
✓ Branch 0 taken 568 times.
✓ Branch 1 taken 359 times.
 927 e0 = make_eval_expr(c == '*' ? e_mul : e_div, 1, e1, e2);
630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 927 times.
 927 if (!e0) {
631 ✗ av_expr_free(e1);
632 ✗ av_expr_free(e2);
633 ✗ return AVERROR(ENOMEM);
634 }
635 }
636 83229 *e = e0;
637 83229 return 0;
638 }
639
640 82881 static int parse_subexpr(AVExpr **e, Parser *p)
641 {
642 int ret;
643 AVExpr *e0, *e1, *e2;
644
2/2
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 82849 times.
 82881 if ((ret = parse_term(&e0, p)) < 0)
645 32 return ret;
646
4/4
✓ Branch 0 taken 169 times.
✓ Branch 1 taken 83060 times.
✓ Branch 2 taken 212 times.
✓ Branch 3 taken 82848 times.
 83229 while (*p->s == '+' || *p->s == '-') {
647 381 e1 = e0;
648
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 380 times.
 381 if ((ret = parse_term(&e2, p)) < 0) {
649 1 av_expr_free(e1);
650 1 return ret;
651 }
652 380 e0 = make_eval_expr(e_add, 1, e1, e2);
653
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380 times.
 380 if (!e0) {
654 ✗ av_expr_free(e1);
655 ✗ av_expr_free(e2);
656 ✗ return AVERROR(ENOMEM);
657 }
658 };
659
660 82848 *e = e0;
661 82848 return 0;
662 }
663
664 82863 static int parse_expr(AVExpr **e, Parser *p)
665 {
666 int ret;
667 AVExpr *e0, *e1, *e2;
668
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82863 times.
 82863 if (p->stack_index <= 0) //protect against stack overflows
669 ✗ return AVERROR(EINVAL);
670 82863 p->stack_index--;
671
672
2/2
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 82830 times.
 82863 if ((ret = parse_subexpr(&e0, p)) < 0)
673 33 return ret;
674
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 82830 times.
 82848 while (*p->s == ';') {
675 18 p->s++;
676 18 e1 = e0;
677
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
 18 if ((ret = parse_subexpr(&e2, p)) < 0) {
678 ✗ av_expr_free(e1);
679 ✗ return ret;
680 }
681 18 e0 = make_eval_expr(e_last, 1, e1, e2);
682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 if (!e0) {
683 ✗ av_expr_free(e1);
684 ✗ av_expr_free(e2);
685 ✗ return AVERROR(ENOMEM);
686 }
687 };
688
689 82830 p->stack_index++;
690 82830 *e = e0;
691 82830 return 0;
692 }
693
694 85900 static int verify_expr(AVExpr *e)
695 {
696
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 85899 times.
 85900 if (!e) return 0;
697
6/6
✓ Branch 0 taken 84008 times.
✓ Branch 1 taken 214 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 19 times.
✓ Branch 4 taken 17 times.
✓ Branch 5 taken 1639 times.
 85899 switch (e->type) {
698 84008 case e_value:
699 84008 case e_const: return 1;
700 214 case e_func0:
701 case e_func1:
702 case e_squish:
703 case e_ld:
704 case e_gauss:
705 case e_isnan:
706 case e_isinf:
707 case e_floor:
708 case e_ceil:
709 case e_trunc:
710 case e_round:
711 case e_sqrt:
712 case e_not:
713 case e_random:
714 case e_sgn:
715
3/4
✓ Branch 1 taken 214 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 213 times.
✓ Branch 4 taken 1 times.
 214 return verify_expr(e->param[0]) && !e->param[1];
716 2 case e_print:
717 2 return verify_expr(e->param[0])
718
2/6
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 2 && (!e->param[1] || verify_expr(e->param[1]));
719 19 case e_if:
720 case e_ifnot:
721 case e_taylor:
722
1/2
✓ Branch 2 taken 19 times.
✗ Branch 3 not taken.
 38 return verify_expr(e->param[0]) && verify_expr(e->param[1])
723
4/6
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 5 times.
✓ Branch 5 taken 14 times.
✗ Branch 6 not taken.
 38 && (!e->param[2] || verify_expr(e->param[2]));
724 17 case e_between:
725 case e_clip:
726 case e_lerp:
727 case e_randomi:
728
1/2
✓ Branch 1 taken 17 times.
✗ Branch 2 not taken.
 34 return verify_expr(e->param[0]) &&
729
3/4
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 1 times.
 34 verify_expr(e->param[1]) &&
730 17 verify_expr(e->param[2]);
731
3/6
✓ Branch 1 taken 1639 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 1639 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1639 times.
✗ Branch 7 not taken.
 1639 default: return verify_expr(e->param[0]) && verify_expr(e->param[1]) && !e->param[2];
732 }
733 }
734
735 82337 int av_expr_parse(AVExpr **expr, const char *s,
736 const char * const *const_names,
737 const char * const *func1_names, double (* const *funcs1)(void *, double),
738 const char * const *func2_names, double (* const *funcs2)(void *, double, double),
739 int log_offset, void *log_ctx)
740 {
741 82337 Parser p = { 0 };
742 82337 AVExpr *e = NULL;
743 82337 char *w = av_malloc(strlen(s) + 1);
744 82337 char *wp = w;
745 82337 const char *s0 = s;
746 82337 int ret = 0;
747
748
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82337 times.
 82337 if (!w)
749 ✗ return AVERROR(ENOMEM);
750
751
2/2
✓ Branch 0 taken 176551 times.
✓ Branch 1 taken 82337 times.
 258888 while (*s)
752
2/2
✓ Branch 0 taken 176104 times.
✓ Branch 1 taken 447 times.
 176551 if (!av_isspace(*s++)) *wp++ = s[-1];
753 82337 *wp++ = 0;
754
755 82337 p.class = &eval_class;
756 82337 p.stack_index=100;
757 82337 p.s= w;
758 82337 p.const_names = const_names;
759 82337 p.funcs1 = funcs1;
760 82337 p.func1_names = func1_names;
761 82337 p.funcs2 = funcs2;
762 82337 p.func2_names = func2_names;
763 82337 p.log_offset = log_offset;
764 82337 p.log_ctx = log_ctx;
765
766
2/2
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 82308 times.
 82337 if ((ret = parse_expr(&e, &p)) < 0)
767 29 goto end;
768
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 82303 times.
 82308 if (*p.s) {
769 5 av_log(&p, AV_LOG_ERROR, "Invalid chars '%s' at the end of expression '%s'\n", p.s, s0);
770 5 ret = AVERROR(EINVAL);
771 5 goto end;
772 }
773
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 82301 times.
 82303 if (!verify_expr(e)) {
774 2 ret = AVERROR(EINVAL);
775 2 goto end;
776 }
777 82301 AVExprRoot *r = av_realloc(e, sizeof(*r));
778
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82301 times.
 82301 if (!r) {
779 ✗ ret = AVERROR(ENOMEM);
780 ✗ goto end;
781 }
782 82301 e = (AVExpr*)r;
783 82301 e->root = 1;
784 82301 r->var= av_mallocz(sizeof(double) *VARS);
785 82301 r->prng_state = av_mallocz(sizeof(*r->prng_state) *VARS);
786
2/4
✓ Branch 0 taken 82301 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 82301 times.
 82301 if (!r->var || !r->prng_state) {
787 ✗ ret = AVERROR(ENOMEM);
788 ✗ goto end;
789 }
790 82301 *expr = e;
791 82301 e = NULL;
792 82337 end:
793 82337 av_expr_free(e);
794 82337 av_free(w);
795 82337 return ret;
796 }
797
798 33963 static int expr_count(AVExpr *e, unsigned *counter, int size, int type)
799 {
800 int i;
801
802
3/6
✓ Branch 0 taken 33963 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 33963 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 33963 times.
 33963 if (!e || !counter || !size)
803 ✗ return AVERROR(EINVAL);
804
805
5/6
✓ Branch 0 taken 5734 times.
✓ Branch 1 taken 28265 times.
✓ Branch 2 taken 5734 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 36 times.
✓ Branch 5 taken 5698 times.
 33999 for (i = 0; e->type != type && i < 3 && e->param[i]; i++)
806 36 expr_count(e->param[i], counter, size, type);
807
808
3/4
✓ Branch 0 taken 28265 times.
✓ Branch 1 taken 5698 times.
✓ Branch 2 taken 28265 times.
✗ Branch 3 not taken.
 33963 if (e->type == type && e->const_index < size)
809 28265 counter[e->const_index]++;
810
811 33963 return 0;
812 }
813
814 33927 int av_expr_count_vars(AVExpr *e, unsigned *counter, int size)
815 {
816 33927 return expr_count(e, counter, size, e_const);
817 }
818
819 ✗ int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg)
820 {
821 ✗ return expr_count(e, counter, size, ((int[]){e_const, e_func1, e_func2})[arg]);
822 }
823
824 22065261 double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
825 {
826 av_assert1(e->root);
827 22065261 AVExprRoot *r = (AVExprRoot *)e;
828 22065261 Parser p = {
829 .class = &eval_class,
830 .const_values = const_values,
831 .opaque = opaque,
832 22065261 .var = r->var,
833 22065261 .prng_state = r->prng_state,
834 };
835
836 22065261 return eval_expr(&p, e);
837 }
838
839 58464 int av_expr_parse_and_eval(double *d, const char *s,
840 const char * const *const_names, const double *const_values,
841 const char * const *func1_names, double (* const *funcs1)(void *, double),
842 const char * const *func2_names, double (* const *funcs2)(void *, double, double),
843 void *opaque, int log_offset, void *log_ctx)
844 {
845 58464 AVExpr *e = NULL;
846 58464 int ret = av_expr_parse(&e, s, const_names, func1_names, funcs1, func2_names, funcs2, log_offset, log_ctx);
847
848
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 58428 times.
 58464 if (ret < 0) {
849 36 *d = NAN;
850 36 return ret;
851 }
852 58428 *d = av_expr_eval(e, const_values, opaque);
853 58428 av_expr_free(e);
854
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 58419 times.
 58428 return isnan(*d) ? AVERROR(EINVAL) : 0;
855 }
856