git.sesse.net Git - ffmpeg/blob - libavfilter/vf_lensfun.c

   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
 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
 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
 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
 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
 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
 309 static float square(float x)
 310 {
 311     return x * x;
 312 }
 313
 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
 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, ctx->graph->nb_threads));
 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, ctx->graph->nb_threads));
 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
 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 };