FFmpeg
vf_lut3d.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Clément Bœsch
3  * Copyright (c) 2018 Paul B Mahol
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  * 3D Lookup table filter
25  */
26 
27 #include "float.h"
28 
29 #include "libavutil/opt.h"
30 #include "libavutil/file.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/intfloat.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "drawutils.h"
36 #include "formats.h"
37 #include "internal.h"
38 #include "video.h"
39 #include "lut3d.h"
40 
41 #define R 0
42 #define G 1
43 #define B 2
44 #define A 3
45 
46 #define OFFSET(x) offsetof(LUT3DContext, x)
47 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
48 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
49 #define COMMON_OPTIONS \
50  { "interp", "select interpolation mode", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERPOLATE_TETRAHEDRAL}, 0, NB_INTERP_MODE-1, TFLAGS, "interp_mode" }, \
51  { "nearest", "use values from the nearest defined points", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_NEAREST}, 0, 0, TFLAGS, "interp_mode" }, \
52  { "trilinear", "interpolate values using the 8 points defining a cube", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TRILINEAR}, 0, 0, TFLAGS, "interp_mode" }, \
53  { "tetrahedral", "interpolate values using a tetrahedron", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_TETRAHEDRAL}, 0, 0, TFLAGS, "interp_mode" }, \
54  { "pyramid", "interpolate values using a pyramid", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_PYRAMID}, 0, 0, TFLAGS, "interp_mode" }, \
55  { "prism", "interpolate values using a prism", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_PRISM}, 0, 0, TFLAGS, "interp_mode" }, \
56  { NULL }
57 
58 #define EXPONENT_MASK 0x7F800000
59 #define MANTISSA_MASK 0x007FFFFF
60 #define SIGN_MASK 0x80000000
61 
62 static inline float sanitizef(float f)
63 {
64  union av_intfloat32 t;
65  t.f = f;
66 
67  if ((t.i & EXPONENT_MASK) == EXPONENT_MASK) {
68  if ((t.i & MANTISSA_MASK) != 0) {
69  // NAN
70  return 0.0f;
71  } else if (t.i & SIGN_MASK) {
72  // -INF
73  return -FLT_MAX;
74  } else {
75  // +INF
76  return FLT_MAX;
77  }
78  }
79  return f;
80 }
81 
82 static inline float lerpf(float v0, float v1, float f)
83 {
84  return v0 + (v1 - v0) * f;
85 }
86 
87 static inline struct rgbvec lerp(const struct rgbvec *v0, const struct rgbvec *v1, float f)
88 {
89  struct rgbvec v = {
90  lerpf(v0->r, v1->r, f), lerpf(v0->g, v1->g, f), lerpf(v0->b, v1->b, f)
91  };
92  return v;
93 }
94 
95 #define NEAR(x) ((int)((x) + .5))
96 #define PREV(x) ((int)(x))
97 #define NEXT(x) (FFMIN((int)(x) + 1, lut3d->lutsize - 1))
98 
99 /**
100  * Get the nearest defined point
101  */
102 static inline struct rgbvec interp_nearest(const LUT3DContext *lut3d,
103  const struct rgbvec *s)
104 {
105  return lut3d->lut[NEAR(s->r) * lut3d->lutsize2 + NEAR(s->g) * lut3d->lutsize + NEAR(s->b)];
106 }
107 
108 /**
109  * Interpolate using the 8 vertices of a cube
110  * @see https://en.wikipedia.org/wiki/Trilinear_interpolation
111  */
112 static inline struct rgbvec interp_trilinear(const LUT3DContext *lut3d,
113  const struct rgbvec *s)
114 {
115  const int lutsize2 = lut3d->lutsize2;
116  const int lutsize = lut3d->lutsize;
117  const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
118  const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
119  const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
120  const struct rgbvec c000 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + prev[2]];
121  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
122  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
123  const struct rgbvec c011 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + next[2]];
124  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
125  const struct rgbvec c101 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + next[2]];
126  const struct rgbvec c110 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + prev[2]];
127  const struct rgbvec c111 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + next[2]];
128  const struct rgbvec c00 = lerp(&c000, &c100, d.r);
129  const struct rgbvec c10 = lerp(&c010, &c110, d.r);
130  const struct rgbvec c01 = lerp(&c001, &c101, d.r);
131  const struct rgbvec c11 = lerp(&c011, &c111, d.r);
132  const struct rgbvec c0 = lerp(&c00, &c10, d.g);
133  const struct rgbvec c1 = lerp(&c01, &c11, d.g);
134  const struct rgbvec c = lerp(&c0, &c1, d.b);
135  return c;
136 }
137 
138 static inline struct rgbvec interp_pyramid(const LUT3DContext *lut3d,
139  const struct rgbvec *s)
140 {
141  const int lutsize2 = lut3d->lutsize2;
142  const int lutsize = lut3d->lutsize;
143  const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
144  const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
145  const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
146  const struct rgbvec c000 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + prev[2]];
147  const struct rgbvec c111 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + next[2]];
148  struct rgbvec c;
149 
150  if (d.g > d.r && d.b > d.r) {
151  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
152  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
153  const struct rgbvec c011 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + next[2]];
154 
155  c.r = c000.r + (c111.r - c011.r) * d.r + (c010.r - c000.r) * d.g + (c001.r - c000.r) * d.b +
156  (c011.r - c001.r - c010.r + c000.r) * d.g * d.b;
157  c.g = c000.g + (c111.g - c011.g) * d.r + (c010.g - c000.g) * d.g + (c001.g - c000.g) * d.b +
158  (c011.g - c001.g - c010.g + c000.g) * d.g * d.b;
159  c.b = c000.b + (c111.b - c011.b) * d.r + (c010.b - c000.b) * d.g + (c001.b - c000.b) * d.b +
160  (c011.b - c001.b - c010.b + c000.b) * d.g * d.b;
161  } else if (d.r > d.g && d.b > d.g) {
162  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
163  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
164  const struct rgbvec c101 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + next[2]];
165 
166  c.r = c000.r + (c100.r - c000.r) * d.r + (c111.r - c101.r) * d.g + (c001.r - c000.r) * d.b +
167  (c101.r - c001.r - c100.r + c000.r) * d.r * d.b;
168  c.g = c000.g + (c100.g - c000.g) * d.r + (c111.g - c101.g) * d.g + (c001.g - c000.g) * d.b +
169  (c101.g - c001.g - c100.g + c000.g) * d.r * d.b;
170  c.b = c000.b + (c100.b - c000.b) * d.r + (c111.b - c101.b) * d.g + (c001.b - c000.b) * d.b +
171  (c101.b - c001.b - c100.b + c000.b) * d.r * d.b;
172  } else {
173  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
174  const struct rgbvec c110 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + prev[2]];
175  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
176 
177  c.r = c000.r + (c100.r - c000.r) * d.r + (c010.r - c000.r) * d.g + (c111.r - c110.r) * d.b +
178  (c110.r - c100.r - c010.r + c000.r) * d.r * d.g;
179  c.g = c000.g + (c100.g - c000.g) * d.r + (c010.g - c000.g) * d.g + (c111.g - c110.g) * d.b +
180  (c110.g - c100.g - c010.g + c000.g) * d.r * d.g;
181  c.b = c000.b + (c100.b - c000.b) * d.r + (c010.b - c000.b) * d.g + (c111.b - c110.b) * d.b +
182  (c110.b - c100.b - c010.b + c000.b) * d.r * d.g;
183  }
184 
185  return c;
186 }
187 
188 static inline struct rgbvec interp_prism(const LUT3DContext *lut3d,
189  const struct rgbvec *s)
190 {
191  const int lutsize2 = lut3d->lutsize2;
192  const int lutsize = lut3d->lutsize;
193  const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
194  const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
195  const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
196  const struct rgbvec c000 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + prev[2]];
197  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
198  const struct rgbvec c101 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + next[2]];
199  const struct rgbvec c111 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + next[2]];
200  struct rgbvec c;
201 
202  if (d.b > d.r) {
203  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
204  const struct rgbvec c011 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + next[2]];
205 
206  c.r = c000.r + (c001.r - c000.r) * d.b + (c101.r - c001.r) * d.r + (c010.r - c000.r) * d.g +
207  (c000.r - c010.r - c001.r + c011.r) * d.b * d.g +
208  (c001.r - c011.r - c101.r + c111.r) * d.r * d.g;
209  c.g = c000.g + (c001.g - c000.g) * d.b + (c101.g - c001.g) * d.r + (c010.g - c000.g) * d.g +
210  (c000.g - c010.g - c001.g + c011.g) * d.b * d.g +
211  (c001.g - c011.g - c101.g + c111.g) * d.r * d.g;
212  c.b = c000.b + (c001.b - c000.b) * d.b + (c101.b - c001.b) * d.r + (c010.b - c000.b) * d.g +
213  (c000.b - c010.b - c001.b + c011.b) * d.b * d.g +
214  (c001.b - c011.b - c101.b + c111.b) * d.r * d.g;
215  } else {
216  const struct rgbvec c110 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + prev[2]];
217  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
218 
219  c.r = c000.r + (c101.r - c100.r) * d.b + (c100.r - c000.r) * d.r + (c010.r - c000.r) * d.g +
220  (c100.r - c110.r - c101.r + c111.r) * d.b * d.g +
221  (c000.r - c010.r - c100.r + c110.r) * d.r * d.g;
222  c.g = c000.g + (c101.g - c100.g) * d.b + (c100.g - c000.g) * d.r + (c010.g - c000.g) * d.g +
223  (c100.g - c110.g - c101.g + c111.g) * d.b * d.g +
224  (c000.g - c010.g - c100.g + c110.g) * d.r * d.g;
225  c.b = c000.b + (c101.b - c100.b) * d.b + (c100.b - c000.b) * d.r + (c010.b - c000.b) * d.g +
226  (c100.b - c110.b - c101.b + c111.b) * d.b * d.g +
227  (c000.b - c010.b - c100.b + c110.b) * d.r * d.g;
228  }
229 
230  return c;
231 }
232 
233 /**
234  * Tetrahedral interpolation. Based on code found in Truelight Software Library paper.
235  * @see http://www.filmlight.ltd.uk/pdf/whitepapers/FL-TL-TN-0057-SoftwareLib.pdf
236  */
237 static inline struct rgbvec interp_tetrahedral(const LUT3DContext *lut3d,
238  const struct rgbvec *s)
239 {
240  const int lutsize2 = lut3d->lutsize2;
241  const int lutsize = lut3d->lutsize;
242  const int prev[] = {PREV(s->r), PREV(s->g), PREV(s->b)};
243  const int next[] = {NEXT(s->r), NEXT(s->g), NEXT(s->b)};
244  const struct rgbvec d = {s->r - prev[0], s->g - prev[1], s->b - prev[2]};
245  const struct rgbvec c000 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + prev[2]];
246  const struct rgbvec c111 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + next[2]];
247  struct rgbvec c;
248  if (d.r > d.g) {
249  if (d.g > d.b) {
250  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
251  const struct rgbvec c110 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + prev[2]];
252  c.r = (1-d.r) * c000.r + (d.r-d.g) * c100.r + (d.g-d.b) * c110.r + (d.b) * c111.r;
253  c.g = (1-d.r) * c000.g + (d.r-d.g) * c100.g + (d.g-d.b) * c110.g + (d.b) * c111.g;
254  c.b = (1-d.r) * c000.b + (d.r-d.g) * c100.b + (d.g-d.b) * c110.b + (d.b) * c111.b;
255  } else if (d.r > d.b) {
256  const struct rgbvec c100 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + prev[2]];
257  const struct rgbvec c101 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + next[2]];
258  c.r = (1-d.r) * c000.r + (d.r-d.b) * c100.r + (d.b-d.g) * c101.r + (d.g) * c111.r;
259  c.g = (1-d.r) * c000.g + (d.r-d.b) * c100.g + (d.b-d.g) * c101.g + (d.g) * c111.g;
260  c.b = (1-d.r) * c000.b + (d.r-d.b) * c100.b + (d.b-d.g) * c101.b + (d.g) * c111.b;
261  } else {
262  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
263  const struct rgbvec c101 = lut3d->lut[next[0] * lutsize2 + prev[1] * lutsize + next[2]];
264  c.r = (1-d.b) * c000.r + (d.b-d.r) * c001.r + (d.r-d.g) * c101.r + (d.g) * c111.r;
265  c.g = (1-d.b) * c000.g + (d.b-d.r) * c001.g + (d.r-d.g) * c101.g + (d.g) * c111.g;
266  c.b = (1-d.b) * c000.b + (d.b-d.r) * c001.b + (d.r-d.g) * c101.b + (d.g) * c111.b;
267  }
268  } else {
269  if (d.b > d.g) {
270  const struct rgbvec c001 = lut3d->lut[prev[0] * lutsize2 + prev[1] * lutsize + next[2]];
271  const struct rgbvec c011 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + next[2]];
272  c.r = (1-d.b) * c000.r + (d.b-d.g) * c001.r + (d.g-d.r) * c011.r + (d.r) * c111.r;
273  c.g = (1-d.b) * c000.g + (d.b-d.g) * c001.g + (d.g-d.r) * c011.g + (d.r) * c111.g;
274  c.b = (1-d.b) * c000.b + (d.b-d.g) * c001.b + (d.g-d.r) * c011.b + (d.r) * c111.b;
275  } else if (d.b > d.r) {
276  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
277  const struct rgbvec c011 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + next[2]];
278  c.r = (1-d.g) * c000.r + (d.g-d.b) * c010.r + (d.b-d.r) * c011.r + (d.r) * c111.r;
279  c.g = (1-d.g) * c000.g + (d.g-d.b) * c010.g + (d.b-d.r) * c011.g + (d.r) * c111.g;
280  c.b = (1-d.g) * c000.b + (d.g-d.b) * c010.b + (d.b-d.r) * c011.b + (d.r) * c111.b;
281  } else {
282  const struct rgbvec c010 = lut3d->lut[prev[0] * lutsize2 + next[1] * lutsize + prev[2]];
283  const struct rgbvec c110 = lut3d->lut[next[0] * lutsize2 + next[1] * lutsize + prev[2]];
284  c.r = (1-d.g) * c000.r + (d.g-d.r) * c010.r + (d.r-d.b) * c110.r + (d.b) * c111.r;
285  c.g = (1-d.g) * c000.g + (d.g-d.r) * c010.g + (d.r-d.b) * c110.g + (d.b) * c111.g;
286  c.b = (1-d.g) * c000.b + (d.g-d.r) * c010.b + (d.r-d.b) * c110.b + (d.b) * c111.b;
287  }
288  }
289  return c;
290 }
291 
292 static inline float prelut_interp_1d_linear(const Lut3DPreLut *prelut,
293  int idx, const float s)
294 {
295  const int lut_max = prelut->size - 1;
296  const float scaled = (s - prelut->min[idx]) * prelut->scale[idx];
297  const float x = av_clipf(scaled, 0.0f, lut_max);
298  const int prev = PREV(x);
299  const int next = FFMIN((int)(x) + 1, lut_max);
300  const float p = prelut->lut[idx][prev];
301  const float n = prelut->lut[idx][next];
302  const float d = x - (float)prev;
303  return lerpf(p, n, d);
304 }
305 
306 static inline struct rgbvec apply_prelut(const Lut3DPreLut *prelut,
307  const struct rgbvec *s)
308 {
309  struct rgbvec c;
310 
311  if (prelut->size <= 0)
312  return *s;
313 
314  c.r = prelut_interp_1d_linear(prelut, 0, s->r);
315  c.g = prelut_interp_1d_linear(prelut, 1, s->g);
316  c.b = prelut_interp_1d_linear(prelut, 2, s->b);
317  return c;
318 }
319 
320 #define DEFINE_INTERP_FUNC_PLANAR(name, nbits, depth) \
321 static int interp_##nbits##_##name##_p##depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
322 { \
323  int x, y; \
324  const LUT3DContext *lut3d = ctx->priv; \
325  const Lut3DPreLut *prelut = &lut3d->prelut; \
326  const ThreadData *td = arg; \
327  const AVFrame *in = td->in; \
328  const AVFrame *out = td->out; \
329  const int direct = out == in; \
330  const int slice_start = (in->height * jobnr ) / nb_jobs; \
331  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
332  uint8_t *grow = out->data[0] + slice_start * out->linesize[0]; \
333  uint8_t *brow = out->data[1] + slice_start * out->linesize[1]; \
334  uint8_t *rrow = out->data[2] + slice_start * out->linesize[2]; \
335  uint8_t *arow = out->data[3] + slice_start * out->linesize[3]; \
336  const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0]; \
337  const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1]; \
338  const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2]; \
339  const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3]; \
340  const float lut_max = lut3d->lutsize - 1; \
341  const float scale_f = 1.0f / ((1<<depth) - 1); \
342  const float scale_r = lut3d->scale.r * lut_max; \
343  const float scale_g = lut3d->scale.g * lut_max; \
344  const float scale_b = lut3d->scale.b * lut_max; \
345  \
346  for (y = slice_start; y < slice_end; y++) { \
347  uint##nbits##_t *dstg = (uint##nbits##_t *)grow; \
348  uint##nbits##_t *dstb = (uint##nbits##_t *)brow; \
349  uint##nbits##_t *dstr = (uint##nbits##_t *)rrow; \
350  uint##nbits##_t *dsta = (uint##nbits##_t *)arow; \
351  const uint##nbits##_t *srcg = (const uint##nbits##_t *)srcgrow; \
352  const uint##nbits##_t *srcb = (const uint##nbits##_t *)srcbrow; \
353  const uint##nbits##_t *srcr = (const uint##nbits##_t *)srcrrow; \
354  const uint##nbits##_t *srca = (const uint##nbits##_t *)srcarow; \
355  for (x = 0; x < in->width; x++) { \
356  const struct rgbvec rgb = {srcr[x] * scale_f, \
357  srcg[x] * scale_f, \
358  srcb[x] * scale_f}; \
359  const struct rgbvec prelut_rgb = apply_prelut(prelut, &rgb); \
360  const struct rgbvec scaled_rgb = {av_clipf(prelut_rgb.r * scale_r, 0, lut_max), \
361  av_clipf(prelut_rgb.g * scale_g, 0, lut_max), \
362  av_clipf(prelut_rgb.b * scale_b, 0, lut_max)}; \
363  struct rgbvec vec = interp_##name(lut3d, &scaled_rgb); \
364  dstr[x] = av_clip_uintp2(vec.r * (float)((1<<depth) - 1), depth); \
365  dstg[x] = av_clip_uintp2(vec.g * (float)((1<<depth) - 1), depth); \
366  dstb[x] = av_clip_uintp2(vec.b * (float)((1<<depth) - 1), depth); \
367  if (!direct && in->linesize[3]) \
368  dsta[x] = srca[x]; \
369  } \
370  grow += out->linesize[0]; \
371  brow += out->linesize[1]; \
372  rrow += out->linesize[2]; \
373  arow += out->linesize[3]; \
374  srcgrow += in->linesize[0]; \
375  srcbrow += in->linesize[1]; \
376  srcrrow += in->linesize[2]; \
377  srcarow += in->linesize[3]; \
378  } \
379  return 0; \
380 }
381 
382 DEFINE_INTERP_FUNC_PLANAR(nearest, 8, 8)
383 DEFINE_INTERP_FUNC_PLANAR(trilinear, 8, 8)
384 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 8, 8)
385 DEFINE_INTERP_FUNC_PLANAR(pyramid, 8, 8)
386 DEFINE_INTERP_FUNC_PLANAR(prism, 8, 8)
387 
388 DEFINE_INTERP_FUNC_PLANAR(nearest, 16, 9)
389 DEFINE_INTERP_FUNC_PLANAR(trilinear, 16, 9)
390 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 9)
391 DEFINE_INTERP_FUNC_PLANAR(pyramid, 16, 9)
392 DEFINE_INTERP_FUNC_PLANAR(prism, 16, 9)
393 
394 DEFINE_INTERP_FUNC_PLANAR(nearest, 16, 10)
395 DEFINE_INTERP_FUNC_PLANAR(trilinear, 16, 10)
396 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 10)
397 DEFINE_INTERP_FUNC_PLANAR(pyramid, 16, 10)
398 DEFINE_INTERP_FUNC_PLANAR(prism, 16, 10)
399 
400 DEFINE_INTERP_FUNC_PLANAR(nearest, 16, 12)
401 DEFINE_INTERP_FUNC_PLANAR(trilinear, 16, 12)
402 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 12)
403 DEFINE_INTERP_FUNC_PLANAR(pyramid, 16, 12)
404 DEFINE_INTERP_FUNC_PLANAR(prism, 16, 12)
405 
406 DEFINE_INTERP_FUNC_PLANAR(nearest, 16, 14)
407 DEFINE_INTERP_FUNC_PLANAR(trilinear, 16, 14)
408 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 14)
409 DEFINE_INTERP_FUNC_PLANAR(pyramid, 16, 14)
410 DEFINE_INTERP_FUNC_PLANAR(prism, 16, 14)
411 
412 DEFINE_INTERP_FUNC_PLANAR(nearest, 16, 16)
413 DEFINE_INTERP_FUNC_PLANAR(trilinear, 16, 16)
414 DEFINE_INTERP_FUNC_PLANAR(tetrahedral, 16, 16)
415 DEFINE_INTERP_FUNC_PLANAR(pyramid, 16, 16)
416 DEFINE_INTERP_FUNC_PLANAR(prism, 16, 16)
417 
418 #define DEFINE_INTERP_FUNC_PLANAR_FLOAT(name, depth) \
419 static int interp_##name##_pf##depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
420 { \
421  int x, y; \
422  const LUT3DContext *lut3d = ctx->priv; \
423  const Lut3DPreLut *prelut = &lut3d->prelut; \
424  const ThreadData *td = arg; \
425  const AVFrame *in = td->in; \
426  const AVFrame *out = td->out; \
427  const int direct = out == in; \
428  const int slice_start = (in->height * jobnr ) / nb_jobs; \
429  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
430  uint8_t *grow = out->data[0] + slice_start * out->linesize[0]; \
431  uint8_t *brow = out->data[1] + slice_start * out->linesize[1]; \
432  uint8_t *rrow = out->data[2] + slice_start * out->linesize[2]; \
433  uint8_t *arow = out->data[3] + slice_start * out->linesize[3]; \
434  const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0]; \
435  const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1]; \
436  const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2]; \
437  const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3]; \
438  const float lut_max = lut3d->lutsize - 1; \
439  const float scale_r = lut3d->scale.r * lut_max; \
440  const float scale_g = lut3d->scale.g * lut_max; \
441  const float scale_b = lut3d->scale.b * lut_max; \
442  \
443  for (y = slice_start; y < slice_end; y++) { \
444  float *dstg = (float *)grow; \
445  float *dstb = (float *)brow; \
446  float *dstr = (float *)rrow; \
447  float *dsta = (float *)arow; \
448  const float *srcg = (const float *)srcgrow; \
449  const float *srcb = (const float *)srcbrow; \
450  const float *srcr = (const float *)srcrrow; \
451  const float *srca = (const float *)srcarow; \
452  for (x = 0; x < in->width; x++) { \
453  const struct rgbvec rgb = {sanitizef(srcr[x]), \
454  sanitizef(srcg[x]), \
455  sanitizef(srcb[x])}; \
456  const struct rgbvec prelut_rgb = apply_prelut(prelut, &rgb); \
457  const struct rgbvec scaled_rgb = {av_clipf(prelut_rgb.r * scale_r, 0, lut_max), \
458  av_clipf(prelut_rgb.g * scale_g, 0, lut_max), \
459  av_clipf(prelut_rgb.b * scale_b, 0, lut_max)}; \
460  struct rgbvec vec = interp_##name(lut3d, &scaled_rgb); \
461  dstr[x] = vec.r; \
462  dstg[x] = vec.g; \
463  dstb[x] = vec.b; \
464  if (!direct && in->linesize[3]) \
465  dsta[x] = srca[x]; \
466  } \
467  grow += out->linesize[0]; \
468  brow += out->linesize[1]; \
469  rrow += out->linesize[2]; \
470  arow += out->linesize[3]; \
471  srcgrow += in->linesize[0]; \
472  srcbrow += in->linesize[1]; \
473  srcrrow += in->linesize[2]; \
474  srcarow += in->linesize[3]; \
475  } \
476  return 0; \
477 }
478 
479 DEFINE_INTERP_FUNC_PLANAR_FLOAT(nearest, 32)
480 DEFINE_INTERP_FUNC_PLANAR_FLOAT(trilinear, 32)
481 DEFINE_INTERP_FUNC_PLANAR_FLOAT(tetrahedral, 32)
482 DEFINE_INTERP_FUNC_PLANAR_FLOAT(pyramid, 32)
483 DEFINE_INTERP_FUNC_PLANAR_FLOAT(prism, 32)
484 
485 #define DEFINE_INTERP_FUNC(name, nbits) \
486 static int interp_##nbits##_##name(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
487 { \
488  int x, y; \
489  const LUT3DContext *lut3d = ctx->priv; \
490  const Lut3DPreLut *prelut = &lut3d->prelut; \
491  const ThreadData *td = arg; \
492  const AVFrame *in = td->in; \
493  const AVFrame *out = td->out; \
494  const int direct = out == in; \
495  const int step = lut3d->step; \
496  const uint8_t r = lut3d->rgba_map[R]; \
497  const uint8_t g = lut3d->rgba_map[G]; \
498  const uint8_t b = lut3d->rgba_map[B]; \
499  const uint8_t a = lut3d->rgba_map[A]; \
500  const int slice_start = (in->height * jobnr ) / nb_jobs; \
501  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
502  uint8_t *dstrow = out->data[0] + slice_start * out->linesize[0]; \
503  const uint8_t *srcrow = in ->data[0] + slice_start * in ->linesize[0]; \
504  const float lut_max = lut3d->lutsize - 1; \
505  const float scale_f = 1.0f / ((1<<nbits) - 1); \
506  const float scale_r = lut3d->scale.r * lut_max; \
507  const float scale_g = lut3d->scale.g * lut_max; \
508  const float scale_b = lut3d->scale.b * lut_max; \
509  \
510  for (y = slice_start; y < slice_end; y++) { \
511  uint##nbits##_t *dst = (uint##nbits##_t *)dstrow; \
512  const uint##nbits##_t *src = (const uint##nbits##_t *)srcrow; \
513  for (x = 0; x < in->width * step; x += step) { \
514  const struct rgbvec rgb = {src[x + r] * scale_f, \
515  src[x + g] * scale_f, \
516  src[x + b] * scale_f}; \
517  const struct rgbvec prelut_rgb = apply_prelut(prelut, &rgb); \
518  const struct rgbvec scaled_rgb = {av_clipf(prelut_rgb.r * scale_r, 0, lut_max), \
519  av_clipf(prelut_rgb.g * scale_g, 0, lut_max), \
520  av_clipf(prelut_rgb.b * scale_b, 0, lut_max)}; \
521  struct rgbvec vec = interp_##name(lut3d, &scaled_rgb); \
522  dst[x + r] = av_clip_uint##nbits(vec.r * (float)((1<<nbits) - 1)); \
523  dst[x + g] = av_clip_uint##nbits(vec.g * (float)((1<<nbits) - 1)); \
524  dst[x + b] = av_clip_uint##nbits(vec.b * (float)((1<<nbits) - 1)); \
525  if (!direct && step == 4) \
526  dst[x + a] = src[x + a]; \
527  } \
528  dstrow += out->linesize[0]; \
529  srcrow += in ->linesize[0]; \
530  } \
531  return 0; \
532 }
533 
534 DEFINE_INTERP_FUNC(nearest, 8)
535 DEFINE_INTERP_FUNC(trilinear, 8)
536 DEFINE_INTERP_FUNC(tetrahedral, 8)
537 DEFINE_INTERP_FUNC(pyramid, 8)
538 DEFINE_INTERP_FUNC(prism, 8)
539 
540 DEFINE_INTERP_FUNC(nearest, 16)
541 DEFINE_INTERP_FUNC(trilinear, 16)
542 DEFINE_INTERP_FUNC(tetrahedral, 16)
543 DEFINE_INTERP_FUNC(pyramid, 16)
544 DEFINE_INTERP_FUNC(prism, 16)
545 
546 #define MAX_LINE_SIZE 512
547 
548 static int skip_line(const char *p)
549 {
550  while (*p && av_isspace(*p))
551  p++;
552  return !*p || *p == '#';
553 }
554 
555 static char* fget_next_word(char* dst, int max, FILE* f)
556 {
557  int c;
558  char *p = dst;
559 
560  /* for null */
561  max--;
562  /* skip until next non whitespace char */
563  while ((c = fgetc(f)) != EOF) {
564  if (av_isspace(c))
565  continue;
566 
567  *p++ = c;
568  max--;
569  break;
570  }
571 
572  /* get max bytes or up until next whitespace char */
573  for (; max > 0; max--) {
574  if ((c = fgetc(f)) == EOF)
575  break;
576 
577  if (av_isspace(c))
578  break;
579 
580  *p++ = c;
581  }
582 
583  *p = 0;
584  if (p == dst)
585  return NULL;
586  return p;
587 }
588 
589 #define NEXT_LINE(loop_cond) do { \
590  if (!fgets(line, sizeof(line), f)) { \
591  av_log(ctx, AV_LOG_ERROR, "Unexpected EOF\n"); \
592  return AVERROR_INVALIDDATA; \
593  } \
594 } while (loop_cond)
595 
596 #define NEXT_LINE_OR_GOTO(loop_cond, label) do { \
597  if (!fgets(line, sizeof(line), f)) { \
598  av_log(ctx, AV_LOG_ERROR, "Unexpected EOF\n"); \
599  ret = AVERROR_INVALIDDATA; \
600  goto label; \
601  } \
602 } while (loop_cond)
603 
604 static int allocate_3dlut(AVFilterContext *ctx, int lutsize, int prelut)
605 {
606  LUT3DContext *lut3d = ctx->priv;
607  int i;
608  if (lutsize < 2 || lutsize > MAX_LEVEL) {
609  av_log(ctx, AV_LOG_ERROR, "Too large or invalid 3D LUT size\n");
610  return AVERROR(EINVAL);
611  }
612 
613  av_freep(&lut3d->lut);
614  lut3d->lut = av_malloc_array(lutsize * lutsize * lutsize, sizeof(*lut3d->lut));
615  if (!lut3d->lut)
616  return AVERROR(ENOMEM);
617 
618  if (prelut) {
619  lut3d->prelut.size = PRELUT_SIZE;
620  for (i = 0; i < 3; i++) {
621  av_freep(&lut3d->prelut.lut[i]);
622  lut3d->prelut.lut[i] = av_malloc_array(PRELUT_SIZE, sizeof(*lut3d->prelut.lut[0]));
623  if (!lut3d->prelut.lut[i])
624  return AVERROR(ENOMEM);
625  }
626  } else {
627  lut3d->prelut.size = 0;
628  for (i = 0; i < 3; i++) {
629  av_freep(&lut3d->prelut.lut[i]);
630  }
631  }
632  lut3d->lutsize = lutsize;
633  lut3d->lutsize2 = lutsize * lutsize;
634  return 0;
635 }
636 
637 /* Basically r g and b float values on each line, with a facultative 3DLUTSIZE
638  * directive; seems to be generated by Davinci */
639 static int parse_dat(AVFilterContext *ctx, FILE *f)
640 {
641  LUT3DContext *lut3d = ctx->priv;
642  char line[MAX_LINE_SIZE];
643  int ret, i, j, k, size, size2;
644 
645  lut3d->lutsize = size = 33;
646  size2 = size * size;
647 
648  NEXT_LINE(skip_line(line));
649  if (!strncmp(line, "3DLUTSIZE ", 10)) {
650  size = strtol(line + 10, NULL, 0);
651 
652  NEXT_LINE(skip_line(line));
653  }
654 
655  ret = allocate_3dlut(ctx, size, 0);
656  if (ret < 0)
657  return ret;
658 
659  for (k = 0; k < size; k++) {
660  for (j = 0; j < size; j++) {
661  for (i = 0; i < size; i++) {
662  struct rgbvec *vec = &lut3d->lut[k * size2 + j * size + i];
663  if (k != 0 || j != 0 || i != 0)
664  NEXT_LINE(skip_line(line));
665  if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)
666  return AVERROR_INVALIDDATA;
667  }
668  }
669  }
670  return 0;
671 }
672 
673 /* Iridas format */
674 static int parse_cube(AVFilterContext *ctx, FILE *f)
675 {
676  LUT3DContext *lut3d = ctx->priv;
677  char line[MAX_LINE_SIZE];
678  float min[3] = {0.0, 0.0, 0.0};
679  float max[3] = {1.0, 1.0, 1.0};
680 
681  while (fgets(line, sizeof(line), f)) {
682  if (!strncmp(line, "LUT_3D_SIZE", 11)) {
683  int ret, i, j, k;
684  const int size = strtol(line + 12, NULL, 0);
685  const int size2 = size * size;
686 
687  ret = allocate_3dlut(ctx, size, 0);
688  if (ret < 0)
689  return ret;
690 
691  for (k = 0; k < size; k++) {
692  for (j = 0; j < size; j++) {
693  for (i = 0; i < size; i++) {
694  struct rgbvec *vec = &lut3d->lut[i * size2 + j * size + k];
695 
696  do {
697 try_again:
698  NEXT_LINE(0);
699  if (!strncmp(line, "DOMAIN_", 7)) {
700  float *vals = NULL;
701  if (!strncmp(line + 7, "MIN ", 4)) vals = min;
702  else if (!strncmp(line + 7, "MAX ", 4)) vals = max;
703  if (!vals)
704  return AVERROR_INVALIDDATA;
705  av_sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);
706  av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",
707  min[0], min[1], min[2], max[0], max[1], max[2]);
708  goto try_again;
709  } else if (!strncmp(line, "TITLE", 5)) {
710  goto try_again;
711  }
712  } while (skip_line(line));
713  if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)
714  return AVERROR_INVALIDDATA;
715  }
716  }
717  }
718  break;
719  }
720  }
721 
722  lut3d->scale.r = av_clipf(1. / (max[0] - min[0]), 0.f, 1.f);
723  lut3d->scale.g = av_clipf(1. / (max[1] - min[1]), 0.f, 1.f);
724  lut3d->scale.b = av_clipf(1. / (max[2] - min[2]), 0.f, 1.f);
725 
726  return 0;
727 }
728 
729 /* Assume 17x17x17 LUT with a 16-bit depth
730  * FIXME: it seems there are various 3dl formats */
731 static int parse_3dl(AVFilterContext *ctx, FILE *f)
732 {
733  char line[MAX_LINE_SIZE];
734  LUT3DContext *lut3d = ctx->priv;
735  int ret, i, j, k;
736  const int size = 17;
737  const int size2 = 17 * 17;
738  const float scale = 16*16*16;
739 
740  lut3d->lutsize = size;
741 
742  ret = allocate_3dlut(ctx, size, 0);
743  if (ret < 0)
744  return ret;
745 
746  NEXT_LINE(skip_line(line));
747  for (k = 0; k < size; k++) {
748  for (j = 0; j < size; j++) {
749  for (i = 0; i < size; i++) {
750  int r, g, b;
751  struct rgbvec *vec = &lut3d->lut[k * size2 + j * size + i];
752 
753  NEXT_LINE(skip_line(line));
754  if (av_sscanf(line, "%d %d %d", &r, &g, &b) != 3)
755  return AVERROR_INVALIDDATA;
756  vec->r = r / scale;
757  vec->g = g / scale;
758  vec->b = b / scale;
759  }
760  }
761  }
762  return 0;
763 }
764 
765 /* Pandora format */
766 static int parse_m3d(AVFilterContext *ctx, FILE *f)
767 {
768  LUT3DContext *lut3d = ctx->priv;
769  float scale;
770  int ret, i, j, k, size, size2, in = -1, out = -1;
771  char line[MAX_LINE_SIZE];
772  uint8_t rgb_map[3] = {0, 1, 2};
773 
774  while (fgets(line, sizeof(line), f)) {
775  if (!strncmp(line, "in", 2)) in = strtol(line + 2, NULL, 0);
776  else if (!strncmp(line, "out", 3)) out = strtol(line + 3, NULL, 0);
777  else if (!strncmp(line, "values", 6)) {
778  const char *p = line + 6;
779 #define SET_COLOR(id) do { \
780  while (av_isspace(*p)) \
781  p++; \
782  switch (*p) { \
783  case 'r': rgb_map[id] = 0; break; \
784  case 'g': rgb_map[id] = 1; break; \
785  case 'b': rgb_map[id] = 2; break; \
786  } \
787  while (*p && !av_isspace(*p)) \
788  p++; \
789 } while (0)
790  SET_COLOR(0);
791  SET_COLOR(1);
792  SET_COLOR(2);
793  break;
794  }
795  }
796 
797  if (in == -1 || out == -1) {
798  av_log(ctx, AV_LOG_ERROR, "in and out must be defined\n");
799  return AVERROR_INVALIDDATA;
800  }
801  if (in < 2 || out < 2 ||
802  in > MAX_LEVEL*MAX_LEVEL*MAX_LEVEL ||
803  out > MAX_LEVEL*MAX_LEVEL*MAX_LEVEL) {
804  av_log(ctx, AV_LOG_ERROR, "invalid in (%d) or out (%d)\n", in, out);
805  return AVERROR_INVALIDDATA;
806  }
807  for (size = 1; size*size*size < in; size++);
808  lut3d->lutsize = size;
809  size2 = size * size;
810 
811  ret = allocate_3dlut(ctx, size, 0);
812  if (ret < 0)
813  return ret;
814 
815  scale = 1. / (out - 1);
816 
817  for (k = 0; k < size; k++) {
818  for (j = 0; j < size; j++) {
819  for (i = 0; i < size; i++) {
820  struct rgbvec *vec = &lut3d->lut[k * size2 + j * size + i];
821  float val[3];
822 
823  NEXT_LINE(0);
824  if (av_sscanf(line, "%f %f %f", val, val + 1, val + 2) != 3)
825  return AVERROR_INVALIDDATA;
826  vec->r = val[rgb_map[0]] * scale;
827  vec->g = val[rgb_map[1]] * scale;
828  vec->b = val[rgb_map[2]] * scale;
829  }
830  }
831  }
832  return 0;
833 }
834 
835 static int nearest_sample_index(float *data, float x, int low, int hi)
836 {
837  int mid;
838  if (x < data[low])
839  return low;
840 
841  if (x > data[hi])
842  return hi;
843 
844  for (;;) {
845  av_assert0(x >= data[low]);
846  av_assert0(x <= data[hi]);
847  av_assert0((hi-low) > 0);
848 
849  if (hi - low == 1)
850  return low;
851 
852  mid = (low + hi) / 2;
853 
854  if (x < data[mid])
855  hi = mid;
856  else
857  low = mid;
858  }
859 
860  return 0;
861 }
862 
863 #define NEXT_FLOAT_OR_GOTO(value, label) \
864  if (!fget_next_word(line, sizeof(line) ,f)) { \
865  ret = AVERROR_INVALIDDATA; \
866  goto label; \
867  } \
868  if (av_sscanf(line, "%f", &value) != 1) { \
869  ret = AVERROR_INVALIDDATA; \
870  goto label; \
871  }
872 
873 static int parse_cinespace(AVFilterContext *ctx, FILE *f)
874 {
875  LUT3DContext *lut3d = ctx->priv;
876  char line[MAX_LINE_SIZE];
877  float in_min[3] = {0.0, 0.0, 0.0};
878  float in_max[3] = {1.0, 1.0, 1.0};
879  float out_min[3] = {0.0, 0.0, 0.0};
880  float out_max[3] = {1.0, 1.0, 1.0};
881  int inside_metadata = 0, size, size2;
882  int prelut = 0;
883  int ret = 0;
884 
885  int prelut_sizes[3] = {0, 0, 0};
886  float *in_prelut[3] = {NULL, NULL, NULL};
887  float *out_prelut[3] = {NULL, NULL, NULL};
888 
889  NEXT_LINE_OR_GOTO(skip_line(line), end);
890  if (strncmp(line, "CSPLUTV100", 10)) {
891  av_log(ctx, AV_LOG_ERROR, "Not cineSpace LUT format\n");
892  ret = AVERROR(EINVAL);
893  goto end;
894  }
895 
896  NEXT_LINE_OR_GOTO(skip_line(line), end);
897  if (strncmp(line, "3D", 2)) {
898  av_log(ctx, AV_LOG_ERROR, "Not 3D LUT format\n");
899  ret = AVERROR(EINVAL);
900  goto end;
901  }
902 
903  while (1) {
904  NEXT_LINE_OR_GOTO(skip_line(line), end);
905 
906  if (!strncmp(line, "BEGIN METADATA", 14)) {
907  inside_metadata = 1;
908  continue;
909  }
910  if (!strncmp(line, "END METADATA", 12)) {
911  inside_metadata = 0;
912  continue;
913  }
914  if (inside_metadata == 0) {
915  int size_r, size_g, size_b;
916 
917  for (int i = 0; i < 3; i++) {
918  int npoints = strtol(line, NULL, 0);
919 
920  if (npoints > 2) {
921  float v,last;
922 
923  if (npoints > PRELUT_SIZE) {
924  av_log(ctx, AV_LOG_ERROR, "Prelut size too large.\n");
925  ret = AVERROR_INVALIDDATA;
926  goto end;
927  }
928 
929  if (in_prelut[i] || out_prelut[i]) {
930  av_log(ctx, AV_LOG_ERROR, "Invalid file has multiple preluts.\n");
931  ret = AVERROR_INVALIDDATA;
932  goto end;
933  }
934 
935  in_prelut[i] = (float*)av_malloc(npoints * sizeof(float));
936  out_prelut[i] = (float*)av_malloc(npoints * sizeof(float));
937  if (!in_prelut[i] || !out_prelut[i]) {
938  ret = AVERROR(ENOMEM);
939  goto end;
940  }
941 
942  prelut_sizes[i] = npoints;
943  in_min[i] = FLT_MAX;
944  in_max[i] = -FLT_MAX;
945  out_min[i] = FLT_MAX;
946  out_max[i] = -FLT_MAX;
947 
948  for (int j = 0; j < npoints; j++) {
949  NEXT_FLOAT_OR_GOTO(v, end)
950  in_min[i] = FFMIN(in_min[i], v);
951  in_max[i] = FFMAX(in_max[i], v);
952  in_prelut[i][j] = v;
953  if (j > 0 && v < last) {
954  av_log(ctx, AV_LOG_ERROR, "Invalid file, non increasing prelut.\n");
955  ret = AVERROR(ENOMEM);
956  goto end;
957  }
958  last = v;
959  }
960 
961  for (int j = 0; j < npoints; j++) {
962  NEXT_FLOAT_OR_GOTO(v, end)
963  out_min[i] = FFMIN(out_min[i], v);
964  out_max[i] = FFMAX(out_max[i], v);
965  out_prelut[i][j] = v;
966  }
967 
968  } else if (npoints == 2) {
969  NEXT_LINE_OR_GOTO(skip_line(line), end);
970  if (av_sscanf(line, "%f %f", &in_min[i], &in_max[i]) != 2) {
971  ret = AVERROR_INVALIDDATA;
972  goto end;
973  }
974  NEXT_LINE_OR_GOTO(skip_line(line), end);
975  if (av_sscanf(line, "%f %f", &out_min[i], &out_max[i]) != 2) {
976  ret = AVERROR_INVALIDDATA;
977  goto end;
978  }
979 
980  } else {
981  av_log(ctx, AV_LOG_ERROR, "Unsupported number of pre-lut points.\n");
982  ret = AVERROR_PATCHWELCOME;
983  goto end;
984  }
985 
986  NEXT_LINE_OR_GOTO(skip_line(line), end);
987  }
988 
989  if (av_sscanf(line, "%d %d %d", &size_r, &size_g, &size_b) != 3) {
990  ret = AVERROR(EINVAL);
991  goto end;
992  }
993  if (size_r != size_g || size_r != size_b) {
994  av_log(ctx, AV_LOG_ERROR, "Unsupported size combination: %dx%dx%d.\n", size_r, size_g, size_b);
995  ret = AVERROR_PATCHWELCOME;
996  goto end;
997  }
998 
999  size = size_r;
1000  size2 = size * size;
1001 
1002  if (prelut_sizes[0] && prelut_sizes[1] && prelut_sizes[2])
1003  prelut = 1;
1004 
1005  ret = allocate_3dlut(ctx, size, prelut);
1006  if (ret < 0)
1007  return ret;
1008 
1009  for (int k = 0; k < size; k++) {
1010  for (int j = 0; j < size; j++) {
1011  for (int i = 0; i < size; i++) {
1012  struct rgbvec *vec = &lut3d->lut[i * size2 + j * size + k];
1013 
1014  NEXT_LINE_OR_GOTO(skip_line(line), end);
1015  if (av_sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3) {
1016  ret = AVERROR_INVALIDDATA;
1017  goto end;
1018  }
1019 
1020  vec->r *= out_max[0] - out_min[0];
1021  vec->g *= out_max[1] - out_min[1];
1022  vec->b *= out_max[2] - out_min[2];
1023  }
1024  }
1025  }
1026 
1027  break;
1028  }
1029  }
1030 
1031  if (prelut) {
1032  for (int c = 0; c < 3; c++) {
1033 
1034  lut3d->prelut.min[c] = in_min[c];
1035  lut3d->prelut.max[c] = in_max[c];
1036  lut3d->prelut.scale[c] = (1.0f / (float)(in_max[c] - in_min[c])) * (lut3d->prelut.size - 1);
1037 
1038  for (int i = 0; i < lut3d->prelut.size; ++i) {
1039  float mix = (float) i / (float)(lut3d->prelut.size - 1);
1040  float x = lerpf(in_min[c], in_max[c], mix), a, b;
1041 
1042  int idx = nearest_sample_index(in_prelut[c], x, 0, prelut_sizes[c]-1);
1043  av_assert0(idx + 1 < prelut_sizes[c]);
1044 
1045  a = out_prelut[c][idx + 0];
1046  b = out_prelut[c][idx + 1];
1047  mix = x - in_prelut[c][idx];
1048 
1049  lut3d->prelut.lut[c][i] = sanitizef(lerpf(a, b, mix));
1050  }
1051  }
1052  lut3d->scale.r = 1.00f;
1053  lut3d->scale.g = 1.00f;
1054  lut3d->scale.b = 1.00f;
1055 
1056  } else {
1057  lut3d->scale.r = av_clipf(1. / (in_max[0] - in_min[0]), 0.f, 1.f);
1058  lut3d->scale.g = av_clipf(1. / (in_max[1] - in_min[1]), 0.f, 1.f);
1059  lut3d->scale.b = av_clipf(1. / (in_max[2] - in_min[2]), 0.f, 1.f);
1060  }
1061 
1062 end:
1063  for (int c = 0; c < 3; c++) {
1064  av_freep(&in_prelut[c]);
1065  av_freep(&out_prelut[c]);
1066  }
1067  return ret;
1068 }
1069 
1070 static int set_identity_matrix(AVFilterContext *ctx, int size)
1071 {
1072  LUT3DContext *lut3d = ctx->priv;
1073  int ret, i, j, k;
1074  const int size2 = size * size;
1075  const float c = 1. / (size - 1);
1076 
1077  ret = allocate_3dlut(ctx, size, 0);
1078  if (ret < 0)
1079  return ret;
1080 
1081  for (k = 0; k < size; k++) {
1082  for (j = 0; j < size; j++) {
1083  for (i = 0; i < size; i++) {
1084  struct rgbvec *vec = &lut3d->lut[k * size2 + j * size + i];
1085  vec->r = k * c;
1086  vec->g = j * c;
1087  vec->b = i * c;
1088  }
1089  }
1090  }
1091 
1092  return 0;
1093 }
1094 
1095 static const enum AVPixelFormat pix_fmts[] = {
1096  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
1097  AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
1098  AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
1099  AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
1100  AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
1101  AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
1102  AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
1103  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
1104  AV_PIX_FMT_GBRP9,
1105  AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
1106  AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
1107  AV_PIX_FMT_GBRP14,
1108  AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,
1109  AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32,
1110  AV_PIX_FMT_NONE
1111 };
1112 
1113 static int config_input(AVFilterLink *inlink)
1114 {
1115  int depth, is16bit, isfloat, planar;
1116  LUT3DContext *lut3d = inlink->dst->priv;
1117  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
1118 
1119  depth = desc->comp[0].depth;
1120  is16bit = desc->comp[0].depth > 8;
1121  planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
1122  isfloat = desc->flags & AV_PIX_FMT_FLAG_FLOAT;
1123  ff_fill_rgba_map(lut3d->rgba_map, inlink->format);
1124  lut3d->step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);
1125 
1126 #define SET_FUNC(name) do { \
1127  if (planar && !isfloat) { \
1128  switch (depth) { \
1129  case 8: lut3d->interp = interp_8_##name##_p8; break; \
1130  case 9: lut3d->interp = interp_16_##name##_p9; break; \
1131  case 10: lut3d->interp = interp_16_##name##_p10; break; \
1132  case 12: lut3d->interp = interp_16_##name##_p12; break; \
1133  case 14: lut3d->interp = interp_16_##name##_p14; break; \
1134  case 16: lut3d->interp = interp_16_##name##_p16; break; \
1135  } \
1136  } else if (isfloat) { lut3d->interp = interp_##name##_pf32; \
1137  } else if (is16bit) { lut3d->interp = interp_16_##name; \
1138  } else { lut3d->interp = interp_8_##name; } \
1139 } while (0)
1140 
1141  switch (lut3d->interpolation) {
1142  case INTERPOLATE_NEAREST: SET_FUNC(nearest); break;
1143  case INTERPOLATE_TRILINEAR: SET_FUNC(trilinear); break;
1144  case INTERPOLATE_TETRAHEDRAL: SET_FUNC(tetrahedral); break;
1145  case INTERPOLATE_PYRAMID: SET_FUNC(pyramid); break;
1146  case INTERPOLATE_PRISM: SET_FUNC(prism); break;
1147  default:
1148  av_assert0(0);
1149  }
1150 
1151  if (ARCH_X86) {
1152  ff_lut3d_init_x86(lut3d, desc);
1153  }
1154 
1155  return 0;
1156 }
1157 
1158 static AVFrame *apply_lut(AVFilterLink *inlink, AVFrame *in)
1159 {
1160  AVFilterContext *ctx = inlink->dst;
1161  LUT3DContext *lut3d = ctx->priv;
1162  AVFilterLink *outlink = inlink->dst->outputs[0];
1163  AVFrame *out;
1164  ThreadData td;
1165 
1166  if (av_frame_is_writable(in)) {
1167  out = in;
1168  } else {
1169  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
1170  if (!out) {
1171  av_frame_free(&in);
1172  return NULL;
1173  }
1174  av_frame_copy_props(out, in);
1175  }
1176 
1177  td.in = in;
1178  td.out = out;
1179  ff_filter_execute(ctx, lut3d->interp, &td, NULL,
1180  FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
1181 
1182  if (out != in)
1183  av_frame_free(&in);
1184 
1185  return out;
1186 }
1187 
1188 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
1189 {
1190  AVFilterLink *outlink = inlink->dst->outputs[0];
1191  AVFrame *out = apply_lut(inlink, in);
1192  if (!out)
1193  return AVERROR(ENOMEM);
1194  return ff_filter_frame(outlink, out);
1195 }
1196 
1197 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1198  char *res, int res_len, int flags)
1199 {
1200  int ret;
1201 
1202  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1203  if (ret < 0)
1204  return ret;
1205 
1206  return config_input(ctx->inputs[0]);
1207 }
1208 
1209 #if CONFIG_LUT3D_FILTER || CONFIG_HALDCLUT_FILTER
1210 
1211 /* These options are shared between several filters;
1212  * &lut3d_haldclut_options[COMMON_OPTIONS_OFFSET] must always
1213  * point to the first of the COMMON_OPTIONS. */
1214 #define COMMON_OPTIONS_OFFSET CONFIG_LUT3D_FILTER
1215 static const AVOption lut3d_haldclut_options[] = {
1216 #if CONFIG_LUT3D_FILTER
1217  { "file", "set 3D LUT file name", OFFSET(file), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
1218 #endif
1219  COMMON_OPTIONS
1220 };
1221 
1222 #if CONFIG_LUT3D_FILTER
1223 
1224 AVFILTER_DEFINE_CLASS_EXT(lut3d, "lut3d", lut3d_haldclut_options);
1225 
1226 static av_cold int lut3d_init(AVFilterContext *ctx)
1227 {
1228  int ret;
1229  FILE *f;
1230  const char *ext;
1231  LUT3DContext *lut3d = ctx->priv;
1232 
1233  lut3d->scale.r = lut3d->scale.g = lut3d->scale.b = 1.f;
1234 
1235  if (!lut3d->file) {
1236  return set_identity_matrix(ctx, 32);
1237  }
1238 
1239  f = av_fopen_utf8(lut3d->file, "r");
1240  if (!f) {
1241  ret = AVERROR(errno);
1242  av_log(ctx, AV_LOG_ERROR, "%s: %s\n", lut3d->file, av_err2str(ret));
1243  return ret;
1244  }
1245 
1246  ext = strrchr(lut3d->file, '.');
1247  if (!ext) {
1248  av_log(ctx, AV_LOG_ERROR, "Unable to guess the format from the extension\n");
1249  ret = AVERROR_INVALIDDATA;
1250  goto end;
1251  }
1252  ext++;
1253 
1254  if (!av_strcasecmp(ext, "dat")) {
1255  ret = parse_dat(ctx, f);
1256  } else if (!av_strcasecmp(ext, "3dl")) {
1257  ret = parse_3dl(ctx, f);
1258  } else if (!av_strcasecmp(ext, "cube")) {
1259  ret = parse_cube(ctx, f);
1260  } else if (!av_strcasecmp(ext, "m3d")) {
1261  ret = parse_m3d(ctx, f);
1262  } else if (!av_strcasecmp(ext, "csp")) {
1263  ret = parse_cinespace(ctx, f);
1264  } else {
1265  av_log(ctx, AV_LOG_ERROR, "Unrecognized '.%s' file type\n", ext);
1266  ret = AVERROR(EINVAL);
1267  }
1268 
1269  if (!ret && !lut3d->lutsize) {
1270  av_log(ctx, AV_LOG_ERROR, "3D LUT is empty\n");
1271  ret = AVERROR_INVALIDDATA;
1272  }
1273 
1274 end:
1275  fclose(f);
1276  return ret;
1277 }
1278 
1279 static av_cold void lut3d_uninit(AVFilterContext *ctx)
1280 {
1281  LUT3DContext *lut3d = ctx->priv;
1282  int i;
1283  av_freep(&lut3d->lut);
1284 
1285  for (i = 0; i < 3; i++) {
1286  av_freep(&lut3d->prelut.lut[i]);
1287  }
1288 }
1289 
1290 static const AVFilterPad lut3d_inputs[] = {
1291  {
1292  .name = "default",
1293  .type = AVMEDIA_TYPE_VIDEO,
1294  .filter_frame = filter_frame,
1295  .config_props = config_input,
1296  },
1297 };
1298 
1299 static const AVFilterPad lut3d_outputs[] = {
1300  {
1301  .name = "default",
1302  .type = AVMEDIA_TYPE_VIDEO,
1303  },
1304 };
1305 
1306 const AVFilter ff_vf_lut3d = {
1307  .name = "lut3d",
1308  .description = NULL_IF_CONFIG_SMALL("Adjust colors using a 3D LUT."),
1309  .priv_size = sizeof(LUT3DContext),
1310  .init = lut3d_init,
1311  .uninit = lut3d_uninit,
1312  FILTER_INPUTS(lut3d_inputs),
1313  FILTER_OUTPUTS(lut3d_outputs),
1314  FILTER_PIXFMTS_ARRAY(pix_fmts),
1315  .priv_class = &lut3d_class,
1316  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
1317  .process_command = process_command,
1318 };
1319 #endif
1320 
1321 #if CONFIG_HALDCLUT_FILTER
1322 
1323 static void update_clut_packed(LUT3DContext *lut3d, const AVFrame *frame)
1324 {
1325  const uint8_t *data = frame->data[0];
1326  const int linesize = frame->linesize[0];
1327  const int w = lut3d->clut_width;
1328  const int step = lut3d->clut_step;
1329  const uint8_t *rgba_map = lut3d->clut_rgba_map;
1330  const int level = lut3d->lutsize;
1331  const int level2 = lut3d->lutsize2;
1332 
1333 #define LOAD_CLUT(nbits) do { \
1334  int i, j, k, x = 0, y = 0; \
1335  \
1336  for (k = 0; k < level; k++) { \
1337  for (j = 0; j < level; j++) { \
1338  for (i = 0; i < level; i++) { \
1339  const uint##nbits##_t *src = (const uint##nbits##_t *) \
1340  (data + y*linesize + x*step); \
1341  struct rgbvec *vec = &lut3d->lut[i * level2 + j * level + k]; \
1342  vec->r = src[rgba_map[0]] / (float)((1<<(nbits)) - 1); \
1343  vec->g = src[rgba_map[1]] / (float)((1<<(nbits)) - 1); \
1344  vec->b = src[rgba_map[2]] / (float)((1<<(nbits)) - 1); \
1345  if (++x == w) { \
1346  x = 0; \
1347  y++; \
1348  } \
1349  } \
1350  } \
1351  } \
1352 } while (0)
1353 
1354  switch (lut3d->clut_bits) {
1355  case 8: LOAD_CLUT(8); break;
1356  case 16: LOAD_CLUT(16); break;
1357  }
1358 }
1359 
1360 static void update_clut_planar(LUT3DContext *lut3d, const AVFrame *frame)
1361 {
1362  const uint8_t *datag = frame->data[0];
1363  const uint8_t *datab = frame->data[1];
1364  const uint8_t *datar = frame->data[2];
1365  const int glinesize = frame->linesize[0];
1366  const int blinesize = frame->linesize[1];
1367  const int rlinesize = frame->linesize[2];
1368  const int w = lut3d->clut_width;
1369  const int level = lut3d->lutsize;
1370  const int level2 = lut3d->lutsize2;
1371 
1372 #define LOAD_CLUT_PLANAR(nbits, depth) do { \
1373  int i, j, k, x = 0, y = 0; \
1374  \
1375  for (k = 0; k < level; k++) { \
1376  for (j = 0; j < level; j++) { \
1377  for (i = 0; i < level; i++) { \
1378  const uint##nbits##_t *gsrc = (const uint##nbits##_t *) \
1379  (datag + y*glinesize); \
1380  const uint##nbits##_t *bsrc = (const uint##nbits##_t *) \
1381  (datab + y*blinesize); \
1382  const uint##nbits##_t *rsrc = (const uint##nbits##_t *) \
1383  (datar + y*rlinesize); \
1384  struct rgbvec *vec = &lut3d->lut[i * level2 + j * level + k]; \
1385  vec->r = gsrc[x] / (float)((1<<(depth)) - 1); \
1386  vec->g = bsrc[x] / (float)((1<<(depth)) - 1); \
1387  vec->b = rsrc[x] / (float)((1<<(depth)) - 1); \
1388  if (++x == w) { \
1389  x = 0; \
1390  y++; \
1391  } \
1392  } \
1393  } \
1394  } \
1395 } while (0)
1396 
1397  switch (lut3d->clut_bits) {
1398  case 8: LOAD_CLUT_PLANAR(8, 8); break;
1399  case 9: LOAD_CLUT_PLANAR(16, 9); break;
1400  case 10: LOAD_CLUT_PLANAR(16, 10); break;
1401  case 12: LOAD_CLUT_PLANAR(16, 12); break;
1402  case 14: LOAD_CLUT_PLANAR(16, 14); break;
1403  case 16: LOAD_CLUT_PLANAR(16, 16); break;
1404  }
1405 }
1406 
1407 static void update_clut_float(LUT3DContext *lut3d, const AVFrame *frame)
1408 {
1409  const uint8_t *datag = frame->data[0];
1410  const uint8_t *datab = frame->data[1];
1411  const uint8_t *datar = frame->data[2];
1412  const int glinesize = frame->linesize[0];
1413  const int blinesize = frame->linesize[1];
1414  const int rlinesize = frame->linesize[2];
1415  const int w = lut3d->clut_width;
1416  const int level = lut3d->lutsize;
1417  const int level2 = lut3d->lutsize2;
1418 
1419  int i, j, k, x = 0, y = 0;
1420 
1421  for (k = 0; k < level; k++) {
1422  for (j = 0; j < level; j++) {
1423  for (i = 0; i < level; i++) {
1424  const float *gsrc = (const float *)(datag + y*glinesize);
1425  const float *bsrc = (const float *)(datab + y*blinesize);
1426  const float *rsrc = (const float *)(datar + y*rlinesize);
1427  struct rgbvec *vec = &lut3d->lut[i * level2 + j * level + k];
1428  vec->r = rsrc[x];
1429  vec->g = gsrc[x];
1430  vec->b = bsrc[x];
1431  if (++x == w) {
1432  x = 0;
1433  y++;
1434  }
1435  }
1436  }
1437  }
1438 }
1439 
1440 static int config_output(AVFilterLink *outlink)
1441 {
1442  AVFilterContext *ctx = outlink->src;
1443  LUT3DContext *lut3d = ctx->priv;
1444  int ret;
1445 
1446  ret = ff_framesync_init_dualinput(&lut3d->fs, ctx);
1447  if (ret < 0)
1448  return ret;
1449  outlink->w = ctx->inputs[0]->w;
1450  outlink->h = ctx->inputs[0]->h;
1451  outlink->time_base = ctx->inputs[0]->time_base;
1452  if ((ret = ff_framesync_configure(&lut3d->fs)) < 0)
1453  return ret;
1454  return 0;
1455 }
1456 
1457 static int activate(AVFilterContext *ctx)
1458 {
1459  LUT3DContext *s = ctx->priv;
1460  return ff_framesync_activate(&s->fs);
1461 }
1462 
1463 static int config_clut(AVFilterLink *inlink)
1464 {
1465  int size, level, w, h;
1466  AVFilterContext *ctx = inlink->dst;
1467  LUT3DContext *lut3d = ctx->priv;
1468  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
1469 
1470  av_assert0(desc);
1471 
1472  lut3d->clut_bits = desc->comp[0].depth;
1473  lut3d->clut_planar = av_pix_fmt_count_planes(inlink->format) > 1;
1474  lut3d->clut_float = desc->flags & AV_PIX_FMT_FLAG_FLOAT;
1475 
1476  lut3d->clut_step = av_get_padded_bits_per_pixel(desc) >> 3;
1477  ff_fill_rgba_map(lut3d->clut_rgba_map, inlink->format);
1478 
1479  if (inlink->w > inlink->h)
1480  av_log(ctx, AV_LOG_INFO, "Padding on the right (%dpx) of the "
1481  "Hald CLUT will be ignored\n", inlink->w - inlink->h);
1482  else if (inlink->w < inlink->h)
1483  av_log(ctx, AV_LOG_INFO, "Padding at the bottom (%dpx) of the "
1484  "Hald CLUT will be ignored\n", inlink->h - inlink->w);
1485  lut3d->clut_width = w = h = FFMIN(inlink->w, inlink->h);
1486 
1487  for (level = 1; level*level*level < w; level++);
1488  size = level*level*level;
1489  if (size != w) {
1490  av_log(ctx, AV_LOG_WARNING, "The Hald CLUT width does not match the level\n");
1491  return AVERROR_INVALIDDATA;
1492  }
1493  av_assert0(w == h && w == size);
1494  level *= level;
1495  if (level > MAX_LEVEL) {
1496  const int max_clut_level = sqrt(MAX_LEVEL);
1497  const int max_clut_size = max_clut_level*max_clut_level*max_clut_level;
1498  av_log(ctx, AV_LOG_ERROR, "Too large Hald CLUT "
1499  "(maximum level is %d, or %dx%d CLUT)\n",
1500  max_clut_level, max_clut_size, max_clut_size);
1501  return AVERROR(EINVAL);
1502  }
1503 
1504  return allocate_3dlut(ctx, level, 0);
1505 }
1506 
1507 static int update_apply_clut(FFFrameSync *fs)
1508 {
1509  AVFilterContext *ctx = fs->parent;
1510  LUT3DContext *lut3d = ctx->priv;
1511  AVFilterLink *inlink = ctx->inputs[0];
1512  AVFrame *master, *second, *out;
1513  int ret;
1514 
1515  ret = ff_framesync_dualinput_get(fs, &master, &second);
1516  if (ret < 0)
1517  return ret;
1518  if (!second)
1519  return ff_filter_frame(ctx->outputs[0], master);
1520  if (lut3d->clut_float)
1521  update_clut_float(ctx->priv, second);
1522  else if (lut3d->clut_planar)
1523  update_clut_planar(ctx->priv, second);
1524  else
1525  update_clut_packed(ctx->priv, second);
1526  out = apply_lut(inlink, master);
1527  return ff_filter_frame(ctx->outputs[0], out);
1528 }
1529 
1530 static av_cold int haldclut_init(AVFilterContext *ctx)
1531 {
1532  LUT3DContext *lut3d = ctx->priv;
1533  lut3d->scale.r = lut3d->scale.g = lut3d->scale.b = 1.f;
1534  lut3d->fs.on_event = update_apply_clut;
1535  return 0;
1536 }
1537 
1538 static av_cold void haldclut_uninit(AVFilterContext *ctx)
1539 {
1540  LUT3DContext *lut3d = ctx->priv;
1541  ff_framesync_uninit(&lut3d->fs);
1542  av_freep(&lut3d->lut);
1543 }
1544 
1545 FRAMESYNC_DEFINE_CLASS_EXT(haldclut, LUT3DContext, fs,
1546  &lut3d_haldclut_options[COMMON_OPTIONS_OFFSET]);
1547 
1548 static const AVFilterPad haldclut_inputs[] = {
1549  {
1550  .name = "main",
1551  .type = AVMEDIA_TYPE_VIDEO,
1552  .config_props = config_input,
1553  },{
1554  .name = "clut",
1555  .type = AVMEDIA_TYPE_VIDEO,
1556  .config_props = config_clut,
1557  },
1558 };
1559 
1560 static const AVFilterPad haldclut_outputs[] = {
1561  {
1562  .name = "default",
1563  .type = AVMEDIA_TYPE_VIDEO,
1564  .config_props = config_output,
1565  },
1566 };
1567 
1568 const AVFilter ff_vf_haldclut = {
1569  .name = "haldclut",
1570  .description = NULL_IF_CONFIG_SMALL("Adjust colors using a Hald CLUT."),
1571  .priv_size = sizeof(LUT3DContext),
1572  .preinit = haldclut_framesync_preinit,
1573  .init = haldclut_init,
1574  .uninit = haldclut_uninit,
1575  .activate = activate,
1576  FILTER_INPUTS(haldclut_inputs),
1577  FILTER_OUTPUTS(haldclut_outputs),
1578  FILTER_PIXFMTS_ARRAY(pix_fmts),
1579  .priv_class = &haldclut_class,
1580  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
1581  .process_command = process_command,
1582 };
1583 #endif
1584 
1585 #endif /* CONFIG_LUT3D_FILTER || CONFIG_HALDCLUT_FILTER */
1586 
1587 #if CONFIG_LUT1D_FILTER
1588 
1589 enum interp_1d_mode {
1590  INTERPOLATE_1D_NEAREST,
1591  INTERPOLATE_1D_LINEAR,
1592  INTERPOLATE_1D_CUBIC,
1593  INTERPOLATE_1D_COSINE,
1594  INTERPOLATE_1D_SPLINE,
1595  NB_INTERP_1D_MODE
1596 };
1597 
1598 #define MAX_1D_LEVEL 65536
1599 
1600 typedef struct LUT1DContext {
1601  const AVClass *class;
1602  char *file;
1603  int interpolation; ///<interp_1d_mode
1604  struct rgbvec scale;
1605  uint8_t rgba_map[4];
1606  int step;
1607  float lut[3][MAX_1D_LEVEL];
1608  int lutsize;
1609  avfilter_action_func *interp;
1610 } LUT1DContext;
1611 
1612 #undef OFFSET
1613 #define OFFSET(x) offsetof(LUT1DContext, x)
1614 
1615 static void set_identity_matrix_1d(LUT1DContext *lut1d, int size)
1616 {
1617  const float c = 1. / (size - 1);
1618  int i;
1619 
1620  lut1d->lutsize = size;
1621  for (i = 0; i < size; i++) {
1622  lut1d->lut[0][i] = i * c;
1623  lut1d->lut[1][i] = i * c;
1624  lut1d->lut[2][i] = i * c;
1625  }
1626 }
1627 
1628 static int parse_cinespace_1d(AVFilterContext *ctx, FILE *f)
1629 {
1630  LUT1DContext *lut1d = ctx->priv;
1631  char line[MAX_LINE_SIZE];
1632  float in_min[3] = {0.0, 0.0, 0.0};
1633  float in_max[3] = {1.0, 1.0, 1.0};
1634  float out_min[3] = {0.0, 0.0, 0.0};
1635  float out_max[3] = {1.0, 1.0, 1.0};
1636  int inside_metadata = 0, size;
1637 
1638  NEXT_LINE(skip_line(line));
1639  if (strncmp(line, "CSPLUTV100", 10)) {
1640  av_log(ctx, AV_LOG_ERROR, "Not cineSpace LUT format\n");
1641  return AVERROR(EINVAL);
1642  }
1643 
1644  NEXT_LINE(skip_line(line));
1645  if (strncmp(line, "1D", 2)) {
1646  av_log(ctx, AV_LOG_ERROR, "Not 1D LUT format\n");
1647  return AVERROR(EINVAL);
1648  }
1649 
1650  while (1) {
1651  NEXT_LINE(skip_line(line));
1652 
1653  if (!strncmp(line, "BEGIN METADATA", 14)) {
1654  inside_metadata = 1;
1655  continue;
1656  }
1657  if (!strncmp(line, "END METADATA", 12)) {
1658  inside_metadata = 0;
1659  continue;
1660  }
1661  if (inside_metadata == 0) {
1662  for (int i = 0; i < 3; i++) {
1663  int npoints = strtol(line, NULL, 0);
1664 
1665  if (npoints != 2) {
1666  av_log(ctx, AV_LOG_ERROR, "Unsupported number of pre-lut points.\n");
1667  return AVERROR_PATCHWELCOME;
1668  }
1669 
1670  NEXT_LINE(skip_line(line));
1671  if (av_sscanf(line, "%f %f", &in_min[i], &in_max[i]) != 2)
1672  return AVERROR_INVALIDDATA;
1673  NEXT_LINE(skip_line(line));
1674  if (av_sscanf(line, "%f %f", &out_min[i], &out_max[i]) != 2)
1675  return AVERROR_INVALIDDATA;
1676  NEXT_LINE(skip_line(line));
1677  }
1678 
1679  size = strtol(line, NULL, 0);
1680 
1681  if (size < 2 || size > MAX_1D_LEVEL) {
1682  av_log(ctx, AV_LOG_ERROR, "Too large or invalid 1D LUT size\n");
1683  return AVERROR(EINVAL);
1684  }
1685 
1686  lut1d->lutsize = size;
1687 
1688  for (int i = 0; i < size; i++) {
1689  NEXT_LINE(skip_line(line));
1690  if (av_sscanf(line, "%f %f %f", &lut1d->lut[0][i], &lut1d->lut[1][i], &lut1d->lut[2][i]) != 3)
1691  return AVERROR_INVALIDDATA;
1692  lut1d->lut[0][i] *= out_max[0] - out_min[0];
1693  lut1d->lut[1][i] *= out_max[1] - out_min[1];
1694  lut1d->lut[2][i] *= out_max[2] - out_min[2];
1695  }
1696 
1697  break;
1698  }
1699  }
1700 
1701  lut1d->scale.r = av_clipf(1. / (in_max[0] - in_min[0]), 0.f, 1.f);
1702  lut1d->scale.g = av_clipf(1. / (in_max[1] - in_min[1]), 0.f, 1.f);
1703  lut1d->scale.b = av_clipf(1. / (in_max[2] - in_min[2]), 0.f, 1.f);
1704 
1705  return 0;
1706 }
1707 
1708 static int parse_cube_1d(AVFilterContext *ctx, FILE *f)
1709 {
1710  LUT1DContext *lut1d = ctx->priv;
1711  char line[MAX_LINE_SIZE];
1712  float min[3] = {0.0, 0.0, 0.0};
1713  float max[3] = {1.0, 1.0, 1.0};
1714 
1715  while (fgets(line, sizeof(line), f)) {
1716  if (!strncmp(line, "LUT_1D_SIZE", 11)) {
1717  const int size = strtol(line + 12, NULL, 0);
1718  int i;
1719 
1720  if (size < 2 || size > MAX_1D_LEVEL) {
1721  av_log(ctx, AV_LOG_ERROR, "Too large or invalid 1D LUT size\n");
1722  return AVERROR(EINVAL);
1723  }
1724  lut1d->lutsize = size;
1725  for (i = 0; i < size; i++) {
1726  do {
1727 try_again:
1728  NEXT_LINE(0);
1729  if (!strncmp(line, "DOMAIN_", 7)) {
1730  float *vals = NULL;
1731  if (!strncmp(line + 7, "MIN ", 4)) vals = min;
1732  else if (!strncmp(line + 7, "MAX ", 4)) vals = max;
1733  if (!vals)
1734  return AVERROR_INVALIDDATA;
1735  av_sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);
1736  av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",
1737  min[0], min[1], min[2], max[0], max[1], max[2]);
1738  goto try_again;
1739  } else if (!strncmp(line, "LUT_1D_INPUT_RANGE ", 19)) {
1740  av_sscanf(line + 19, "%f %f", min, max);
1741  min[1] = min[2] = min[0];
1742  max[1] = max[2] = max[0];
1743  goto try_again;
1744  } else if (!strncmp(line, "TITLE", 5)) {
1745  goto try_again;
1746  }
1747  } while (skip_line(line));
1748  if (av_sscanf(line, "%f %f %f", &lut1d->lut[0][i], &lut1d->lut[1][i], &lut1d->lut[2][i]) != 3)
1749  return AVERROR_INVALIDDATA;
1750  }
1751  break;
1752  }
1753  }
1754 
1755  lut1d->scale.r = av_clipf(1. / (max[0] - min[0]), 0.f, 1.f);
1756  lut1d->scale.g = av_clipf(1. / (max[1] - min[1]), 0.f, 1.f);
1757  lut1d->scale.b = av_clipf(1. / (max[2] - min[2]), 0.f, 1.f);
1758 
1759  return 0;
1760 }
1761 
1762 static const AVOption lut1d_options[] = {
1763  { "file", "set 1D LUT file name", OFFSET(file), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
1764  { "interp", "select interpolation mode", OFFSET(interpolation), AV_OPT_TYPE_INT, {.i64=INTERPOLATE_1D_LINEAR}, 0, NB_INTERP_1D_MODE-1, TFLAGS, "interp_mode" },
1765  { "nearest", "use values from the nearest defined points", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_NEAREST}, 0, 0, TFLAGS, "interp_mode" },
1766  { "linear", "use values from the linear interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_LINEAR}, 0, 0, TFLAGS, "interp_mode" },
1767  { "cosine", "use values from the cosine interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_COSINE}, 0, 0, TFLAGS, "interp_mode" },
1768  { "cubic", "use values from the cubic interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_CUBIC}, 0, 0, TFLAGS, "interp_mode" },
1769  { "spline", "use values from the spline interpolation", 0, AV_OPT_TYPE_CONST, {.i64=INTERPOLATE_1D_SPLINE}, 0, 0, TFLAGS, "interp_mode" },
1770  { NULL }
1771 };
1772 
1773 AVFILTER_DEFINE_CLASS(lut1d);
1774 
1775 static inline float interp_1d_nearest(const LUT1DContext *lut1d,
1776  int idx, const float s)
1777 {
1778  return lut1d->lut[idx][NEAR(s)];
1779 }
1780 
1781 #define NEXT1D(x) (FFMIN((int)(x) + 1, lut1d->lutsize - 1))
1782 
1783 static inline float interp_1d_linear(const LUT1DContext *lut1d,
1784  int idx, const float s)
1785 {
1786  const int prev = PREV(s);
1787  const int next = NEXT1D(s);
1788  const float d = s - prev;
1789  const float p = lut1d->lut[idx][prev];
1790  const float n = lut1d->lut[idx][next];
1791 
1792  return lerpf(p, n, d);
1793 }
1794 
1795 static inline float interp_1d_cosine(const LUT1DContext *lut1d,
1796  int idx, const float s)
1797 {
1798  const int prev = PREV(s);
1799  const int next = NEXT1D(s);
1800  const float d = s - prev;
1801  const float p = lut1d->lut[idx][prev];
1802  const float n = lut1d->lut[idx][next];
1803  const float m = (1.f - cosf(d * M_PI)) * .5f;
1804 
1805  return lerpf(p, n, m);
1806 }
1807 
1808 static inline float interp_1d_cubic(const LUT1DContext *lut1d,
1809  int idx, const float s)
1810 {
1811  const int prev = PREV(s);
1812  const int next = NEXT1D(s);
1813  const float mu = s - prev;
1814  float a0, a1, a2, a3, mu2;
1815 
1816  float y0 = lut1d->lut[idx][FFMAX(prev - 1, 0)];
1817  float y1 = lut1d->lut[idx][prev];
1818  float y2 = lut1d->lut[idx][next];
1819  float y3 = lut1d->lut[idx][FFMIN(next + 1, lut1d->lutsize - 1)];
1820 
1821 
1822  mu2 = mu * mu;
1823  a0 = y3 - y2 - y0 + y1;
1824  a1 = y0 - y1 - a0;
1825  a2 = y2 - y0;
1826  a3 = y1;
1827 
1828  return a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3;
1829 }
1830 
1831 static inline float interp_1d_spline(const LUT1DContext *lut1d,
1832  int idx, const float s)
1833 {
1834  const int prev = PREV(s);
1835  const int next = NEXT1D(s);
1836  const float x = s - prev;
1837  float c0, c1, c2, c3;
1838 
1839  float y0 = lut1d->lut[idx][FFMAX(prev - 1, 0)];
1840  float y1 = lut1d->lut[idx][prev];
1841  float y2 = lut1d->lut[idx][next];
1842  float y3 = lut1d->lut[idx][FFMIN(next + 1, lut1d->lutsize - 1)];
1843 
1844  c0 = y1;
1845  c1 = .5f * (y2 - y0);
1846  c2 = y0 - 2.5f * y1 + 2.f * y2 - .5f * y3;
1847  c3 = .5f * (y3 - y0) + 1.5f * (y1 - y2);
1848 
1849  return ((c3 * x + c2) * x + c1) * x + c0;
1850 }
1851 
1852 #define DEFINE_INTERP_FUNC_PLANAR_1D(name, nbits, depth) \
1853 static int interp_1d_##nbits##_##name##_p##depth(AVFilterContext *ctx, \
1854  void *arg, int jobnr, \
1855  int nb_jobs) \
1856 { \
1857  int x, y; \
1858  const LUT1DContext *lut1d = ctx->priv; \
1859  const ThreadData *td = arg; \
1860  const AVFrame *in = td->in; \
1861  const AVFrame *out = td->out; \
1862  const int direct = out == in; \
1863  const int slice_start = (in->height * jobnr ) / nb_jobs; \
1864  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
1865  uint8_t *grow = out->data[0] + slice_start * out->linesize[0]; \
1866  uint8_t *brow = out->data[1] + slice_start * out->linesize[1]; \
1867  uint8_t *rrow = out->data[2] + slice_start * out->linesize[2]; \
1868  uint8_t *arow = out->data[3] + slice_start * out->linesize[3]; \
1869  const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0]; \
1870  const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1]; \
1871  const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2]; \
1872  const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3]; \
1873  const float factor = (1 << depth) - 1; \
1874  const float scale_r = (lut1d->scale.r / factor) * (lut1d->lutsize - 1); \
1875  const float scale_g = (lut1d->scale.g / factor) * (lut1d->lutsize - 1); \
1876  const float scale_b = (lut1d->scale.b / factor) * (lut1d->lutsize - 1); \
1877  \
1878  for (y = slice_start; y < slice_end; y++) { \
1879  uint##nbits##_t *dstg = (uint##nbits##_t *)grow; \
1880  uint##nbits##_t *dstb = (uint##nbits##_t *)brow; \
1881  uint##nbits##_t *dstr = (uint##nbits##_t *)rrow; \
1882  uint##nbits##_t *dsta = (uint##nbits##_t *)arow; \
1883  const uint##nbits##_t *srcg = (const uint##nbits##_t *)srcgrow; \
1884  const uint##nbits##_t *srcb = (const uint##nbits##_t *)srcbrow; \
1885  const uint##nbits##_t *srcr = (const uint##nbits##_t *)srcrrow; \
1886  const uint##nbits##_t *srca = (const uint##nbits##_t *)srcarow; \
1887  for (x = 0; x < in->width; x++) { \
1888  float r = srcr[x] * scale_r; \
1889  float g = srcg[x] * scale_g; \
1890  float b = srcb[x] * scale_b; \
1891  r = interp_1d_##name(lut1d, 0, r); \
1892  g = interp_1d_##name(lut1d, 1, g); \
1893  b = interp_1d_##name(lut1d, 2, b); \
1894  dstr[x] = av_clip_uintp2(r * factor, depth); \
1895  dstg[x] = av_clip_uintp2(g * factor, depth); \
1896  dstb[x] = av_clip_uintp2(b * factor, depth); \
1897  if (!direct && in->linesize[3]) \
1898  dsta[x] = srca[x]; \
1899  } \
1900  grow += out->linesize[0]; \
1901  brow += out->linesize[1]; \
1902  rrow += out->linesize[2]; \
1903  arow += out->linesize[3]; \
1904  srcgrow += in->linesize[0]; \
1905  srcbrow += in->linesize[1]; \
1906  srcrrow += in->linesize[2]; \
1907  srcarow += in->linesize[3]; \
1908  } \
1909  return 0; \
1910 }
1911 
1912 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 8, 8)
1913 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 8, 8)
1914 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 8, 8)
1915 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 8, 8)
1916 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 8, 8)
1917 
1918 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 16, 9)
1919 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 16, 9)
1920 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 16, 9)
1921 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 16, 9)
1922 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 16, 9)
1923 
1924 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 16, 10)
1925 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 16, 10)
1926 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 16, 10)
1927 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 16, 10)
1928 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 16, 10)
1929 
1930 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 16, 12)
1931 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 16, 12)
1932 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 16, 12)
1933 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 16, 12)
1934 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 16, 12)
1935 
1936 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 16, 14)
1937 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 16, 14)
1938 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 16, 14)
1939 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 16, 14)
1940 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 16, 14)
1941 
1942 DEFINE_INTERP_FUNC_PLANAR_1D(nearest, 16, 16)
1943 DEFINE_INTERP_FUNC_PLANAR_1D(linear, 16, 16)
1944 DEFINE_INTERP_FUNC_PLANAR_1D(cosine, 16, 16)
1945 DEFINE_INTERP_FUNC_PLANAR_1D(cubic, 16, 16)
1946 DEFINE_INTERP_FUNC_PLANAR_1D(spline, 16, 16)
1947 
1948 #define DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(name, depth) \
1949 static int interp_1d_##name##_pf##depth(AVFilterContext *ctx, \
1950  void *arg, int jobnr, \
1951  int nb_jobs) \
1952 { \
1953  int x, y; \
1954  const LUT1DContext *lut1d = ctx->priv; \
1955  const ThreadData *td = arg; \
1956  const AVFrame *in = td->in; \
1957  const AVFrame *out = td->out; \
1958  const int direct = out == in; \
1959  const int slice_start = (in->height * jobnr ) / nb_jobs; \
1960  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
1961  uint8_t *grow = out->data[0] + slice_start * out->linesize[0]; \
1962  uint8_t *brow = out->data[1] + slice_start * out->linesize[1]; \
1963  uint8_t *rrow = out->data[2] + slice_start * out->linesize[2]; \
1964  uint8_t *arow = out->data[3] + slice_start * out->linesize[3]; \
1965  const uint8_t *srcgrow = in->data[0] + slice_start * in->linesize[0]; \
1966  const uint8_t *srcbrow = in->data[1] + slice_start * in->linesize[1]; \
1967  const uint8_t *srcrrow = in->data[2] + slice_start * in->linesize[2]; \
1968  const uint8_t *srcarow = in->data[3] + slice_start * in->linesize[3]; \
1969  const float lutsize = lut1d->lutsize - 1; \
1970  const float scale_r = lut1d->scale.r * lutsize; \
1971  const float scale_g = lut1d->scale.g * lutsize; \
1972  const float scale_b = lut1d->scale.b * lutsize; \
1973  \
1974  for (y = slice_start; y < slice_end; y++) { \
1975  float *dstg = (float *)grow; \
1976  float *dstb = (float *)brow; \
1977  float *dstr = (float *)rrow; \
1978  float *dsta = (float *)arow; \
1979  const float *srcg = (const float *)srcgrow; \
1980  const float *srcb = (const float *)srcbrow; \
1981  const float *srcr = (const float *)srcrrow; \
1982  const float *srca = (const float *)srcarow; \
1983  for (x = 0; x < in->width; x++) { \
1984  float r = av_clipf(sanitizef(srcr[x]) * scale_r, 0.0f, lutsize); \
1985  float g = av_clipf(sanitizef(srcg[x]) * scale_g, 0.0f, lutsize); \
1986  float b = av_clipf(sanitizef(srcb[x]) * scale_b, 0.0f, lutsize); \
1987  r = interp_1d_##name(lut1d, 0, r); \
1988  g = interp_1d_##name(lut1d, 1, g); \
1989  b = interp_1d_##name(lut1d, 2, b); \
1990  dstr[x] = r; \
1991  dstg[x] = g; \
1992  dstb[x] = b; \
1993  if (!direct && in->linesize[3]) \
1994  dsta[x] = srca[x]; \
1995  } \
1996  grow += out->linesize[0]; \
1997  brow += out->linesize[1]; \
1998  rrow += out->linesize[2]; \
1999  arow += out->linesize[3]; \
2000  srcgrow += in->linesize[0]; \
2001  srcbrow += in->linesize[1]; \
2002  srcrrow += in->linesize[2]; \
2003  srcarow += in->linesize[3]; \
2004  } \
2005  return 0; \
2006 }
2007 
2008 DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(nearest, 32)
2009 DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(linear, 32)
2010 DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(cosine, 32)
2011 DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(cubic, 32)
2012 DEFINE_INTERP_FUNC_PLANAR_1D_FLOAT(spline, 32)
2013 
2014 #define DEFINE_INTERP_FUNC_1D(name, nbits) \
2015 static int interp_1d_##nbits##_##name(AVFilterContext *ctx, void *arg, \
2016  int jobnr, int nb_jobs) \
2017 { \
2018  int x, y; \
2019  const LUT1DContext *lut1d = ctx->priv; \
2020  const ThreadData *td = arg; \
2021  const AVFrame *in = td->in; \
2022  const AVFrame *out = td->out; \
2023  const int direct = out == in; \
2024  const int step = lut1d->step; \
2025  const uint8_t r = lut1d->rgba_map[R]; \
2026  const uint8_t g = lut1d->rgba_map[G]; \
2027  const uint8_t b = lut1d->rgba_map[B]; \
2028  const uint8_t a = lut1d->rgba_map[A]; \
2029  const int slice_start = (in->height * jobnr ) / nb_jobs; \
2030  const int slice_end = (in->height * (jobnr+1)) / nb_jobs; \
2031  uint8_t *dstrow = out->data[0] + slice_start * out->linesize[0]; \
2032  const uint8_t *srcrow = in ->data[0] + slice_start * in ->linesize[0]; \
2033  const float factor = (1 << nbits) - 1; \
2034  const float scale_r = (lut1d->scale.r / factor) * (lut1d->lutsize - 1); \
2035  const float scale_g = (lut1d->scale.g / factor) * (lut1d->lutsize - 1); \
2036  const float scale_b = (lut1d->scale.b / factor) * (lut1d->lutsize - 1); \
2037  \
2038  for (y = slice_start; y < slice_end; y++) { \
2039  uint##nbits##_t *dst = (uint##nbits##_t *)dstrow; \
2040  const uint##nbits##_t *src = (const uint##nbits##_t *)srcrow; \
2041  for (x = 0; x < in->width * step; x += step) { \
2042  float rr = src[x + r] * scale_r; \
2043  float gg = src[x + g] * scale_g; \
2044  float bb = src[x + b] * scale_b; \
2045  rr = interp_1d_##name(lut1d, 0, rr); \
2046  gg = interp_1d_##name(lut1d, 1, gg); \
2047  bb = interp_1d_##name(lut1d, 2, bb); \
2048  dst[x + r] = av_clip_uint##nbits(rr * factor); \
2049  dst[x + g] = av_clip_uint##nbits(gg * factor); \
2050  dst[x + b] = av_clip_uint##nbits(bb * factor); \
2051  if (!direct && step == 4) \
2052  dst[x + a] = src[x + a]; \
2053  } \
2054  dstrow += out->linesize[0]; \
2055  srcrow += in ->linesize[0]; \
2056  } \
2057  return 0; \
2058 }
2059 
2060 DEFINE_INTERP_FUNC_1D(nearest, 8)
2061 DEFINE_INTERP_FUNC_1D(linear, 8)
2062 DEFINE_INTERP_FUNC_1D(cosine, 8)
2063 DEFINE_INTERP_FUNC_1D(cubic, 8)
2064 DEFINE_INTERP_FUNC_1D(spline, 8)
2065 
2066 DEFINE_INTERP_FUNC_1D(nearest, 16)
2067 DEFINE_INTERP_FUNC_1D(linear, 16)
2068 DEFINE_INTERP_FUNC_1D(cosine, 16)
2069 DEFINE_INTERP_FUNC_1D(cubic, 16)
2070 DEFINE_INTERP_FUNC_1D(spline, 16)
2071 
2072 static int config_input_1d(AVFilterLink *inlink)
2073 {
2074  int depth, is16bit, isfloat, planar;
2075  LUT1DContext *lut1d = inlink->dst->priv;
2076  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
2077 
2078  depth = desc->comp[0].depth;
2079  is16bit = desc->comp[0].depth > 8;
2080  planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
2081  isfloat = desc->flags & AV_PIX_FMT_FLAG_FLOAT;
2082  ff_fill_rgba_map(lut1d->rgba_map, inlink->format);
2083  lut1d->step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);
2084 
2085 #define SET_FUNC_1D(name) do { \
2086  if (planar && !isfloat) { \
2087  switch (depth) { \
2088  case 8: lut1d->interp = interp_1d_8_##name##_p8; break; \
2089  case 9: lut1d->interp = interp_1d_16_##name##_p9; break; \
2090  case 10: lut1d->interp = interp_1d_16_##name##_p10; break; \
2091  case 12: lut1d->interp = interp_1d_16_##name##_p12; break; \
2092  case 14: lut1d->interp = interp_1d_16_##name##_p14; break; \
2093  case 16: lut1d->interp = interp_1d_16_##name##_p16; break; \
2094  } \
2095  } else if (isfloat) { lut1d->interp = interp_1d_##name##_pf32; \
2096  } else if (is16bit) { lut1d->interp = interp_1d_16_##name; \
2097  } else { lut1d->interp = interp_1d_8_##name; } \
2098 } while (0)
2099 
2100  switch (lut1d->interpolation) {
2101  case INTERPOLATE_1D_NEAREST: SET_FUNC_1D(nearest); break;
2102  case INTERPOLATE_1D_LINEAR: SET_FUNC_1D(linear); break;
2103  case INTERPOLATE_1D_COSINE: SET_FUNC_1D(cosine); break;
2104  case INTERPOLATE_1D_CUBIC: SET_FUNC_1D(cubic); break;
2105  case INTERPOLATE_1D_SPLINE: SET_FUNC_1D(spline); break;
2106  default:
2107  av_assert0(0);
2108  }
2109 
2110  return 0;
2111 }
2112 
2113 static av_cold int lut1d_init(AVFilterContext *ctx)
2114 {
2115  int ret;
2116  FILE *f;
2117  const char *ext;
2118  LUT1DContext *lut1d = ctx->priv;
2119 
2120  lut1d->scale.r = lut1d->scale.g = lut1d->scale.b = 1.f;
2121 
2122  if (!lut1d->file) {
2123  set_identity_matrix_1d(lut1d, 32);
2124  return 0;
2125  }
2126 
2127  f = av_fopen_utf8(lut1d->file, "r");
2128  if (!f) {
2129  ret = AVERROR(errno);
2130  av_log(ctx, AV_LOG_ERROR, "%s: %s\n", lut1d->file, av_err2str(ret));
2131  return ret;
2132  }
2133 
2134  ext = strrchr(lut1d->file, '.');
2135  if (!ext) {
2136  av_log(ctx, AV_LOG_ERROR, "Unable to guess the format from the extension\n");
2137  ret = AVERROR_INVALIDDATA;
2138  goto end;
2139  }
2140  ext++;
2141 
2142  if (!av_strcasecmp(ext, "cube") || !av_strcasecmp(ext, "1dlut")) {
2143  ret = parse_cube_1d(ctx, f);
2144  } else if (!av_strcasecmp(ext, "csp")) {
2145  ret = parse_cinespace_1d(ctx, f);
2146  } else {
2147  av_log(ctx, AV_LOG_ERROR, "Unrecognized '.%s' file type\n", ext);
2148  ret = AVERROR(EINVAL);
2149  }
2150 
2151  if (!ret && !lut1d->lutsize) {
2152  av_log(ctx, AV_LOG_ERROR, "1D LUT is empty\n");
2153  ret = AVERROR_INVALIDDATA;
2154  }
2155 
2156 end:
2157  fclose(f);
2158  return ret;
2159 }
2160 
2161 static AVFrame *apply_1d_lut(AVFilterLink *inlink, AVFrame *in)
2162 {
2163  AVFilterContext *ctx = inlink->dst;
2164  LUT1DContext *lut1d = ctx->priv;
2165  AVFilterLink *outlink = inlink->dst->outputs[0];
2166  AVFrame *out;
2167  ThreadData td;
2168 
2169  if (av_frame_is_writable(in)) {
2170  out = in;
2171  } else {
2172  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
2173  if (!out) {
2174  av_frame_free(&in);
2175  return NULL;
2176  }
2177  av_frame_copy_props(out, in);
2178  }
2179 
2180  td.in = in;
2181  td.out = out;
2182  ff_filter_execute(ctx, lut1d->interp, &td, NULL,
2183  FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
2184 
2185  if (out != in)
2186  av_frame_free(&in);
2187 
2188  return out;
2189 }
2190 
2191 static int filter_frame_1d(AVFilterLink *inlink, AVFrame *in)
2192 {
2193  AVFilterLink *outlink = inlink->dst->outputs[0];
2194  AVFrame *out = apply_1d_lut(inlink, in);
2195  if (!out)
2196  return AVERROR(ENOMEM);
2197  return ff_filter_frame(outlink, out);
2198 }
2199 
2200 static int lut1d_process_command(AVFilterContext *ctx, const char *cmd, const char *args,
2201  char *res, int res_len, int flags)
2202 {
2203  LUT1DContext *lut1d = ctx->priv;
2204  int ret;
2205 
2206  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
2207  if (ret < 0)
2208  return ret;
2209 
2210  ret = lut1d_init(ctx);
2211  if (ret < 0) {
2212  set_identity_matrix_1d(lut1d, 32);
2213  return ret;
2214  }
2215  return config_input_1d(ctx->inputs[0]);
2216 }
2217 
2218 static const AVFilterPad lut1d_inputs[] = {
2219  {
2220  .name = "default",
2221  .type = AVMEDIA_TYPE_VIDEO,
2222  .filter_frame = filter_frame_1d,
2223  .config_props = config_input_1d,
2224  },
2225 };
2226 
2227 static const AVFilterPad lut1d_outputs[] = {
2228  {
2229  .name = "default",
2230  .type = AVMEDIA_TYPE_VIDEO,
2231  },
2232 };
2233 
2234 const AVFilter ff_vf_lut1d = {
2235  .name = "lut1d",
2236  .description = NULL_IF_CONFIG_SMALL("Adjust colors using a 1D LUT."),
2237  .priv_size = sizeof(LUT1DContext),
2238  .init = lut1d_init,
2239  FILTER_INPUTS(lut1d_inputs),
2240  FILTER_OUTPUTS(lut1d_outputs),
2241  FILTER_PIXFMTS_ARRAY(pix_fmts),
2242  .priv_class = &lut1d_class,
2243  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
2244  .process_command = lut1d_process_command,
2245 };
2246 #endif
apply_lut
static AVFrame * apply_lut(AVFilterLink *inlink, AVFrame *in)
Definition: vf_lut3d.c:1158
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:98
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vf_lut3d.c:49
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_lut3d.c:1113
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:426
DEFINE_INTERP_FUNC_PLANAR_FLOAT
#define DEFINE_INTERP_FUNC_PLANAR_FLOAT(name, depth)
Definition: vf_lut3d.c:418
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition: vf_lut3d.c:546
lerpf
static float lerpf(float v0, float v1, float f)
Definition: vf_lut3d.c:82
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:119
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
mix
static int mix(int c0, int c1)
Definition: 4xm.c:716
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
parse_m3d
static int parse_m3d(AVFilterContext *ctx, FILE *f)
Definition: vf_lut3d.c:766
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:285
out
FILE * out
Definition: movenc.c:54
rgbvec
Definition: lut3d.h:37
NEXT_FLOAT_OR_GOTO
#define NEXT_FLOAT_OR_GOTO(value, label)
Definition: vf_lut3d.c:863
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
avfilter_action_func
int() avfilter_action_func(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A function pointer passed to the AVFilterGraph::execute callback to be executed multiple times,...
Definition: avfilter.h:844
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
apply_prelut
static struct rgbvec apply_prelut(const Lut3DPreLut *prelut, const struct rgbvec *s)
Definition: vf_lut3d.c:306
lerp
static struct rgbvec lerp(const struct rgbvec *v0, const struct rgbvec *v1, float f)
Definition: vf_lut3d.c:87
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:171
parse_dat
static int parse_dat(AVFilterContext *ctx, FILE *f)
Definition: vf_lut3d.c:639
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:227
LUT3DContext::lutsize2
int lutsize2
Definition: lut3d.h:58
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
LUT3DContext::scale
struct rgbvec scale
Definition: lut3d.h:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
w
uint8_t w
Definition: llviddspenc.c:38
av_intfloat32::i
uint32_t i
Definition: intfloat.h:28
AVOption
AVOption.
Definition: opt.h:247
skip_line
static int skip_line(const char *p)
Definition: vf_lut3d.c:548
b
#define b
Definition: input.c:40
lut3d.h
data
const char data[16]
Definition: mxf.c:143
linear
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
Definition: interplayacm.c:131
float.h
interp_tetrahedral
static struct rgbvec interp_tetrahedral(const LUT3DContext *lut3d, const struct rgbvec *s)
Tetrahedral interpolation.
Definition: vf_lut3d.c:237
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
preinit
static av_cold int preinit(AVFilterContext *ctx)
Definition: af_aresample.c:46
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
interp_prism
static struct rgbvec interp_prism(const LUT3DContext *lut3d, const struct rgbvec *s)
Definition: vf_lut3d.c:188
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:169
c1
static const uint64_t c1
Definition: murmur3.c:51
AVFILTER_DEFINE_CLASS_EXT
#define AVFILTER_DEFINE_CLASS_EXT(name, desc, options)
Definition: internal.h:318
FFFrameSync
Frame sync structure.
Definition: framesync.h:146
parse_cube
static int parse_cube(AVFilterContext *ctx, FILE *f)
Definition: vf_lut3d.c:674
intfloat.h
video.h
ff_vf_lut3d
const AVFilter ff_vf_lut3d
MANTISSA_MASK
#define MANTISSA_MASK
Definition: vf_lut3d.c:59
SIGN_MASK
#define SIGN_MASK
Definition: vf_lut3d.c:60
LUT3DContext
Definition: lut3d.h:54
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_lut3d.c:1197
INTERPOLATE_PYRAMID
@ INTERPOLATE_PYRAMID
Definition: lut3d.h:32
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
formats.h
init
static int init
Definition: av_tx.c:47
Lut3DPreLut::lut
float * lut[3]
Definition: lut3d.h:51
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2700
parse_3dl
static int parse_3dl(AVFilterContext *ctx, FILE *f)
Definition: vf_lut3d.c:731
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:422
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
v0
#define v0
Definition: regdef.h:26
cosf
#define cosf(x)
Definition: libm.h:78
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:420
val
static double val(void *priv, double ch)
Definition: aeval.c:76
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
interp_trilinear
static struct rgbvec interp_trilinear(const LUT3DContext *lut3d, const struct rgbvec *s)
Interpolate using the 8 vertices of a cube.
Definition: vf_lut3d.c:112
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
a1
#define a1
Definition: regdef.h:47
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_lut3d.c:1095
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_adenorm.c:156
SET_COLOR
#define SET_COLOR(id)
INTERPOLATE_NEAREST
@ INTERPOLATE_NEAREST
Definition: lut3d.h:29
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
LUT3DContext::file
char * file
Definition: lut3d.h:61
av_cold
#define av_cold
Definition: attributes.h:90
av_fopen_utf8
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
Lut3DPreLut::scale
float scale[3]
Definition: lut3d.h:50
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:424
OFFSET
#define OFFSET(x)
Definition: vf_lut3d.c:46
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:425
g
const char * g
Definition: vf_curves.c:117
SET_FUNC
#define SET_FUNC(name)
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
INTERPOLATE_PRISM
@ INTERPOLATE_PRISM
Definition: lut3d.h:33
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
fget_next_word
static char * fget_next_word(char *dst, int max, FILE *f)
Definition: vf_lut3d.c:555
DEFINE_INTERP_FUNC
#define DEFINE_INTERP_FUNC(name, nbits)
Definition: vf_lut3d.c:485
Lut3DPreLut::size
int size
Definition: lut3d.h:47
f
#define f(width, name)
Definition: cbs_vp9.c:255
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:191
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_lut3d.c:1188
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:423
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:394
av_sscanf
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:960
prelut_interp_1d_linear
static float prelut_interp_1d_linear(const Lut3DPreLut *prelut, int idx, const float s)
Definition: vf_lut3d.c:292
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
rgbvec::r
float r
Definition: lut3d.h:38
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:395
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:537
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
activate
filter_frame For filters that do not use the activate() callback
av_clipf
#define av_clipf
Definition: common.h:144
FRAMESYNC_DEFINE_CLASS_EXT
#define FRAMESYNC_DEFINE_CLASS_EXT(name, context, field, options)
Definition: framesync.h:324
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:230
av_intfloat32
Definition: intfloat.h:27
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:419
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
ff_framesync_init_dualinput
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
Definition: framesync.c:353
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
master
const char * master
Definition: vf_curves.c:119
av_get_padded_bits_per_pixel
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2625
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:433
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:390
size
int size
Definition: twinvq_data.h:10344
Lut3DPreLut::min
float min[3]
Definition: lut3d.h:48
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:473
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:882
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
EXPONENT_MASK
#define EXPONENT_MASK
Definition: vf_lut3d.c:58
line
Definition: graph2dot.c:48
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:228
set_identity_matrix
static int set_identity_matrix(AVFilterContext *ctx, int size)
Definition: vf_lut3d.c:1070
PREV
#define PREV(x)
Definition: vf_lut3d.c:96
a0
#define a0
Definition: regdef.h:46
interpolation
static int interpolation(DeclickChannel *c, const double *src, int ar_order, double *acoefficients, int *index, int nb_errors, double *auxiliary, double *interpolated)
Definition: af_adeclick.c:336
M_PI
#define M_PI
Definition: mathematics.h:52
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
PRELUT_SIZE
#define PRELUT_SIZE
Definition: lut3d.h:44
internal.h
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:326
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:146
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:399
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
LUT3DContext::interp
avfilter_action_func * interp
Definition: lut3d.h:64
DEFINE_INTERP_FUNC_PLANAR
#define DEFINE_INTERP_FUNC_PLANAR(name, nbits, depth)
Definition: vf_lut3d.c:320
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:421
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
a2
#define a2
Definition: regdef.h:48
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:803
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
INTERPOLATE_TETRAHEDRAL
@ INTERPOLATE_TETRAHEDRAL
Definition: lut3d.h:31
Lut3DPreLut::max
float max[3]
Definition: lut3d.h:49
interp_pyramid
static struct rgbvec interp_pyramid(const LUT3DContext *lut3d, const struct rgbvec *s)
Definition: vf_lut3d.c:138
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
parse_cinespace
static int parse_cinespace(AVFilterContext *ctx, FILE *f)
Definition: vf_lut3d.c:873
Lut3DPreLut
Definition: lut3d.h:46
AVFilter
Filter definition.
Definition: avfilter.h:165
sanitizef
static float sanitizef(float f)
Definition: vf_lut3d.c:62
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:229
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
allocate_3dlut
static int allocate_3dlut(AVFilterContext *ctx, int lutsize, int prelut)
Definition: vf_lut3d.c:604
NEXT_LINE_OR_GOTO
#define NEXT_LINE_OR_GOTO(loop_cond, label)
Definition: vf_lut3d.c:596
rgbvec::g
float g
Definition: lut3d.h:38
ff_vf_haldclut
const AVFilter ff_vf_haldclut
NEXT
#define NEXT(x)
Definition: vf_lut3d.c:97
LUT3DContext::prelut
Lut3DPreLut prelut
Definition: lut3d.h:65
c2
static const uint64_t c2
Definition: murmur3.c:52
rgbvec::b
float b
Definition: lut3d.h:38
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:434
interp_nearest
static struct rgbvec interp_nearest(const LUT3DContext *lut3d, const struct rgbvec *s)
Get the nearest defined point.
Definition: vf_lut3d.c:102
LUT3DContext::step
int step
Definition: lut3d.h:63
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
file.h
TFLAGS
#define TFLAGS
Definition: vf_lut3d.c:48
AVFilterContext
An instance of a filter.
Definition: avfilter.h:402
NEXT_LINE
#define NEXT_LINE(loop_cond)
Definition: vf_lut3d.c:589
av_intfloat32::f
float f
Definition: intfloat.h:29
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:121
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FLAGS
#define FLAGS
Definition: vf_lut3d.c:47
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:192
INTERPOLATE_TRILINEAR
@ INTERPOLATE_TRILINEAR
Definition: lut3d.h:30
NEAR
#define NEAR(x)
Definition: vf_lut3d.c:95
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:34
ff_lut3d_init_x86
void ff_lut3d_init_x86(LUT3DContext *s, const AVPixFmtDescriptor *desc)
Definition: vf_lut3d_init.c:58
d
d
Definition: ffmpeg_filter.c:153
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:154
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:227
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:282
h
h
Definition: vp9dsp_template.c:2038
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:336
ff_vf_lut1d
const AVFilter ff_vf_lut1d
avstring.h
ff_framesync_dualinput_get
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
Definition: framesync.c:371
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:143
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
a3
#define a3
Definition: regdef.h:49
LUT3DContext::lutsize
int lutsize
Definition: lut3d.h:57
LUT3DContext::lut
struct rgbvec * lut
Definition: lut3d.h:56
LUT3DContext::interpolation
int interpolation
interp_mode
Definition: lut3d.h:60
LUT3DContext::rgba_map
uint8_t rgba_map[4]
Definition: lut3d.h:62
min
float min
Definition: vorbis_enc_data.h:429
nearest_sample_index
static int nearest_sample_index(float *data, float x, int low, int hi)
Definition: vf_lut3d.c:835
Generated on Wed Aug 24 2022 21:38:14 for FFmpeg by   doxygen 1.8.17