FFmpeg
vf_tiltandshift.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 Vittorio Giovara
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file vf_tiltandshift.c
23  * Simple time and space inverter.
24  */
25 
26 #include <string.h>
27 
28 #include "libavutil/imgutils.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 
33 #include "avfilter.h"
34 #include "internal.h"
35 #include "video.h"
36 
42 };
43 
44 typedef struct TiltandshiftContext {
45  const AVClass *class;
46 
47  /* set when all input frames have been processed and we have to
48  * empty buffers, pad and then return */
49  int eof_recv;
50 
51  /* live or static sliding */
52  int tilt;
53 
54  /* initial or final actions to perform (pad/hold a frame/black/nothing) */
57 
58  /* columns to hold or pad at the beginning or at the end (respectively) */
59  int hold;
60  int pad;
61 
62  /* buffers for black columns */
63  uint8_t *black_buffers[4];
65 
66  /* list containing all input frames */
67  size_t input_size;
70 
73 
75 {
76  if (s->input == NULL) {
77  s->input = frame;
78  } else {
79  AVFrame *head = s->input;
80  while (head->opaque)
81  head = head->opaque;
82  head->opaque = frame;
83  }
84  s->input_size++;
85  return 0;
86 }
87 
89 {
90  AVFrame *head = s->input;
91  if (head) {
92  s->input = head->opaque;
93  av_frame_free(&head);
94  }
95  s->input_size--;
96 }
97 
98 static const enum AVPixelFormat pix_fmts[] = {
104 };
105 
107 {
108  TiltandshiftContext *s = ctx->priv;
109  while (s->input)
111  av_freep(&s->black_buffers);
112 }
113 
114 static int config_props(AVFilterLink *outlink)
115 {
116  AVFilterContext *ctx = outlink->src;
117  TiltandshiftContext *s = ctx->priv;
118 
119  outlink->w = ctx->inputs[0]->w;
120  outlink->h = ctx->inputs[0]->h;
121  outlink->format = ctx->inputs[0]->format;
122 
123  // when we have to pad black or a frame at the start, skip navigating
124  // the list and use either the frame or black for the requested value
125  if (s->start != TILT_NONE && !s->hold)
126  s->hold = outlink->w;
127 
128  // Init black buffers if we pad with black at the start or at the end.
129  // For the end, we always have to init on NONE and BLACK because we never
130  // know if there are going to be enough input frames to fill an output one.
131  if (s->start == TILT_BLACK || s->end != TILT_FRAME) {
132  int i, j, ret;
133  uint8_t black_data[] = { 0x10, 0x80, 0x80, 0x10 };
135  if (!desc)
136  return AVERROR_BUG;
137 
138  if (outlink->format == AV_PIX_FMT_YUVJ420P ||
139  outlink->format == AV_PIX_FMT_YUVJ422P ||
140  outlink->format == AV_PIX_FMT_YUVJ444P ||
141  outlink->format == AV_PIX_FMT_YUVJ440P ||
142  outlink->color_range == AVCOL_RANGE_JPEG)
143  black_data[0] = black_data[3] = 0;
144 
145  ret = av_image_alloc(s->black_buffers, s->black_linesizes, 1,
146  outlink->h, outlink->format, 1);
147  if (ret < 0)
148  return ret;
149 
150  for (i = 0; i < FFMIN(desc->nb_components, 4); i++)
151  for (j = 0; j < (!i ? outlink->h
152  : -((-outlink->h) >> desc->log2_chroma_h)); j++)
153  memset(s->black_buffers[i] + j * s->black_linesizes[i],
154  black_data[i], 1);
155 
156  av_log(ctx, AV_LOG_VERBOSE, "Padding buffers initialized.\n");
157  }
158 
159  s->desc = av_pix_fmt_desc_get(outlink->format);
160  if (!s->desc)
161  return AVERROR_BUG;
162 
163  return 0;
164 }
165 
166 
167 static void copy_column(AVFilterLink *outlink,
168  uint8_t *dst_data[4], int dst_linesizes[4],
169  const uint8_t *src_data[4], const int src_linesizes[4],
170  int ncol, int tilt)
171 {
172  AVFilterContext *ctx = outlink->src;
173  TiltandshiftContext *s = ctx->priv;
174  uint8_t *dst[4];
175  const uint8_t *src[4];
176 
177  dst[0] = dst_data[0] + ncol;
178  dst[1] = dst_data[1] + (ncol >> s->desc->log2_chroma_h);
179  dst[2] = dst_data[2] + (ncol >> s->desc->log2_chroma_h);
180 
181  if (!tilt)
182  ncol = 0;
183  src[0] = src_data[0] + ncol;
184  src[1] = src_data[1] + (ncol >> s->desc->log2_chroma_h);
185  src[2] = src_data[2] + (ncol >> s->desc->log2_chroma_h);
186 
187  av_image_copy(dst, dst_linesizes, src, src_linesizes, outlink->format, 1, outlink->h);
188 }
189 
190 static int output_frame(AVFilterLink *outlink)
191 {
192  TiltandshiftContext *s = outlink->src->priv;
193  AVFrame *head;
194  int ret;
195 
196  int ncol = 0;
197  AVFrame *dst = ff_get_video_buffer(outlink, outlink->w, outlink->h);
198  if (!dst)
199  return AVERROR(ENOMEM);
200 
201  // in case we have to do any initial black padding
202  if (s->start == TILT_BLACK) {
203  for ( ; ncol < s->hold; ncol++)
204  copy_column(outlink, dst->data, dst->linesize,
205  (const uint8_t **)s->black_buffers, s->black_linesizes,
206  ncol, 0);
207  }
208 
209  head = s->input;
210  // copy a column from each input frame
211  for ( ; ncol < s->input_size; ncol++) {
212  AVFrame *src = head;
213 
214  copy_column(outlink, dst->data, dst->linesize,
215  (const uint8_t **)src->data, src->linesize,
216  ncol, s->tilt);
217 
218  // keep track of the last known frame in case we need it below
219  s->prev = head;
220  // advance to the next frame unless we have to hold it
221  if (s->hold <= ncol)
222  head = head->opaque;
223  }
224 
225  // pad any remaining space with black or last frame
226  if (s->end == TILT_FRAME) {
227  for ( ; ncol < outlink->w; ncol++)
228  copy_column(outlink, dst->data, dst->linesize,
229  (const uint8_t **)s->prev->data,
230  s->prev->linesize, ncol, 1);
231  } else { // TILT_BLACK and TILT_NONE
232  for ( ; ncol < outlink->w; ncol++)
233  copy_column(outlink, dst->data, dst->linesize,
234  (const uint8_t **)s->black_buffers, s->black_linesizes,
235  ncol, 0);
236  }
237 
238  // set correct timestamps and props as long as there is proper input
239  ret = av_frame_copy_props(dst, s->input);
240  if (ret < 0)
241  return ret;
242 
243  // discard frame at the top of the list since it has been fully processed
245  // and it is safe to reduce the hold value (even if unused)
246  s->hold--;
247 
248  // output
249  return ff_filter_frame(outlink, dst);
250 }
251 
252 // This function just polls for new frames and queues them on a list
254 {
255  AVFilterLink *outlink = inlink->dst->outputs[0];
256  AVFilterContext *ctx = outlink->src;
257  TiltandshiftContext *s = inlink->dst->priv;
258 
259  int ret = list_add_frame(s, frame);
260  if (ret < 0) {
261  return ret;
262  }
263 
264  // load up enough frames to fill a frame and keep the queue filled on subsequent
265  // calls, until we receive EOF, and then we either pad or end
266  if (!s->eof_recv && s->input_size < outlink->w - s->pad) {
267  av_log(ctx, AV_LOG_DEBUG, "Not enough frames in the list (%zu/%d), waiting for more.\n", s->input_size, outlink->w - s->pad);
268  return 0;
269  }
270 
271  return output_frame(outlink);
272 }
273 
274 static int request_frame(AVFilterLink *outlink)
275 {
276  AVFilterContext *ctx = outlink->src;
277  TiltandshiftContext *s = ctx->priv;
278  int ret;
279 
280  // signal job finished when list is empty or when padding is either
281  // limited or disabled and eof was received
282  if ((s->input_size <= 0 || s->input_size == outlink->w - s->pad || s->end == TILT_NONE) && s->eof_recv) {
283  return AVERROR_EOF;
284  }
285 
286  ret = ff_request_frame(ctx->inputs[0]);
287  if (ret == AVERROR_EOF) {
288  s->eof_recv = 1;
289  } else if (ret < 0) {
290  return ret;
291  }
292 
293  if (s->eof_recv) {
294  while (s->input_size) {
295  av_log(ctx, AV_LOG_DEBUG, "Emptying buffers (%zu/%d).\n", s->input_size, outlink->w - s->pad);
296  ret = output_frame(outlink);
297  if (ret < 0) {
298  return ret;
299  }
300  }
301  }
302 
303  return 0;
304 }
305 
306 #define OFFSET(x) offsetof(TiltandshiftContext, x)
307 #define V AV_OPT_FLAG_VIDEO_PARAM
308 static const AVOption tiltandshift_options[] = {
309  { "tilt", "Tilt the video horizontally while shifting", OFFSET(tilt), AV_OPT_TYPE_INT,
310  { .i64 = 1 }, 0, 1, .flags = V, .unit = "tilt" },
311 
312  { "start", "Action at the start of input", OFFSET(start), AV_OPT_TYPE_INT,
313  { .i64 = TILT_NONE }, 0, TILT_OPT_MAX, .flags = V, .unit = "start" },
314  { "none", "Start immediately (default)", 0, AV_OPT_TYPE_CONST,
315  { .i64 = TILT_NONE }, INT_MIN, INT_MAX, .flags = V, .unit = "start" },
316  { "frame", "Use the first frames", 0, AV_OPT_TYPE_CONST,
317  { .i64 = TILT_FRAME }, INT_MIN, INT_MAX, .flags = V, .unit = "start" },
318  { "black", "Fill with black", 0, AV_OPT_TYPE_CONST,
319  { .i64 = TILT_BLACK }, INT_MIN, INT_MAX, .flags = V, .unit = "start" },
320 
321  { "end", "Action at the end of input", OFFSET(end), AV_OPT_TYPE_INT,
322  { .i64 = TILT_NONE }, 0, TILT_OPT_MAX, .flags = V, .unit = "end" },
323  { "none", "Do not pad at the end (default)", 0, AV_OPT_TYPE_CONST,
324  { .i64 = TILT_NONE }, INT_MIN, INT_MAX, .flags = V, .unit = "end" },
325  { "frame", "Use the last frame", 0, AV_OPT_TYPE_CONST,
326  { .i64 = TILT_FRAME }, INT_MIN, INT_MAX, .flags = V, .unit = "end" },
327  { "black", "Fill with black", 0, AV_OPT_TYPE_CONST,
328  { .i64 = TILT_BLACK }, INT_MIN, INT_MAX, .flags = V, .unit = "end" },
329 
330  { "hold", "Number of columns to hold at the start of the video", OFFSET(hold), AV_OPT_TYPE_INT,
331  { .i64 = 0 }, 0, INT_MAX, .flags = V, .unit = "hold" },
332  { "pad", "Number of columns to pad at the end of the video", OFFSET(pad), AV_OPT_TYPE_INT,
333  { .i64 = 0 }, 0, INT_MAX, .flags = V, .unit = "pad" },
334 
335  { NULL },
336 };
337 
338 AVFILTER_DEFINE_CLASS(tiltandshift);
339 
341  {
342  .name = "in",
343  .type = AVMEDIA_TYPE_VIDEO,
344  .filter_frame = filter_frame,
345  },
346 };
347 
349  {
350  .name = "out",
351  .type = AVMEDIA_TYPE_VIDEO,
352  .config_props = config_props,
353  .request_frame = request_frame,
354  },
355 };
356 
358  .name = "tiltandshift",
359  .description = NULL_IF_CONFIG_SMALL("Generate a tilt-and-shift'd video."),
360  .priv_size = sizeof(TiltandshiftContext),
361  .priv_class = &tiltandshift_class,
362  .uninit = uninit,
366 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
TILT_NONE
@ TILT_NONE
Definition: vf_tiltandshift.c:38
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
tiltandshift_inputs
static const AVFilterPad tiltandshift_inputs[]
Definition: vf_tiltandshift.c:340
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
TiltandshiftContext
Definition: vf_tiltandshift.c:44
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:523
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
pixdesc.h
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
AVOption
AVOption.
Definition: opt.h:346
V
#define V
Definition: vf_tiltandshift.c:307
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:463
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
list_remove_head
static void list_remove_head(TiltandshiftContext *s)
Definition: vf_tiltandshift.c:88
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_tiltandshift.c:106
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
TILT_BLACK
@ TILT_BLACK
Definition: vf_tiltandshift.c:40
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:422
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
TILT_OPT_MAX
@ TILT_OPT_MAX
Definition: vf_tiltandshift.c:41
av_cold
#define av_cold
Definition: attributes.h:90
OFFSET
#define OFFSET(x)
Definition: vf_tiltandshift.c:306
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
s
#define s(width, name)
Definition: cbs_vp9.c:198
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_tiltandshift.c:253
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_vf_tiltandshift
const AVFilter ff_vf_tiltandshift
Definition: vf_tiltandshift.c:357
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:709
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: vf_tiltandshift.c:274
tiltandshift_outputs
static const AVFilterPad tiltandshift_outputs[]
Definition: vf_tiltandshift.c:348
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_tiltandshift.c:98
av_image_alloc
int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)
Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...
Definition: imgutils.c:218
TiltandshiftContext::tilt
int tilt
Definition: vf_tiltandshift.c:52
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
TiltandshiftContext::start
enum PaddingOption start
Definition: vf_tiltandshift.c:55
TiltandshiftContext::desc
const AVPixFmtDescriptor * desc
Definition: vf_tiltandshift.c:71
TiltandshiftContext::hold
int hold
Definition: vf_tiltandshift.c:59
internal.h
config_props
static int config_props(AVFilterLink *outlink)
Definition: vf_tiltandshift.c:114
TiltandshiftContext::pad
int pad
Definition: vf_tiltandshift.c:60
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
tiltandshift_options
static const AVOption tiltandshift_options[]
Definition: vf_tiltandshift.c:308
TILT_FRAME
@ TILT_FRAME
Definition: vf_tiltandshift.c:39
AVFilter
Filter definition.
Definition: avfilter.h:166
list_add_frame
static int list_add_frame(TiltandshiftContext *s, AVFrame *frame)
Definition: vf_tiltandshift.c:74
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
TiltandshiftContext::prev
AVFrame * prev
Definition: vf_tiltandshift.c:69
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
TiltandshiftContext::end
enum PaddingOption end
Definition: vf_tiltandshift.c:56
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
desc
const char * desc
Definition: libsvtav1.c:75
output_frame
static int output_frame(AVFilterLink *outlink)
Definition: vf_tiltandshift.c:190
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
TiltandshiftContext::input
AVFrame * input
Definition: vf_tiltandshift.c:68
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
PaddingOption
PaddingOption
Definition: vf_tiltandshift.c:37
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:420
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
copy_column
static void copy_column(AVFilterLink *outlink, uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], int ncol, int tilt)
Definition: vf_tiltandshift.c:167
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TiltandshiftContext::black_buffers
uint8_t * black_buffers[4]
Definition: vf_tiltandshift.c:63
TiltandshiftContext::eof_recv
int eof_recv
Definition: vf_tiltandshift.c:49
av_image_copy
void av_image_copy(uint8_t *const dst_data[4], const int dst_linesizes[4], const uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
TiltandshiftContext::input_size
size_t input_size
Definition: vf_tiltandshift.c:67
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(tiltandshift)
TiltandshiftContext::black_linesizes
int black_linesizes[4]
Definition: vf_tiltandshift.c:64