1 /*
2 * Copyright (C) 2007 by Andrew Zabolotny (author of lensfun, from which this filter derives from)
3 * Copyright (C) 2018 Stephen Seo
4 *
5 * This file is part of FFmpeg.
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program 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
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21 /**
22 * @file
23 * Lensfun filter, applies lens correction with parameters from the lensfun database
24 *
25 * @see https://lensfun.sourceforge.net/
26 */
27
28 #include <float.h>
29 #include <math.h>
30
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/opt.h"
34 #include "libswscale/swscale.h"
35 #include "avfilter.h"
36 #include "formats.h"
37 #include "internal.h"
38 #include "video.h"
39
40 #include <lensfun.h>
41
42 #define LANCZOS_RESOLUTION 256
43
44 enum Mode {
45 VIGNETTING = 0x1,
46 GEOMETRY_DISTORTION = 0x2,
47 SUBPIXEL_DISTORTION = 0x4
48 };
49
50 enum InterpolationType {
51 NEAREST,
52 LINEAR,
53 LANCZOS
54 };
55
56 typedef struct VignettingThreadData {
57 int width, height;
58 uint8_t *data_in;
59 int linesize_in;
60 int pixel_composition;
61 lfModifier *modifier;
62 } VignettingThreadData;
63
64 typedef struct DistortionCorrectionThreadData {
65 int width, height;
66 const float *distortion_coords;
67 const uint8_t *data_in;
68 uint8_t *data_out;
69 int linesize_in, linesize_out;
70 const float *interpolation;
71 int mode;
72 int interpolation_type;
73 } DistortionCorrectionThreadData;
74
75 typedef struct LensfunContext {
76 const AVClass *class;
77 const char *make, *model, *lens_model;
78 int mode;
79 float focal_length;
80 float aperture;
81 float focus_distance;
82 float scale;
83 int target_geometry;
84 int reverse;
85 int interpolation_type;
86
87 float *distortion_coords;
88 float *interpolation;
89
90 lfLens *lens;
91 lfCamera *camera;
92 lfModifier *modifier;
93 } LensfunContext;
94
95 #define OFFSET(x) offsetof(LensfunContext, x)
96 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
97 static const AVOption lensfun_options[] = {
98 { "make", "set camera maker", OFFSET(make), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
99 { "model", "set camera model", OFFSET(model), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
100 { "lens_model", "set lens model", OFFSET(lens_model), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
101 { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=GEOMETRY_DISTORTION}, 0, VIGNETTING | GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION, FLAGS, "mode" },
102 { "vignetting", "fix lens vignetting", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING}, 0, 0, FLAGS, "mode" },
103 { "geometry", "correct geometry distortion", 0, AV_OPT_TYPE_CONST, {.i64=GEOMETRY_DISTORTION}, 0, 0, FLAGS, "mode" },
104 { "subpixel", "fix chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
105 { "vig_geo", "fix lens vignetting and correct geometry distortion", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | GEOMETRY_DISTORTION}, 0, 0, FLAGS, "mode" },
106 { "vig_subpixel", "fix lens vignetting and chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
107 { "distortion", "correct geometry distortion and chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
108 { "all", NULL, 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
109 { "focal_length", "focal length of video (zoom; constant for the duration of the use of this filter)", OFFSET(focal_length), AV_OPT_TYPE_FLOAT, {.dbl=18}, 0.0, DBL_MAX, FLAGS },
110 { "aperture", "aperture (constant for the duration of the use of this filter)", OFFSET(aperture), AV_OPT_TYPE_FLOAT, {.dbl=3.5}, 0.0, DBL_MAX, FLAGS },
111 { "focus_distance", "focus distance (constant for the duration of the use of this filter)", OFFSET(focus_distance), AV_OPT_TYPE_FLOAT, {.dbl=1000.0f}, 0.0, DBL_MAX, FLAGS },
112 { "scale", "scale factor applied after corrections (0.0 means automatic scaling)", OFFSET(scale), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, DBL_MAX, FLAGS },
113 { "target_geometry", "target geometry of the lens correction (only when geometry correction is enabled)", OFFSET(target_geometry), AV_OPT_TYPE_INT, {.i64=LF_RECTILINEAR}, 0, INT_MAX, FLAGS, "lens_geometry" },
114 { "rectilinear", "rectilinear lens (default)", 0, AV_OPT_TYPE_CONST, {.i64=LF_RECTILINEAR}, 0, 0, FLAGS, "lens_geometry" },
115 { "fisheye", "fisheye lens", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE}, 0, 0, FLAGS, "lens_geometry" },
116 { "panoramic", "panoramic (cylindrical)", 0, AV_OPT_TYPE_CONST, {.i64=LF_PANORAMIC}, 0, 0, FLAGS, "lens_geometry" },
117 { "equirectangular", "equirectangular", 0, AV_OPT_TYPE_CONST, {.i64=LF_EQUIRECTANGULAR}, 0, 0, FLAGS, "lens_geometry" },
118 { "fisheye_orthographic", "orthographic fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_ORTHOGRAPHIC}, 0, 0, FLAGS, "lens_geometry" },
119 { "fisheye_stereographic", "stereographic fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_STEREOGRAPHIC}, 0, 0, FLAGS, "lens_geometry" },
120 { "fisheye_equisolid", "equisolid fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_EQUISOLID}, 0, 0, FLAGS, "lens_geometry" },
121 { "fisheye_thoby", "fisheye as measured by thoby", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_THOBY}, 0, 0, FLAGS, "lens_geometry" },
122 { "reverse", "Does reverse correction (regular image to lens distorted)", OFFSET(reverse), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
123 { "interpolation", "Type of interpolation", OFFSET(interpolation_type), AV_OPT_TYPE_INT, {.i64=LINEAR}, 0, LANCZOS, FLAGS, "interpolation" },
124 { "nearest", NULL, 0, AV_OPT_TYPE_CONST, {.i64=NEAREST}, 0, 0, FLAGS, "interpolation" },
125 { "linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "interpolation" },
126 { "lanczos", NULL, 0, AV_OPT_TYPE_CONST, {.i64=LANCZOS}, 0, 0, FLAGS, "interpolation" },
127 { NULL }
128 };
129
130 AVFILTER_DEFINE_CLASS(lensfun);
131
init(AVFilterContext * ctx)132 static av_cold int init(AVFilterContext *ctx)
133 {
134 LensfunContext *lensfun = ctx->priv;
135 lfDatabase *db;
136 const lfCamera **cameras;
137 const lfLens **lenses;
138
139 if (!lensfun->make) {
140 av_log(ctx, AV_LOG_FATAL, "Option \"make\" not specified\n");
141 return AVERROR(EINVAL);
142 } else if (!lensfun->model) {
143 av_log(ctx, AV_LOG_FATAL, "Option \"model\" not specified\n");
144 return AVERROR(EINVAL);
145 } else if (!lensfun->lens_model) {
146 av_log(ctx, AV_LOG_FATAL, "Option \"lens_model\" not specified\n");
147 return AVERROR(EINVAL);
148 }
149
150 lensfun->lens = lf_lens_new();
151 lensfun->camera = lf_camera_new();
152
153 db = lf_db_new();
154 if (lf_db_load(db) != LF_NO_ERROR) {
155 lf_db_destroy(db);
156 av_log(ctx, AV_LOG_FATAL, "Failed to load lensfun database\n");
157 return AVERROR_INVALIDDATA;
158 }
159
160 cameras = lf_db_find_cameras(db, lensfun->make, lensfun->model);
161 if (cameras && *cameras) {
162 lf_camera_copy(lensfun->camera, *cameras);
163 av_log(ctx, AV_LOG_INFO, "Using camera %s\n", lensfun->camera->Model);
164 } else {
165 lf_free(cameras);
166 lf_db_destroy(db);
167 av_log(ctx, AV_LOG_FATAL, "Failed to find camera in lensfun database\n");
168 return AVERROR_INVALIDDATA;
169 }
170 lf_free(cameras);
171
172 lenses = lf_db_find_lenses_hd(db, lensfun->camera, NULL, lensfun->lens_model, 0);
173 if (lenses && *lenses) {
174 lf_lens_copy(lensfun->lens, *lenses);
175 av_log(ctx, AV_LOG_INFO, "Using lens %s\n", lensfun->lens->Model);
176 } else {
177 lf_free(lenses);
178 lf_db_destroy(db);
179 av_log(ctx, AV_LOG_FATAL, "Failed to find lens in lensfun database\n");
180 return AVERROR_INVALIDDATA;
181 }
182 lf_free(lenses);
183
184 lf_db_destroy(db);
185 return 0;
186 }
187
query_formats(AVFilterContext * ctx)188 static int query_formats(AVFilterContext *ctx)
189 {
190 // Some of the functions provided by lensfun require pixels in RGB format
191 static const enum AVPixelFormat fmts[] = {AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE};
192 AVFilterFormats *fmts_list = ff_make_format_list(fmts);
193 return ff_set_common_formats(ctx, fmts_list);
194 }
195
lanczos_kernel(float x)196 static float lanczos_kernel(float x)
197 {
198 if (x == 0.0f) {
199 return 1.0f;
200 } else if (x > -2.0f && x < 2.0f) {
201 return (2.0f * sin(M_PI * x) * sin(M_PI / 2.0f * x)) / (M_PI * M_PI * x * x);
202 } else {
203 return 0.0f;
204 }
205 }
206
config_props(AVFilterLink * inlink)207 static int config_props(AVFilterLink *inlink)
208 {
209 AVFilterContext *ctx = inlink->dst;
210 LensfunContext *lensfun = ctx->priv;
211 int index;
212 float a;
213 int lensfun_mode = 0;
214
215 if (!lensfun->modifier) {
216 if (lensfun->camera && lensfun->lens) {
217 lensfun->modifier = lf_modifier_new(lensfun->lens,
218 lensfun->camera->CropFactor,
219 inlink->w,
220 inlink->h);
221 if (lensfun->mode & VIGNETTING)
222 lensfun_mode |= LF_MODIFY_VIGNETTING;
223 if (lensfun->mode & GEOMETRY_DISTORTION)
224 lensfun_mode |= LF_MODIFY_DISTORTION | LF_MODIFY_GEOMETRY | LF_MODIFY_SCALE;
225 if (lensfun->mode & SUBPIXEL_DISTORTION)
226 lensfun_mode |= LF_MODIFY_TCA;
227 lf_modifier_initialize(lensfun->modifier,
228 lensfun->lens,
229 LF_PF_U8,
230 lensfun->focal_length,
231 lensfun->aperture,
232 lensfun->focus_distance,
233 lensfun->scale,
234 lensfun->target_geometry,
235 lensfun_mode,
236 lensfun->reverse);
237 } else {
238 // lensfun->camera and lensfun->lens should have been initialized
239 return AVERROR_BUG;
240 }
241 }
242
243 if (!lensfun->distortion_coords) {
244 if (lensfun->mode & SUBPIXEL_DISTORTION) {
245 lensfun->distortion_coords = av_malloc_array(inlink->w * inlink->h, sizeof(float) * 2 * 3);
246 if (!lensfun->distortion_coords)
247 return AVERROR(ENOMEM);
248 if (lensfun->mode & GEOMETRY_DISTORTION) {
249 // apply both geometry and subpixel distortion
250 lf_modifier_apply_subpixel_geometry_distortion(lensfun->modifier,
251 0, 0,
252 inlink->w, inlink->h,
253 lensfun->distortion_coords);
254 } else {
255 // apply only subpixel distortion
256 lf_modifier_apply_subpixel_distortion(lensfun->modifier,
257 0, 0,
258 inlink->w, inlink->h,
259 lensfun->distortion_coords);
260 }
261 } else if (lensfun->mode & GEOMETRY_DISTORTION) {
262 lensfun->distortion_coords = av_malloc_array(inlink->w * inlink->h, sizeof(float) * 2);
263 if (!lensfun->distortion_coords)
264 return AVERROR(ENOMEM);
265 // apply only geometry distortion
266 lf_modifier_apply_geometry_distortion(lensfun->modifier,
267 0, 0,
268 inlink->w, inlink->h,
269 lensfun->distortion_coords);
270 }
271 }
272
273 if (!lensfun->interpolation)
274 if (lensfun->interpolation_type == LANCZOS) {
275 lensfun->interpolation = av_malloc_array(LANCZOS_RESOLUTION, sizeof(float) * 4);
276 if (!lensfun->interpolation)
277 return AVERROR(ENOMEM);
278 for (index = 0; index < 4 * LANCZOS_RESOLUTION; ++index) {
279 if (index == 0) {
280 lensfun->interpolation[index] = 1.0f;
281 } else {
282 a = sqrtf((float)index / LANCZOS_RESOLUTION);
283 lensfun->interpolation[index] = lanczos_kernel(a);
284 }
285 }
286 }
287
288 return 0;
289 }
290
vignetting_filter_slice(AVFilterContext * ctx,void * arg,int jobnr,int nb_jobs)291 static int vignetting_filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
292 {
293 const VignettingThreadData *thread_data = arg;
294 const int slice_start = thread_data->height * jobnr / nb_jobs;
295 const int slice_end = thread_data->height * (jobnr + 1) / nb_jobs;
296
297 lf_modifier_apply_color_modification(thread_data->modifier,
298 thread_data->data_in + slice_start * thread_data->linesize_in,
299 0,
300 slice_start,
301 thread_data->width,
302 slice_end - slice_start,
303 thread_data->pixel_composition,
304 thread_data->linesize_in);
305
306 return 0;
307 }
308
square(float x)309 static float square(float x)
310 {
311 return x * x;
312 }
313
distortion_correction_filter_slice(AVFilterContext * ctx,void * arg,int jobnr,int nb_jobs)314 static int distortion_correction_filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
315 {
316 const DistortionCorrectionThreadData *thread_data = arg;
317 const int slice_start = thread_data->height * jobnr / nb_jobs;
318 const int slice_end = thread_data->height * (jobnr + 1) / nb_jobs;
319
320 int x, y, i, j, rgb_index;
321 float interpolated, new_x, new_y, d, norm;
322 int new_x_int, new_y_int;
323 for (y = slice_start; y < slice_end; ++y)
324 for (x = 0; x < thread_data->width; ++x)
325 for (rgb_index = 0; rgb_index < 3; ++rgb_index) {
326 if (thread_data->mode & SUBPIXEL_DISTORTION) {
327 // subpixel (and possibly geometry) distortion correction was applied, correct distortion
328 switch(thread_data->interpolation_type) {
329 case NEAREST:
330 new_x_int = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2] + 0.5f;
331 new_y_int = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1] + 0.5f;
332 if (new_x_int < 0 || new_x_int >= thread_data->width || new_y_int < 0 || new_y_int >= thread_data->height) {
333 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
334 } else {
335 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = thread_data->data_in[new_x_int * 3 + rgb_index + new_y_int * thread_data->linesize_in];
336 }
337 break;
338 case LINEAR:
339 interpolated = 0.0f;
340 new_x = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2];
341 new_x_int = new_x;
342 new_y = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1];
343 new_y_int = new_y;
344 if (new_x_int < 0 || new_x_int + 1 >= thread_data->width || new_y_int < 0 || new_y_int + 1 >= thread_data->height) {
345 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
346 } else {
347 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] =
348 thread_data->data_in[ new_x_int * 3 + rgb_index + new_y_int * thread_data->linesize_in] * (new_x_int + 1 - new_x) * (new_y_int + 1 - new_y)
349 + thread_data->data_in[(new_x_int + 1) * 3 + rgb_index + new_y_int * thread_data->linesize_in] * (new_x - new_x_int) * (new_y_int + 1 - new_y)
350 + thread_data->data_in[ new_x_int * 3 + rgb_index + (new_y_int + 1) * thread_data->linesize_in] * (new_x_int + 1 - new_x) * (new_y - new_y_int)
351 + thread_data->data_in[(new_x_int + 1) * 3 + rgb_index + (new_y_int + 1) * thread_data->linesize_in] * (new_x - new_x_int) * (new_y - new_y_int);
352 }
353 break;
354 case LANCZOS:
355 interpolated = 0.0f;
356 norm = 0.0f;
357 new_x = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2];
358 new_x_int = new_x;
359 new_y = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1];
360 new_y_int = new_y;
361 for (j = 0; j < 4; ++j)
362 for (i = 0; i < 4; ++i) {
363 if (new_x_int + i - 2 < 0 || new_x_int + i - 2 >= thread_data->width || new_y_int + j - 2 < 0 || new_y_int + j - 2 >= thread_data->height)
364 continue;
365 d = square(new_x - (new_x_int + i - 2)) * square(new_y - (new_y_int + j - 2));
366 if (d >= 4.0f)
367 continue;
368 d = thread_data->interpolation[(int)(d * LANCZOS_RESOLUTION)];
369 norm += d;
370 interpolated += thread_data->data_in[(new_x_int + i - 2) * 3 + rgb_index + (new_y_int + j - 2) * thread_data->linesize_in] * d;
371 }
372 if (norm == 0.0f) {
373 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
374 } else {
375 interpolated /= norm;
376 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = interpolated < 0.0f ? 0.0f : interpolated > 255.0f ? 255.0f : interpolated;
377 }
378 break;
379 }
380 } else if (thread_data->mode & GEOMETRY_DISTORTION) {
381 // geometry distortion correction was applied, correct distortion
382 switch(thread_data->interpolation_type) {
383 case NEAREST:
384 new_x_int = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2] + 0.5f;
385 new_y_int = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2 + 1] + 0.5f;
386 if (new_x_int < 0 || new_x_int >= thread_data->width || new_y_int < 0 || new_y_int >= thread_data->height) {
387 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
388 } else {
389 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = thread_data->data_in[new_x_int * 3 + rgb_index + new_y_int * thread_data->linesize_in];
390 }
391 break;
392 case LINEAR:
393 interpolated = 0.0f;
394 new_x = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2];
395 new_x_int = new_x;
396 new_y = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2 + 1];
397 new_y_int = new_y;
398 if (new_x_int < 0 || new_x_int + 1 >= thread_data->width || new_y_int < 0 || new_y_int + 1 >= thread_data->height) {
399 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
400 } else {
401 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] =
402 thread_data->data_in[ new_x_int * 3 + rgb_index + new_y_int * thread_data->linesize_in] * (new_x_int + 1 - new_x) * (new_y_int + 1 - new_y)
403 + thread_data->data_in[(new_x_int + 1) * 3 + rgb_index + new_y_int * thread_data->linesize_in] * (new_x - new_x_int) * (new_y_int + 1 - new_y)
404 + thread_data->data_in[ new_x_int * 3 + rgb_index + (new_y_int + 1) * thread_data->linesize_in] * (new_x_int + 1 - new_x) * (new_y - new_y_int)
405 + thread_data->data_in[(new_x_int + 1) * 3 + rgb_index + (new_y_int + 1) * thread_data->linesize_in] * (new_x - new_x_int) * (new_y - new_y_int);
406 }
407 break;
408 case LANCZOS:
409 interpolated = 0.0f;
410 norm = 0.0f;
411 new_x = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2];
412 new_x_int = new_x;
413 new_y = thread_data->distortion_coords[x * 2 + 1 + y * thread_data->width * 2];
414 new_y_int = new_y;
415 for (j = 0; j < 4; ++j)
416 for (i = 0; i < 4; ++i) {
417 if (new_x_int + i - 2 < 0 || new_x_int + i - 2 >= thread_data->width || new_y_int + j - 2 < 0 || new_y_int + j - 2 >= thread_data->height)
418 continue;
419 d = square(new_x - (new_x_int + i - 2)) * square(new_y - (new_y_int + j - 2));
420 if (d >= 4.0f)
421 continue;
422 d = thread_data->interpolation[(int)(d * LANCZOS_RESOLUTION)];
423 norm += d;
424 interpolated += thread_data->data_in[(new_x_int + i - 2) * 3 + rgb_index + (new_y_int + j - 2) * thread_data->linesize_in] * d;
425 }
426 if (norm == 0.0f) {
427 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
428 } else {
429 interpolated /= norm;
430 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = interpolated < 0.0f ? 0.0f : interpolated > 255.0f ? 255.0f : interpolated;
431 }
432 break;
433 }
434 } else {
435 // no distortion correction was applied
436 thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = thread_data->data_in[x * 3 + rgb_index + y * thread_data->linesize_in];
437 }
438 }
439
440 return 0;
441 }
442
filter_frame(AVFilterLink * inlink,AVFrame * in)443 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
444 {
445 AVFilterContext *ctx = inlink->dst;
446 LensfunContext *lensfun = ctx->priv;
447 AVFilterLink *outlink = ctx->outputs[0];
448 AVFrame *out;
449 VignettingThreadData vignetting_thread_data;
450 DistortionCorrectionThreadData distortion_correction_thread_data;
451
452 if (lensfun->mode & VIGNETTING) {
453 av_frame_make_writable(in);
454
455 vignetting_thread_data = (VignettingThreadData) {
456 .width = inlink->w,
457 .height = inlink->h,
458 .data_in = in->data[0],
459 .linesize_in = in->linesize[0],
460 .pixel_composition = LF_CR_3(RED, GREEN, BLUE),
461 .modifier = lensfun->modifier
462 };
463
464 ctx->internal->execute(ctx,
465 vignetting_filter_slice,
466 &vignetting_thread_data,
467 NULL,
468 FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
469 }
470
471 if (lensfun->mode & (GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION)) {
472 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
473 if (!out) {
474 av_frame_free(&in);
475 return AVERROR(ENOMEM);
476 }
477 av_frame_copy_props(out, in);
478
479 distortion_correction_thread_data = (DistortionCorrectionThreadData) {
480 .width = inlink->w,
481 .height = inlink->h,
482 .distortion_coords = lensfun->distortion_coords,
483 .data_in = in->data[0],
484 .data_out = out->data[0],
485 .linesize_in = in->linesize[0],
486 .linesize_out = out->linesize[0],
487 .interpolation = lensfun->interpolation,
488 .mode = lensfun->mode,
489 .interpolation_type = lensfun->interpolation_type
490 };
491
492 ctx->internal->execute(ctx,
493 distortion_correction_filter_slice,
494 &distortion_correction_thread_data,
495 NULL,
496 FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
497
498 av_frame_free(&in);
499 return ff_filter_frame(outlink, out);
500 } else {
501 return ff_filter_frame(outlink, in);
502 }
503 }
504
uninit(AVFilterContext * ctx)505 static av_cold void uninit(AVFilterContext *ctx)
506 {
507 LensfunContext *lensfun = ctx->priv;
508
509 if (lensfun->camera)
510 lf_camera_destroy(lensfun->camera);
511 if (lensfun->lens)
512 lf_lens_destroy(lensfun->lens);
513 if (lensfun->modifier)
514 lf_modifier_destroy(lensfun->modifier);
515 av_freep(&lensfun->distortion_coords);
516 av_freep(&lensfun->interpolation);
517 }
518
519 static const AVFilterPad lensfun_inputs[] = {
520 {
521 .name = "default",
522 .type = AVMEDIA_TYPE_VIDEO,
523 .config_props = config_props,
524 .filter_frame = filter_frame,
525 },
526 { NULL }
527 };
528
529 static const AVFilterPad lensfun_outputs[] = {
530 {
531 .name = "default",
532 .type = AVMEDIA_TYPE_VIDEO,
533 },
534 { NULL }
535 };
536
537 AVFilter ff_vf_lensfun = {
538 .name = "lensfun",
539 .description = NULL_IF_CONFIG_SMALL("Apply correction to an image based on info derived from the lensfun database."),
540 .priv_size = sizeof(LensfunContext),
541 .init = init,
542 .uninit = uninit,
543 .query_formats = query_formats,
544 .inputs = lensfun_inputs,
545 .outputs = lensfun_outputs,
546 .priv_class = &lensfun_class,
547 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
548 };
549