55 #define OFFSET(x) offsetof(LenscorrectionCtx, x) 56 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM 75 #define NEAREST(type, name) \ 76 static int filter##name##_slice(AVFilterContext *ctx, void *arg, int job, \ 77 int nb_jobs, int plane) \ 79 LenscorrectionCtx *rect = ctx->priv; \ 80 ThreadData *td = arg; \ 81 AVFrame *in = td->in; \ 82 AVFrame *out = td->out; \ 84 const int32_t *correction = rect->correction[plane]; \ 85 const int fill_color = rect->fill_color[plane]; \ 86 const int w = rect->planewidth[plane], h = rect->planeheight[plane]; \ 87 const int xcenter = rect->cx * w; \ 88 const int ycenter = rect->cy * h; \ 89 const int start = (h * job ) / nb_jobs; \ 90 const int end = (h * (job+1)) / nb_jobs; \ 91 const int inlinesize = in->linesize[plane] / sizeof(type); \ 92 const int outlinesize = out->linesize[plane] / sizeof(type); \ 93 const type *indata = (const type *)in->data[plane]; \ 94 type *outrow = (type *)out->data[plane] + start * outlinesize; \ 95 for (int i = start; i < end; i++, outrow += outlinesize) { \ 96 const int off_y = i - ycenter; \ 98 for (int j = 0; j < w; j++) { \ 99 const int off_x = j - xcenter; \ 100 const int64_t radius_mult = correction[j + i*w]; \ 101 const int x = xcenter + ((radius_mult * off_x + (1<<23))>>24); \ 102 const int y = ycenter + ((radius_mult * off_y + (1<<23))>>24); \ 103 const char isvalid = x >= 0 && x < w && y >= 0 && y < h; \ 104 *out++ = isvalid ? indata[y * inlinesize + x] : fill_color; \ 114 #define BILINEAR(type, name) \ 115 static int filter##name##_slice_bilinear(AVFilterContext *ctx, void *arg, \ 116 int job, int nb_jobs, int plane) \ 118 LenscorrectionCtx *rect = ctx->priv; \ 119 ThreadData *td = arg; \ 120 AVFrame *in = td->in; \ 121 AVFrame *out = td->out; \ 123 const int32_t *correction = rect->correction[plane]; \ 124 const int fill_color = rect->fill_color[plane]; \ 125 const int depth = rect->depth; \ 126 const uint64_t max = (1 << 24) - 1; \ 127 const uint64_t add = (1 << 23); \ 128 const int w = rect->planewidth[plane], h = rect->planeheight[plane]; \ 129 const int xcenter = rect->cx * w; \ 130 const int ycenter = rect->cy * h; \ 131 const int start = (h * job ) / nb_jobs; \ 132 const int end = (h * (job+1)) / nb_jobs; \ 133 const int inlinesize = in->linesize[plane] / sizeof(type); \ 134 const int outlinesize = out->linesize[plane] / sizeof(type); \ 135 const type *indata = (const type *)in->data[plane]; \ 136 type *outrow = (type *)out->data[plane] + start * outlinesize; \ 138 for (int i = start; i < end; i++, outrow += outlinesize) { \ 139 const int off_y = i - ycenter; \ 140 type *out = outrow; \ 142 for (int j = 0; j < w; j++) { \ 143 const int off_x = j - xcenter; \ 144 const int64_t radius_mult = correction[j + i*w]; \ 145 const int x = xcenter + ((radius_mult * off_x + (1<<23)) >> 24); \ 146 const int y = ycenter + ((radius_mult * off_y + (1<<23)) >> 24); \ 147 const char isvalid = x >= 0 && x <= w - 1 && y >= 0 && y <= h - 1; \ 150 const int nx = FFMIN(x + 1, w - 1); \ 151 const int ny = FFMIN(y + 1, h - 1); \ 152 const uint64_t du = off_x >= 0 ? (radius_mult * off_x + add) & max : max - ((radius_mult * -off_x + add) & max); \ 153 const uint64_t dv = off_y >= 0 ? (radius_mult * off_y + add) & max : max - ((radius_mult * -off_y + add) & max); \ 154 const uint64_t p0 = indata[ y * inlinesize + x]; \ 155 const uint64_t p1 = indata[ y * inlinesize + nx]; \ 156 const uint64_t p2 = indata[ny * inlinesize + x]; \ 157 const uint64_t p3 = indata[ny * inlinesize + nx]; \ 160 sum += (max - du) * (max - dv) * p0; \ 161 sum += ( du) * (max - dv) * p1; \ 162 sum += (max - du) * ( dv) * p2; \ 163 sum += ( du) * ( dv) * p3; \ 165 out[j] = av_clip_uintp2_c((sum + (1ULL << 47)) >> 48, depth); \ 167 out[j] = fill_color; \ 227 int xcenter = rect->
cx *
w;
228 int ycenter = rect->
cy *
h;
229 int k1 = rect->
k1 * (1<<24);
230 int k2 = rect->
k2 * (1<<24);
231 const int64_t r2inv = (4LL<<60) / (w * w + h * h);
233 for (
int j = 0; j <
h; j++) {
234 const int off_y = j - ycenter;
235 const int off_y2 = off_y * off_y;
236 for (
int i = 0;
i <
w;
i++) {
237 const int off_x =
i - xcenter;
238 const int64_t r2 = ((off_x * off_x + off_y2) * r2inv + (1LL<<31)) >> 32;
239 const int64_t r4 = (r2 * r2 + (1<<27)) >> 28;
240 const int radius_mult = (r2 * k1 + r4 * k2 + (1LL<<27) + (1LL<<52))>>28;
258 factor = 1 << (rect->
depth - 8);
266 rect->
filter_slice = rect->
depth <= 8 ? filter8_slice_bilinear : filter16_slice_bilinear;
280 for (
int plane = 0; plane < rect->
nb_planes; plane++) {
299 for (
int plane = 0; plane < rect->
nb_planes; plane++)
361 .
name =
"lenscorrection",
365 .
inputs = lenscorrection_inputs,
366 .
outputs = lenscorrection_outputs,
367 .priv_class = &lenscorrection_class,
#define RGB_TO_Y_BT709(r, g, b)
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUVA422P9
static const AVFilterPad lenscorrection_inputs[]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Main libavfilter public API header.
int h
agreed upon image height
#define AV_PIX_FMT_GBRP10
#define RGB_TO_V_BT709(r1, g1, b1, max)
#define RGB_TO_U_BT709(r1, g1, b1, max)
#define AV_PIX_FMT_YUV420P12
#define FF_ARRAY_ELEMS(a)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
#define AV_PIX_FMT_GRAY10
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
const char * name
Pad name.
#define AV_PIX_FMT_GRAY12
AVFilterLink ** inputs
array of pointers to input links
static int process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
static int config_output(AVFilterLink *outlink)
static av_cold void uninit(AVFilterContext *ctx)
#define AV_PIX_FMT_YUVA420P9
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUVA420P16
A filter pad used for either input or output.
A link between two filters.
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Various defines for YUV<->RGB conversion.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
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...
void * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_YUV444P10
int(* filter_slice)(AVFilterContext *ctx, void *arg, int job, int nb_jobs, int plane)
#define AV_PIX_FMT_GBRAP16
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
#define AV_PIX_FMT_YUV422P9
#define BILINEAR(type, name)
#define AV_PIX_FMT_GBRP16
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
#define AV_PIX_FMT_GRAY16
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_PIX_FMT_YUVA444P12
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_GBRP14
static const AVFilterPad outputs[]
int format
agreed upon media format
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P14
Used for passing data between threads.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_PIX_FMT_GRAY14
static const AVOption lenscorrection_options[]
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 inputs
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
static int query_formats(AVFilterContext *ctx)
Describe the class of an AVClass context structure.
static void calc_correction(AVFilterContext *ctx, int plane)
static const int factor[16]
const char * name
Filter name.
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV420P9
AVFilter ff_vf_lenscorrection
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_GBRP12
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar GBRA 4:4:4:4 32bpp
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
avfilter_execute_func * execute
AVFILTER_DEFINE_CLASS(lenscorrection)
AVFilterContext * dst
dest filter
#define NEAREST(type, name)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
#define av_malloc_array(a, b)
static const AVFilterPad lenscorrection_outputs[]
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
int depth
Number of bits in the component.
AVPixelFormat
Pixel format.
#define AV_PIX_FMT_YUV422P16
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_PIX_FMT_YUVA422P12
#define AV_CEIL_RSHIFT(a, b)