mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-07 11:13:41 +02:00
549 lines
26 KiB
C
549 lines
26 KiB
C
|
/*
|
||
|
|
* Copyright (C) 2007 by Andrew Zabolotny (author of lensfun, from which this filter derives from)
|
||
|
|
* Copyright (C) 2018 Stephen Seo
|
||
|
|
*
|
||
|
|
* This file is part of FFmpeg.
|
||
|
|
*
|
||
|
|
* This program is free software: you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU General Public License as published by
|
||
|
|
* the Free Software Foundation, either version 3 of the License, or
|
||
|
|
* (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This program is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU General Public License
|
||
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @file
|
||
|
|
* Lensfun filter, applies lens correction with parameters from the lensfun database
|
||
|
|
*
|
||
|
|
* @see https://lensfun.sourceforge.net/
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <float.h>
|
||
|
|
#include <math.h>
|
||
|
|
|
||
|
|
#include "libavutil/avassert.h"
|
||
|
|
#include "libavutil/imgutils.h"
|
||
|
|
#include "libavutil/opt.h"
|
||
|
|
#include "libswscale/swscale.h"
|
||
|
|
#include "avfilter.h"
|
||
|
|
#include "formats.h"
|
||
|
|
#include "internal.h"
|
||
|
|
#include "video.h"
|
||
|
|
|
||
|
|
#include <lensfun.h>
|
||
|
|
|
||
|
|
#define LANCZOS_RESOLUTION 256
|
||
|
|
|
||
|
|
enum Mode {
|
||
|
|
VIGNETTING = 0x1,
|
||
|
|
GEOMETRY_DISTORTION = 0x2,
|
||
|
|
SUBPIXEL_DISTORTION = 0x4
|
||
|
|
};
|
||
|
|
|
||
|
|
enum InterpolationType {
|
||
|
|
NEAREST,
|
||
|
|
LINEAR,
|
||
|
|
LANCZOS
|
||
|
|
};
|
||
|
|
|
||
|
|
typedef struct VignettingThreadData {
|
||
|
|
int width, height;
|
||
|
|
uint8_t *data_in;
|
||
|
|
int linesize_in;
|
||
|
|
int pixel_composition;
|
||
|
|
lfModifier *modifier;
|
||
|
|
} VignettingThreadData;
|
||
|
|
|
||
|
|
typedef struct DistortionCorrectionThreadData {
|
||
|
|
int width, height;
|
||
|
|
const float *distortion_coords;
|
||
|
|
const uint8_t *data_in;
|
||
|
|
uint8_t *data_out;
|
||
|
|
int linesize_in, linesize_out;
|
||
|
|
const float *interpolation;
|
||
|
|
int mode;
|
||
|
|
int interpolation_type;
|
||
|
|
} DistortionCorrectionThreadData;
|
||
|
|
|
||
|
|
typedef struct LensfunContext {
|
||
|
|
const AVClass *class;
|
||
|
|
const char *make, *model, *lens_model;
|
||
|
|
int mode;
|
||
|
|
float focal_length;
|
||
|
|
float aperture;
|
||
|
|
float focus_distance;
|
||
|
|
int target_geometry;
|
||
|
|
int reverse;
|
||
|
|
int interpolation_type;
|
||
|
|
|
||
|
|
float *distortion_coords;
|
||
|
|
float *interpolation;
|
||
|
|
|
||
|
|
lfLens *lens;
|
||
|
|
lfCamera *camera;
|
||
|
|
lfModifier *modifier;
|
||
|
|
} LensfunContext;
|
||
|
|
|
||
|
|
#define OFFSET(x) offsetof(LensfunContext, x)
|
||
|
|
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
|
||
|
|
static const AVOption lensfun_options[] = {
|
||
|
|
{ "make", "set camera maker", OFFSET(make), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
|
||
|
|
{ "model", "set camera model", OFFSET(model), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
|
||
|
|
{ "lens_model", "set lens model", OFFSET(lens_model), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
|
||
|
|
{ "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=GEOMETRY_DISTORTION}, 0, VIGNETTING | GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION, FLAGS, "mode" },
|
||
|
|
{ "vignetting", "fix lens vignetting", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "geometry", "correct geometry distortion", 0, AV_OPT_TYPE_CONST, {.i64=GEOMETRY_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "subpixel", "fix chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "vig_geo", "fix lens vignetting and correct geometry distortion", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | GEOMETRY_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "vig_subpixel", "fix lens vignetting and chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "distortion", "correct geometry distortion and chromatic aberrations", 0, AV_OPT_TYPE_CONST, {.i64=GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "all", NULL, 0, AV_OPT_TYPE_CONST, {.i64=VIGNETTING | GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION}, 0, 0, FLAGS, "mode" },
|
||
|
|
{ "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 },
|
||
|
|
{ "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 },
|
||
|
|
{ "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 },
|
||
|
|
{ "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" },
|
||
|
|
{ "rectilinear", "rectilinear lens (default)", 0, AV_OPT_TYPE_CONST, {.i64=LF_RECTILINEAR}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "fisheye", "fisheye lens", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "panoramic", "panoramic (cylindrical)", 0, AV_OPT_TYPE_CONST, {.i64=LF_PANORAMIC}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "equirectangular", "equirectangular", 0, AV_OPT_TYPE_CONST, {.i64=LF_EQUIRECTANGULAR}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "fisheye_orthographic", "orthographic fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_ORTHOGRAPHIC}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "fisheye_stereographic", "stereographic fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_STEREOGRAPHIC}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "fisheye_equisolid", "equisolid fisheye", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_EQUISOLID}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "fisheye_thoby", "fisheye as measured by thoby", 0, AV_OPT_TYPE_CONST, {.i64=LF_FISHEYE_THOBY}, 0, 0, FLAGS, "lens_geometry" },
|
||
|
|
{ "reverse", "Does reverse correction (regular image to lens distorted)", OFFSET(reverse), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
|
||
|
|
{ "interpolation", "Type of interpolation", OFFSET(interpolation_type), AV_OPT_TYPE_INT, {.i64=LINEAR}, 0, LANCZOS, FLAGS, "interpolation" },
|
||
|
|
{ "nearest", NULL, 0, AV_OPT_TYPE_CONST, {.i64=NEAREST}, 0, 0, FLAGS, "interpolation" },
|
||
|
|
{ "linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=LINEAR}, 0, 0, FLAGS, "interpolation" },
|
||
|
|
{ "lanczos", NULL, 0, AV_OPT_TYPE_CONST, {.i64=LANCZOS}, 0, 0, FLAGS, "interpolation" },
|
||
|
|
{ NULL }
|
||
|
|
};
|
||
|
|
|
||
|
|
AVFILTER_DEFINE_CLASS(lensfun);
|
||
|
|
|
||
|
|
static av_cold int init(AVFilterContext *ctx)
|
||
|
|
{
|
||
|
|
LensfunContext *lensfun = ctx->priv;
|
||
|
|
lfDatabase *db;
|
||
|
|
const lfCamera **cameras;
|
||
|
|
const lfLens **lenses;
|
||
|
|
|
||
|
|
if (!lensfun->make) {
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Option \"make\" not specified\n");
|
||
|
|
return AVERROR(EINVAL);
|
||
|
|
} else if (!lensfun->model) {
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Option \"model\" not specified\n");
|
||
|
|
return AVERROR(EINVAL);
|
||
|
|
} else if (!lensfun->lens_model) {
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Option \"lens_model\" not specified\n");
|
||
|
|
return AVERROR(EINVAL);
|
||
|
|
}
|
||
|
|
|
||
|
|
lensfun->lens = lf_lens_new();
|
||
|
|
lensfun->camera = lf_camera_new();
|
||
|
|
|
||
|
|
db = lf_db_new();
|
||
|
|
if (lf_db_load(db) != LF_NO_ERROR) {
|
||
|
|
lf_db_destroy(db);
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Failed to load lensfun database\n");
|
||
|
|
return AVERROR_INVALIDDATA;
|
||
|
|
}
|
||
|
|
|
||
|
|
cameras = lf_db_find_cameras(db, lensfun->make, lensfun->model);
|
||
|
|
if (cameras && *cameras) {
|
||
|
|
lf_camera_copy(lensfun->camera, *cameras);
|
||
|
|
av_log(ctx, AV_LOG_INFO, "Using camera %s\n", lensfun->camera->Model);
|
||
|
|
} else {
|
||
|
|
lf_free(cameras);
|
||
|
|
lf_db_destroy(db);
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Failed to find camera in lensfun database\n");
|
||
|
|
return AVERROR_INVALIDDATA;
|
||
|
|
}
|
||
|
|
lf_free(cameras);
|
||
|
|
|
||
|
|
lenses = lf_db_find_lenses_hd(db, lensfun->camera, NULL, lensfun->lens_model, 0);
|
||
|
|
if (lenses && *lenses) {
|
||
|
|
lf_lens_copy(lensfun->lens, *lenses);
|
||
|
|
av_log(ctx, AV_LOG_INFO, "Using lens %s\n", lensfun->lens->Model);
|
||
|
|
} else {
|
||
|
|
lf_free(lenses);
|
||
|
|
lf_db_destroy(db);
|
||
|
|
av_log(ctx, AV_LOG_FATAL, "Failed to find lens in lensfun database\n");
|
||
|
|
return AVERROR_INVALIDDATA;
|
||
|
|
}
|
||
|
|
lf_free(lenses);
|
||
|
|
|
||
|
|
lf_db_destroy(db);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int query_formats(AVFilterContext *ctx)
|
||
|
|
{
|
||
|
|
// Some of the functions provided by lensfun require pixels in RGB format
|
||
|
|
static const enum AVPixelFormat fmts[] = {AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE};
|
||
|
|
AVFilterFormats *fmts_list = ff_make_format_list(fmts);
|
||
|
|
return ff_set_common_formats(ctx, fmts_list);
|
||
|
|
}
|
||
|
|
|
||
|
|
static float lanczos_kernel(float x)
|
||
|
|
{
|
||
|
|
if (x == 0.0f) {
|
||
|
|
return 1.0f;
|
||
|
|
} else if (x > -2.0f && x < 2.0f) {
|
||
|
|
return (2.0f * sin(M_PI * x) * sin(M_PI / 2.0f * x)) / (M_PI * M_PI * x * x);
|
||
|
|
} else {
|
||
|
|
return 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static int config_props(AVFilterLink *inlink)
|
||
|
|
{
|
||
|
|
AVFilterContext *ctx = inlink->dst;
|
||
|
|
LensfunContext *lensfun = ctx->priv;
|
||
|
|
int index;
|
||
|
|
float a;
|
||
|
|
int lensfun_mode = 0;
|
||
|
|
|
||
|
|
if (!lensfun->modifier) {
|
||
|
|
if (lensfun->camera && lensfun->lens) {
|
||
|
|
lensfun->modifier = lf_modifier_new(lensfun->lens,
|
||
|
|
lensfun->camera->CropFactor,
|
||
|
|
inlink->w,
|
||
|
|
inlink->h);
|
||
|
|
if (lensfun->mode & VIGNETTING)
|
||
|
|
lensfun_mode |= LF_MODIFY_VIGNETTING;
|
||
|
|
if (lensfun->mode & GEOMETRY_DISTORTION)
|
||
|
|
lensfun_mode |= LF_MODIFY_DISTORTION | LF_MODIFY_GEOMETRY | LF_MODIFY_SCALE;
|
||
|
|
if (lensfun->mode & SUBPIXEL_DISTORTION)
|
||
|
|
lensfun_mode |= LF_MODIFY_TCA;
|
||
|
|
lf_modifier_initialize(lensfun->modifier,
|
||
|
|
lensfun->lens,
|
||
|
|
LF_PF_U8,
|
||
|
|
lensfun->focal_length,
|
||
|
|
lensfun->aperture,
|
||
|
|
lensfun->focus_distance,
|
||
|
|
0.0,
|
||
|
|
lensfun->target_geometry,
|
||
|
|
lensfun_mode,
|
||
|
|
lensfun->reverse);
|
||
|
|
} else {
|
||
|
|
// lensfun->camera and lensfun->lens should have been initialized
|
||
|
|
return AVERROR_BUG;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!lensfun->distortion_coords) {
|
||
|
|
if (lensfun->mode & SUBPIXEL_DISTORTION) {
|
||
|
|
lensfun->distortion_coords = av_malloc(sizeof(float) * inlink->w * inlink->h * 2 * 3);
|
||
|
|
if (!lensfun->distortion_coords)
|
||
|
|
return AVERROR(ENOMEM);
|
||
|
|
if (lensfun->mode & GEOMETRY_DISTORTION) {
|
||
|
|
// apply both geometry and subpixel distortion
|
||
|
|
lf_modifier_apply_subpixel_geometry_distortion(lensfun->modifier,
|
||
|
|
0, 0,
|
||
|
|
inlink->w, inlink->h,
|
||
|
|
lensfun->distortion_coords);
|
||
|
|
} else {
|
||
|
|
// apply only subpixel distortion
|
||
|
|
lf_modifier_apply_subpixel_distortion(lensfun->modifier,
|
||
|
|
0, 0,
|
||
|
|
inlink->w, inlink->h,
|
||
|
|
lensfun->distortion_coords);
|
||
|
|
}
|
||
|
|
} else if (lensfun->mode & GEOMETRY_DISTORTION) {
|
||
|
|
lensfun->distortion_coords = av_malloc(sizeof(float) * inlink->w * inlink->h * 2);
|
||
|
|
if (!lensfun->distortion_coords)
|
||
|
|
return AVERROR(ENOMEM);
|
||
|
|
// apply only geometry distortion
|
||
|
|
lf_modifier_apply_geometry_distortion(lensfun->modifier,
|
||
|
|
0, 0,
|
||
|
|
inlink->w, inlink->h,
|
||
|
|
lensfun->distortion_coords);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!lensfun->interpolation)
|
||
|
|
if (lensfun->interpolation_type == LANCZOS) {
|
||
|
|
lensfun->interpolation = av_malloc(sizeof(float) * 4 * LANCZOS_RESOLUTION);
|
||
|
|
if (!lensfun->interpolation)
|
||
|
|
return AVERROR(ENOMEM);
|
||
|
|
for (index = 0; index < 4 * LANCZOS_RESOLUTION; ++index) {
|
||
|
|
if (index == 0) {
|
||
|
|
lensfun->interpolation[index] = 1.0f;
|
||
|
|
} else {
|
||
|
|
a = sqrtf((float)index / LANCZOS_RESOLUTION);
|
||
|
|
lensfun->interpolation[index] = lanczos_kernel(a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int vignetting_filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
|
||
|
|
{
|
||
|
|
const VignettingThreadData *thread_data = arg;
|
||
|
|
const int slice_start = thread_data->height * jobnr / nb_jobs;
|
||
|
|
const int slice_end = thread_data->height * (jobnr + 1) / nb_jobs;
|
||
|
|
|
||
|
|
lf_modifier_apply_color_modification(thread_data->modifier,
|
||
|
|
thread_data->data_in + slice_start * thread_data->linesize_in,
|
||
|
|
0,
|
||
|
|
slice_start,
|
||
|
|
thread_data->width,
|
||
|
|
slice_end - slice_start,
|
||
|
|
thread_data->pixel_composition,
|
||
|
|
thread_data->linesize_in);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static float square(float x)
|
||
|
|
{
|
||
|
|
return x * x;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int distortion_correction_filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
|
||
|
|
{
|
||
|
|
const DistortionCorrectionThreadData *thread_data = arg;
|
||
|
|
const int slice_start = thread_data->height * jobnr / nb_jobs;
|
||
|
|
const int slice_end = thread_data->height * (jobnr + 1) / nb_jobs;
|
||
|
|
|
||
|
|
int x, y, i, j, rgb_index;
|
||
|
|
float interpolated, new_x, new_y, d, norm;
|
||
|
|
int new_x_int, new_y_int;
|
||
|
|
for (y = slice_start; y < slice_end; ++y)
|
||
|
|
for (x = 0; x < thread_data->width; ++x)
|
||
|
|
for (rgb_index = 0; rgb_index < 3; ++rgb_index) {
|
||
|
|
if (thread_data->mode & SUBPIXEL_DISTORTION) {
|
||
|
|
// subpixel (and possibly geometry) distortion correction was applied, correct distortion
|
||
|
|
switch(thread_data->interpolation_type) {
|
||
|
|
case NEAREST:
|
||
|
|
new_x_int = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2] + 0.5f;
|
||
|
|
new_y_int = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1] + 0.5f;
|
||
|
|
if (new_x_int < 0 || new_x_int >= thread_data->width || new_y_int < 0 || new_y_int >= thread_data->height) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
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];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case LINEAR:
|
||
|
|
interpolated = 0.0f;
|
||
|
|
new_x = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2];
|
||
|
|
new_x_int = new_x;
|
||
|
|
new_y = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1];
|
||
|
|
new_y_int = new_y;
|
||
|
|
if (new_x_int < 0 || new_x_int + 1 >= thread_data->width || new_y_int < 0 || new_y_int + 1 >= thread_data->height) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
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] * (new_x_int + 1 - new_x) * (new_y_int + 1 - new_y)
|
||
|
|
+ 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)
|
||
|
|
+ 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)
|
||
|
|
+ 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);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case LANCZOS:
|
||
|
|
interpolated = 0.0f;
|
||
|
|
norm = 0.0f;
|
||
|
|
new_x = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2];
|
||
|
|
new_x_int = new_x;
|
||
|
|
new_y = thread_data->distortion_coords[x * 2 * 3 + y * thread_data->width * 2 * 3 + rgb_index * 2 + 1];
|
||
|
|
new_y_int = new_y;
|
||
|
|
for (j = 0; j < 4; ++j)
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
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)
|
||
|
|
continue;
|
||
|
|
d = square(new_x - (new_x_int + i - 2)) * square(new_y - (new_y_int + j - 2));
|
||
|
|
if (d >= 4.0f)
|
||
|
|
continue;
|
||
|
|
d = thread_data->interpolation[(int)(d * LANCZOS_RESOLUTION)];
|
||
|
|
norm += d;
|
||
|
|
interpolated += thread_data->data_in[(new_x_int + i - 2) * 3 + rgb_index + (new_y_int + j - 2) * thread_data->linesize_in] * d;
|
||
|
|
}
|
||
|
|
if (norm == 0.0f) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
interpolated /= norm;
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = interpolated < 0.0f ? 0.0f : interpolated > 255.0f ? 255.0f : interpolated;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else if (thread_data->mode & GEOMETRY_DISTORTION) {
|
||
|
|
// geometry distortion correction was applied, correct distortion
|
||
|
|
switch(thread_data->interpolation_type) {
|
||
|
|
case NEAREST:
|
||
|
|
new_x_int = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2] + 0.5f;
|
||
|
|
new_y_int = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2 + 1] + 0.5f;
|
||
|
|
if (new_x_int < 0 || new_x_int >= thread_data->width || new_y_int < 0 || new_y_int >= thread_data->height) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
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];
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case LINEAR:
|
||
|
|
interpolated = 0.0f;
|
||
|
|
new_x = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2];
|
||
|
|
new_x_int = new_x;
|
||
|
|
new_y = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2 + 1];
|
||
|
|
new_y_int = new_y;
|
||
|
|
if (new_x_int < 0 || new_x_int + 1 >= thread_data->width || new_y_int < 0 || new_y_int + 1 >= thread_data->height) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
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] * (new_x_int + 1 - new_x) * (new_y_int + 1 - new_y)
|
||
|
|
+ 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)
|
||
|
|
+ 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)
|
||
|
|
+ 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);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case LANCZOS:
|
||
|
|
interpolated = 0.0f;
|
||
|
|
norm = 0.0f;
|
||
|
|
new_x = thread_data->distortion_coords[x * 2 + y * thread_data->width * 2];
|
||
|
|
new_x_int = new_x;
|
||
|
|
new_y = thread_data->distortion_coords[x * 2 + 1 + y * thread_data->width * 2];
|
||
|
|
new_y_int = new_y;
|
||
|
|
for (j = 0; j < 4; ++j)
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
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)
|
||
|
|
continue;
|
||
|
|
d = square(new_x - (new_x_int + i - 2)) * square(new_y - (new_y_int + j - 2));
|
||
|
|
if (d >= 4.0f)
|
||
|
|
continue;
|
||
|
|
d = thread_data->interpolation[(int)(d * LANCZOS_RESOLUTION)];
|
||
|
|
norm += d;
|
||
|
|
interpolated += thread_data->data_in[(new_x_int + i - 2) * 3 + rgb_index + (new_y_int + j - 2) * thread_data->linesize_in] * d;
|
||
|
|
}
|
||
|
|
if (norm == 0.0f) {
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = 0;
|
||
|
|
} else {
|
||
|
|
interpolated /= norm;
|
||
|
|
thread_data->data_out[x * 3 + rgb_index + y * thread_data->linesize_out] = interpolated < 0.0f ? 0.0f : interpolated > 255.0f ? 255.0f : interpolated;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// no distortion correction was applied
|
||
|
|
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];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
|
||
|
|
{
|
||
|
|
AVFilterContext *ctx = inlink->dst;
|
||
|
|
LensfunContext *lensfun = ctx->priv;
|
||
|
|
AVFilterLink *outlink = ctx->outputs[0];
|
||
|
|
AVFrame *out;
|
||
|
|
VignettingThreadData vignetting_thread_data;
|
||
|
|
DistortionCorrectionThreadData distortion_correction_thread_data;
|
||
|
|
|
||
|
|
if (lensfun->mode & VIGNETTING) {
|
||
|
|
av_frame_make_writable(in);
|
||
|
|
|
||
|
|
vignetting_thread_data = (VignettingThreadData) {
|
||
|
|
.width = inlink->w,
|
||
|
|
.height = inlink->h,
|
||
|
|
.data_in = in->data[0],
|
||
|
|
.linesize_in = in->linesize[0],
|
||
|
|
.pixel_composition = LF_CR_3(RED, GREEN, BLUE),
|
||
|
|
.modifier = lensfun->modifier
|
||
|
|
};
|
||
|
|
|
||
|
|
ctx->internal->execute(ctx,
|
||
|
|
vignetting_filter_slice,
|
||
|
|
&vignetting_thread_data,
|
||
|
|
NULL,
|
||
|
|
FFMIN(outlink->h, ctx->graph->nb_threads));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (lensfun->mode & (GEOMETRY_DISTORTION | SUBPIXEL_DISTORTION)) {
|
||
|
|
out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
|
||
|
|
if (!out) {
|
||
|
|
av_frame_free(&in);
|
||
|
|
return AVERROR(ENOMEM);
|
||
|
|
}
|
||
|
|
av_frame_copy_props(out, in);
|
||
|
|
|
||
|
|
distortion_correction_thread_data = (DistortionCorrectionThreadData) {
|
||
|
|
.width = inlink->w,
|
||
|
|
.height = inlink->h,
|
||
|
|
.distortion_coords = lensfun->distortion_coords,
|
||
|
|
.data_in = in->data[0],
|
||
|
|
.data_out = out->data[0],
|
||
|
|
.linesize_in = in->linesize[0],
|
||
|
|
.linesize_out = out->linesize[0],
|
||
|
|
.interpolation = lensfun->interpolation,
|
||
|
|
.mode = lensfun->mode,
|
||
|
|
.interpolation_type = lensfun->interpolation_type
|
||
|
|
};
|
||
|
|
|
||
|
|
ctx->internal->execute(ctx,
|
||
|
|
distortion_correction_filter_slice,
|
||
|
|
&distortion_correction_thread_data,
|
||
|
|
NULL,
|
||
|
|
FFMIN(outlink->h, ctx->graph->nb_threads));
|
||
|
|
|
||
|
|
av_frame_free(&in);
|
||
|
|
return ff_filter_frame(outlink, out);
|
||
|
|
} else {
|
||
|
|
return ff_filter_frame(outlink, in);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static av_cold void uninit(AVFilterContext *ctx)
|
||
|
|
{
|
||
|
|
LensfunContext *lensfun = ctx->priv;
|
||
|
|
|
||
|
|
if (lensfun->camera)
|
||
|
|
lf_camera_destroy(lensfun->camera);
|
||
|
|
if (lensfun->lens)
|
||
|
|
lf_lens_destroy(lensfun->lens);
|
||
|
|
if (lensfun->modifier)
|
||
|
|
lf_modifier_destroy(lensfun->modifier);
|
||
|
|
if (lensfun->distortion_coords)
|
||
|
|
av_free(lensfun->distortion_coords);
|
||
|
|
if (lensfun->interpolation)
|
||
|
|
av_free(lensfun->interpolation);
|
||
|
|
}
|
||
|
|
|
||
|
|
static const AVFilterPad lensfun_inputs[] = {
|
||
|
|
{
|
||
|
|
.name = "default",
|
||
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
||
|
|
.config_props = config_props,
|
||
|
|
.filter_frame = filter_frame,
|
||
|
|
},
|
||
|
|
{ NULL }
|
||
|
|
};
|
||
|
|
|
||
|
|
static const AVFilterPad lensfun_outputs[] = {
|
||
|
|
{
|
||
|
|
.name = "default",
|
||
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
||
|
|
},
|
||
|
|
{ NULL }
|
||
|
|
};
|
||
|
|
|
||
|
|
AVFilter ff_vf_lensfun = {
|
||
|
|
.name = "lensfun",
|
||
|
|
.description = NULL_IF_CONFIG_SMALL("Apply correction to an image based on info derived from the lensfun database."),
|
||
|
|
.priv_size = sizeof(LensfunContext),
|
||
|
|
.init = init,
|
||
|
|
.uninit = uninit,
|
||
|
|
.query_formats = query_formats,
|
||
|
|
.inputs = lensfun_inputs,
|
||
|
|
.outputs = lensfun_outputs,
|
||
|
|
.priv_class = &lensfun_class,
|
||
|
|
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
|
||
|
|
};
|