FFmpeg: libavfilter/vf_rotate.c Source File

FFmpeg
vf_rotate.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Stefano Sabatini
3  * Copyright (c) 2008 Vitor Sessak
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg 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 GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * rotation filter, partially based on the tests/rotozoom.c program
25 */
26 
27 #include "libavutil/avstring.h"
28 #include "libavutil/eval.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/parseutils.h"
32 #include "libavutil/pixdesc.h"
33 
34 #include "avfilter.h"
35 #include "drawutils.h"
36 #include "internal.h"
37 #include "video.h"
38 
39 #include <float.h>
40 
41  static const char * const var_names[] = {
42  "in_w" , "iw", ///< width of the input video
43  "in_h" , "ih", ///< height of the input video
44  "out_w", "ow", ///< width of the input video
45  "out_h", "oh", ///< height of the input video
46  "hsub", "vsub",
47  "n", ///< number of frame
48  "t", ///< timestamp expressed in seconds
49  NULL
50 };
51 
52  enum var_name {
53   VAR_IN_W , VAR_IW,
54   VAR_IN_H , VAR_IH,
55   VAR_OUT_W, VAR_OW,
56   VAR_OUT_H, VAR_OH,
57   VAR_HSUB, VAR_VSUB,
58   VAR_N,
59   VAR_T,
60   VAR_VARS_NB
61 };
62 
63  typedef struct RotContext {
64   const AVClass *class;
65   double angle;
66   char *angle_expr_str; ///< expression for the angle
67   AVExpr *angle_expr; ///< parsed expression for the angle
68   char *outw_expr_str, *outh_expr_str;
69   int outh, outw;
70   uint8_t fillcolor[4]; ///< color expressed either in YUVA or RGBA colorspace for the padding area
71   char *fillcolor_str;
72   int fillcolor_enable;
73   int hsub, vsub;
74   int nb_planes;
75   int use_bilinear;
76   float sinx, cosx;
77   double var_values[VAR_VARS_NB];
78   FFDrawContext draw;
79   FFDrawColor color;
80   uint8_t *(*interpolate_bilinear)(uint8_t *dst_color,
81  const uint8_t *src, int src_linesize, int src_linestep,
82  int x, int y, int max_x, int max_y);
83 } RotContext;
84 
85 typedef struct ThreadData {
86  AVFrame *in, *out;
87   int inw, inh;
88   int outw, outh;
89  int plane;
90   int xi, yi;
91   int xprime, yprime;
92   int c, s;
93 } ThreadData;
94 
95  #define OFFSET(x) offsetof(RotContext, x)
96  #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
97  #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
98 
99  static const AVOption rotate_options[] = {
100  { "angle", "set angle (in radians)", OFFSET(angle_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, .flags=TFLAGS },
101  { "a", "set angle (in radians)", OFFSET(angle_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, .flags=TFLAGS },
102  { "out_w", "set output width expression", OFFSET(outw_expr_str), AV_OPT_TYPE_STRING, {.str="iw"}, 0, 0, .flags=FLAGS },
103  { "ow", "set output width expression", OFFSET(outw_expr_str), AV_OPT_TYPE_STRING, {.str="iw"}, 0, 0, .flags=FLAGS },
104  { "out_h", "set output height expression", OFFSET(outh_expr_str), AV_OPT_TYPE_STRING, {.str="ih"}, 0, 0, .flags=FLAGS },
105  { "oh", "set output height expression", OFFSET(outh_expr_str), AV_OPT_TYPE_STRING, {.str="ih"}, 0, 0, .flags=FLAGS },
106  { "fillcolor", "set background fill color", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str="black"}, 0, 0, .flags=FLAGS },
107  { "c", "set background fill color", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str="black"}, 0, 0, .flags=FLAGS },
108  { "bilinear", "use bilinear interpolation", OFFSET(use_bilinear), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, .flags=FLAGS },
109  { NULL }
110 };
111 
112 AVFILTER_DEFINE_CLASS(rotate);
113 
114  static av_cold int init(AVFilterContext *ctx)
115 {
116  RotContext *rot = ctx->priv;
117 
118  if (!strcmp(rot->fillcolor_str, "none"))
119  rot->fillcolor_enable = 0;
120  else if (av_parse_color(rot->fillcolor, rot->fillcolor_str, -1, ctx) >= 0)
121  rot->fillcolor_enable = 1;
122  else
123  return AVERROR(EINVAL);
124  return 0;
125 }
126 
127  static av_cold void uninit(AVFilterContext *ctx)
128 {
129  RotContext *rot = ctx->priv;
130 
131  av_expr_free(rot->angle_expr);
132  rot->angle_expr = NULL;
133 }
134 
135  static const enum AVPixelFormat pix_fmts[] = {
136  AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
137  AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA,
138  AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
139  AV_PIX_FMT_0RGB, AV_PIX_FMT_RGB0,
140  AV_PIX_FMT_0BGR, AV_PIX_FMT_BGR0,
141  AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
142  AV_PIX_FMT_GRAY8,
143  AV_PIX_FMT_YUV410P,
144  AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
145  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
146  AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA420P,
147  AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUVA420P10LE,
148  AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUVA444P10LE,
149  AV_PIX_FMT_YUV420P12LE,
150  AV_PIX_FMT_YUV444P12LE,
151  AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUVA444P16LE,
152  AV_PIX_FMT_YUV420P16LE, AV_PIX_FMT_YUVA420P16LE,
153  AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUVA444P9LE,
154  AV_PIX_FMT_YUV420P9LE, AV_PIX_FMT_YUVA420P9LE,
155  AV_PIX_FMT_NONE
156 };
157 
158  static double get_rotated_w(void *opaque, double angle)
159 {
160  RotContext *rot = opaque;
161  double inw = rot->var_values[VAR_IN_W];
162  double inh = rot->var_values[VAR_IN_H];
163  float sinx = sin(angle);
164  float cosx = cos(angle);
165 
166  return FFMAX(0, inh * sinx) + FFMAX(0, -inw * cosx) +
167  FFMAX(0, inw * cosx) + FFMAX(0, -inh * sinx);
168 }
169 
170  static double get_rotated_h(void *opaque, double angle)
171 {
172  RotContext *rot = opaque;
173  double inw = rot->var_values[VAR_IN_W];
174  double inh = rot->var_values[VAR_IN_H];
175  float sinx = sin(angle);
176  float cosx = cos(angle);
177 
178  return FFMAX(0, -inh * cosx) + FFMAX(0, -inw * sinx) +
179  FFMAX(0, inh * cosx) + FFMAX(0, inw * sinx);
180 }
181 
182  static double (* const func1[])(void *, double) = {
183  get_rotated_w,
184  get_rotated_h,
185  NULL
186 };
187 
188  static const char * const func1_names[] = {
189  "rotw",
190  "roth",
191  NULL
192 };
193 
194  #define FIXP (1<<16)
195  #define FIXP2 (1<<20)
196  #define INT_PI 3294199 //(M_PI * FIXP2)
197 
198 /**
199  * Compute the sin of a using integer values.
200  * Input is scaled by FIXP2 and output values are scaled by FIXP.
201  */
202  static int64_t int_sin(int64_t a)
203 {
204  int64_t a2, res = 0;
205  int i;
206  if (a < 0) a = INT_PI-a; // 0..inf
207  a %= 2 * INT_PI; // 0..2PI
208 
209  if (a >= INT_PI*3/2) a -= 2*INT_PI; // -PI/2 .. 3PI/2
210  if (a >= INT_PI/2 ) a = INT_PI - a; // -PI/2 .. PI/2
211 
212  /* compute sin using Taylor series approximated to the fifth term */
213  a2 = (a*a)/(FIXP2);
214  for (i = 2; i < 11; i += 2) {
215  res += a;
216  a = -a*a2 / (FIXP2*i*(i+1));
217  }
218  return (res + 8)>>4;
219 }
220 
221 /**
222  * Interpolate the color in src at position x and y using bilinear
223  * interpolation.
224  */
225  static uint8_t *interpolate_bilinear8(uint8_t *dst_color,
226  const uint8_t *src, int src_linesize, int src_linestep,
227  int x, int y, int max_x, int max_y)
228 {
229  int int_x = av_clip(x>>16, 0, max_x);
230  int int_y = av_clip(y>>16, 0, max_y);
231  int frac_x = x&0xFFFF;
232  int frac_y = y&0xFFFF;
233  int i;
234  int int_x1 = FFMIN(int_x+1, max_x);
235  int int_y1 = FFMIN(int_y+1, max_y);
236 
237  for (i = 0; i < src_linestep; i++) {
238  int s00 = src[src_linestep * int_x + i + src_linesize * int_y ];
239  int s01 = src[src_linestep * int_x1 + i + src_linesize * int_y ];
240  int s10 = src[src_linestep * int_x + i + src_linesize * int_y1];
241  int s11 = src[src_linestep * int_x1 + i + src_linesize * int_y1];
242  int s0 = (((1<<16) - frac_x)*s00 + frac_x*s01);
243  int s1 = (((1<<16) - frac_x)*s10 + frac_x*s11);
244 
245  dst_color[i] = ((int64_t)((1<<16) - frac_y)*s0 + (int64_t)frac_y*s1) >> 32;
246  }
247 
248  return dst_color;
249 }
250 
251 /**
252  * Interpolate the color in src at position x and y using bilinear
253  * interpolation.
254  */
255  static uint8_t *interpolate_bilinear16(uint8_t *dst_color,
256  const uint8_t *src, int src_linesize, int src_linestep,
257  int x, int y, int max_x, int max_y)
258 {
259  int int_x = av_clip(x>>16, 0, max_x);
260  int int_y = av_clip(y>>16, 0, max_y);
261  int64_t frac_x = x&0xFFFF;
262  int64_t frac_y = y&0xFFFF;
263  int i;
264  int int_x1 = FFMIN(int_x+1, max_x);
265  int int_y1 = FFMIN(int_y+1, max_y);
266 
267  for (i = 0; i < src_linestep; i+=2) {
268  int s00 = AV_RL16(&src[src_linestep * int_x + i + src_linesize * int_y ]);
269  int s01 = AV_RL16(&src[src_linestep * int_x1 + i + src_linesize * int_y ]);
270  int s10 = AV_RL16(&src[src_linestep * int_x + i + src_linesize * int_y1]);
271  int s11 = AV_RL16(&src[src_linestep * int_x1 + i + src_linesize * int_y1]);
272  int64_t s0 = (((1<<16) - frac_x)*s00 + frac_x*s01);
273  int64_t s1 = (((1<<16) - frac_x)*s10 + frac_x*s11);
274 
275  AV_WL16(&dst_color[i], (((1<<16) - frac_y)*s0 + frac_y*s1) >> 32);
276  }
277 
278  return dst_color;
279 }
280 
281  static int config_props(AVFilterLink *outlink)
282 {
283  AVFilterContext *ctx = outlink->src;
284  RotContext *rot = ctx->priv;
285  AVFilterLink *inlink = ctx->inputs[0];
286  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(inlink->format);
287  int ret;
288  double res;
289  char *expr;
290 
291  ff_draw_init(&rot->draw, inlink->format, 0);
292  ff_draw_color(&rot->draw, &rot->color, rot->fillcolor);
293 
294  rot->hsub = pixdesc->log2_chroma_w;
295  rot->vsub = pixdesc->log2_chroma_h;
296 
297  if (pixdesc->comp[0].depth == 8)
298  rot->interpolate_bilinear = interpolate_bilinear8;
299  else
300  rot->interpolate_bilinear = interpolate_bilinear16;
301 
302  rot->var_values[VAR_IN_W] = rot->var_values[VAR_IW] = inlink->w;
303  rot->var_values[VAR_IN_H] = rot->var_values[VAR_IH] = inlink->h;
304  rot->var_values[VAR_HSUB] = 1<<rot->hsub;
305  rot->var_values[VAR_VSUB] = 1<<rot->vsub;
306  rot->var_values[VAR_N] = NAN;
307  rot->var_values[VAR_T] = NAN;
308  rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = NAN;
309  rot->var_values[VAR_OUT_H] = rot->var_values[VAR_OH] = NAN;
310 
311  av_expr_free(rot->angle_expr);
312  rot->angle_expr = NULL;
313  if ((ret = av_expr_parse(&rot->angle_expr, expr = rot->angle_expr_str, var_names,
314  func1_names, func1, NULL, NULL, 0, ctx)) < 0) {
315  av_log(ctx, AV_LOG_ERROR,
316  "Error occurred parsing angle expression '%s'\n", rot->angle_expr_str);
317  return ret;
318  }
319 
320 #define SET_SIZE_EXPR(name, opt_name) do { \
321  ret = av_expr_parse_and_eval(&res, expr = rot->name##_expr_str, \
322  var_names, rot->var_values, \
323  func1_names, func1, NULL, NULL, rot, 0, ctx); \
324  if (ret < 0 || isnan(res) || isinf(res) || res <= 0) { \
325  av_log(ctx, AV_LOG_ERROR, \
326  "Error parsing or evaluating expression for option %s: " \
327  "invalid expression '%s' or non-positive or indefinite value %f\n", \
328  opt_name, expr, res); \
329  return ret; \
330  } \
331 } while (0)
332 
333  /* evaluate width and height */
334  av_expr_parse_and_eval(&res, expr = rot->outw_expr_str, var_names, rot->var_values,
335  func1_names, func1, NULL, NULL, rot, 0, ctx);
336  rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = res;
337  rot->outw = res + 0.5;
338  SET_SIZE_EXPR(outh, "out_h");
339  rot->var_values[VAR_OUT_H] = rot->var_values[VAR_OH] = res;
340  rot->outh = res + 0.5;
341 
342  /* evaluate the width again, as it may depend on the evaluated output height */
343  SET_SIZE_EXPR(outw, "out_w");
344  rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = res;
345  rot->outw = res + 0.5;
346 
347  /* compute number of planes */
348  rot->nb_planes = av_pix_fmt_count_planes(inlink->format);
349  outlink->w = rot->outw;
350  outlink->h = rot->outh;
351  return 0;
352 }
353 
354  static av_always_inline void copy_elem(uint8_t *pout, const uint8_t *pin, int elem_size)
355 {
356  int v;
357  switch (elem_size) {
358  case 1:
359  *pout = *pin;
360  break;
361  case 2:
362  *((uint16_t *)pout) = *((uint16_t *)pin);
363  break;
364  case 3:
365  v = AV_RB24(pin);
366  AV_WB24(pout, v);
367  break;
368  case 4:
369  *((uint32_t *)pout) = *((uint32_t *)pin);
370  break;
371  default:
372  memcpy(pout, pin, elem_size);
373  break;
374  }
375 }
376 
377  static av_always_inline void simple_rotate_internal(uint8_t *dst, const uint8_t *src, int src_linesize, int angle, int elem_size, int len)
378 {
379  int i;
380  switch(angle) {
381  case 0:
382  memcpy(dst, src, elem_size * len);
383  break;
384  case 1:
385  for (i = 0; i<len; i++)
386  copy_elem(dst + i*elem_size, src + (len-i-1)*src_linesize, elem_size);
387  break;
388  case 2:
389  for (i = 0; i<len; i++)
390  copy_elem(dst + i*elem_size, src + (len-i-1)*elem_size, elem_size);
391  break;
392  case 3:
393  for (i = 0; i<len; i++)
394  copy_elem(dst + i*elem_size, src + i*src_linesize, elem_size);
395  break;
396  }
397 }
398 
399  static av_always_inline void simple_rotate(uint8_t *dst, const uint8_t *src, int src_linesize, int angle, int elem_size, int len)
400 {
401  switch(elem_size) {
402  case 1 : simple_rotate_internal(dst, src, src_linesize, angle, 1, len); break;
403  case 2 : simple_rotate_internal(dst, src, src_linesize, angle, 2, len); break;
404  case 3 : simple_rotate_internal(dst, src, src_linesize, angle, 3, len); break;
405  case 4 : simple_rotate_internal(dst, src, src_linesize, angle, 4, len); break;
406  default: simple_rotate_internal(dst, src, src_linesize, angle, elem_size, len); break;
407  }
408 }
409 
410  static int filter_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
411 {
412  ThreadData *td = arg;
413  AVFrame *in = td->in;
414  AVFrame *out = td->out;
415  RotContext *rot = ctx->priv;
416  const int outw = td->outw, outh = td->outh;
417  const int inw = td->inw, inh = td->inh;
418  const int plane = td->plane;
419  const int xi = td->xi, yi = td->yi;
420  const int c = td->c, s = td->s;
421  const int start = (outh * job ) / nb_jobs;
422  const int end = (outh * (job+1)) / nb_jobs;
423  int xprime = td->xprime + start * s;
424  int yprime = td->yprime + start * c;
425  int i, j, x, y;
426 
427  for (j = start; j < end; j++) {
428  x = xprime + xi + FIXP*(inw-1)/2;
429  y = yprime + yi + FIXP*(inh-1)/2;
430 
431  if (fabs(rot->angle - 0) < FLT_EPSILON && outw == inw && outh == inh) {
432  simple_rotate(out->data[plane] + j * out->linesize[plane],
433  in->data[plane] + j * in->linesize[plane],
434  in->linesize[plane], 0, rot->draw.pixelstep[plane], outw);
435  } else if (fabs(rot->angle - M_PI/2) < FLT_EPSILON && outw == inh && outh == inw) {
436  simple_rotate(out->data[plane] + j * out->linesize[plane],
437  in->data[plane] + j * rot->draw.pixelstep[plane],
438  in->linesize[plane], 1, rot->draw.pixelstep[plane], outw);
439  } else if (fabs(rot->angle - M_PI) < FLT_EPSILON && outw == inw && outh == inh) {
440  simple_rotate(out->data[plane] + j * out->linesize[plane],
441  in->data[plane] + (outh-j-1) * in->linesize[plane],
442  in->linesize[plane], 2, rot->draw.pixelstep[plane], outw);
443  } else if (fabs(rot->angle - 3*M_PI/2) < FLT_EPSILON && outw == inh && outh == inw) {
444  simple_rotate(out->data[plane] + j * out->linesize[plane],
445  in->data[plane] + (outh-j-1) * rot->draw.pixelstep[plane],
446  in->linesize[plane], 3, rot->draw.pixelstep[plane], outw);
447  } else {
448 
449  for (i = 0; i < outw; i++) {
450  int32_t v;
451  int x1, y1;
452  uint8_t *pin, *pout;
453  x1 = x>>16;
454  y1 = y>>16;
455 
456  /* the out-of-range values avoid border artifacts */
457  if (x1 >= -1 && x1 <= inw && y1 >= -1 && y1 <= inh) {
458  uint8_t inp_inv[4]; /* interpolated input value */
459  pout = out->data[plane] + j * out->linesize[plane] + i * rot->draw.pixelstep[plane];
460  if (rot->use_bilinear) {
461  pin = rot->interpolate_bilinear(inp_inv,
462  in->data[plane], in->linesize[plane], rot->draw.pixelstep[plane],
463  x, y, inw-1, inh-1);
464  } else {
465  int x2 = av_clip(x1, 0, inw-1);
466  int y2 = av_clip(y1, 0, inh-1);
467  pin = in->data[plane] + y2 * in->linesize[plane] + x2 * rot->draw.pixelstep[plane];
468  }
469  switch (rot->draw.pixelstep[plane]) {
470  case 1:
471  *pout = *pin;
472  break;
473  case 2:
474  v = AV_RL16(pin);
475  AV_WL16(pout, v);
476  break;
477  case 3:
478  v = AV_RB24(pin);
479  AV_WB24(pout, v);
480  break;
481  case 4:
482  *((uint32_t *)pout) = *((uint32_t *)pin);
483  break;
484  default:
485  memcpy(pout, pin, rot->draw.pixelstep[plane]);
486  break;
487  }
488  }
489  x += c;
490  y -= s;
491  }
492  }
493  xprime += s;
494  yprime += c;
495  }
496 
497  return 0;
498 }
499 
500  static int filter_frame(AVFilterLink *inlink, AVFrame *in)
501 {
502  AVFilterContext *ctx = inlink->dst;
503  AVFilterLink *outlink = ctx->outputs[0];
504  AVFrame *out;
505  RotContext *rot = ctx->priv;
506  int angle_int, s, c, plane;
507  double res;
508 
509  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
510  if (!out) {
511  av_frame_free(&in);
512  return AVERROR(ENOMEM);
513  }
514  av_frame_copy_props(out, in);
515 
516  rot->var_values[VAR_N] = inlink->frame_count_out;
517  rot->var_values[VAR_T] = TS2T(in->pts, inlink->time_base);
518  rot->angle = res = av_expr_eval(rot->angle_expr, rot->var_values, rot);
519 
520  av_log(ctx, AV_LOG_DEBUG, "n:%f time:%f angle:%f/PI\n",
521  rot->var_values[VAR_N], rot->var_values[VAR_T], rot->angle/M_PI);
522 
523  angle_int = res * FIXP * 16;
524  s = int_sin(angle_int);
525  c = int_sin(angle_int + INT_PI/2);
526 
527  /* fill background */
528  if (rot->fillcolor_enable)
529  ff_fill_rectangle(&rot->draw, &rot->color, out->data, out->linesize,
530  0, 0, outlink->w, outlink->h);
531 
532  for (plane = 0; plane < rot->nb_planes; plane++) {
533  int hsub = plane == 1 || plane == 2 ? rot->hsub : 0;
534  int vsub = plane == 1 || plane == 2 ? rot->vsub : 0;
535  const int outw = AV_CEIL_RSHIFT(outlink->w, hsub);
536  const int outh = AV_CEIL_RSHIFT(outlink->h, vsub);
537  ThreadData td = { .in = in, .out = out,
538  .inw = AV_CEIL_RSHIFT(inlink->w, hsub),
539  .inh = AV_CEIL_RSHIFT(inlink->h, vsub),
540  .outh = outh, .outw = outw,
541  .xi = -(outw-1) * c / 2, .yi = (outw-1) * s / 2,
542  .xprime = -(outh-1) * s / 2,
543  .yprime = -(outh-1) * c / 2,
544  .plane = plane, .c = c, .s = s };
545 
546  ff_filter_execute(ctx, filter_slice, &td, NULL,
547  FFMIN(outh, ff_filter_get_nb_threads(ctx)));
548  }
549 
550  av_frame_free(&in);
551  return ff_filter_frame(outlink, out);
552 }
553 
554  static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
555  char *res, int res_len, int flags)
556 {
557  RotContext *rot = ctx->priv;
558  int ret;
559 
560  if (!strcmp(cmd, "angle") || !strcmp(cmd, "a")) {
561  AVExpr *old = rot->angle_expr;
562  ret = av_expr_parse(&rot->angle_expr, args, var_names,
563  NULL, NULL, NULL, NULL, 0, ctx);
564  if (ret < 0) {
565  av_log(ctx, AV_LOG_ERROR,
566  "Error when parsing the expression '%s' for angle command\n", args);
567  rot->angle_expr = old;
568  return ret;
569  }
570  av_expr_free(old);
571  } else
572  ret = AVERROR(ENOSYS);
573 
574  return ret;
575 }
576 
577  static const AVFilterPad rotate_inputs[] = {
578  {
579  .name = "default",
580  .type = AVMEDIA_TYPE_VIDEO,
581  .filter_frame = filter_frame,
582  },
583 };
584 
585  static const AVFilterPad rotate_outputs[] = {
586  {
587  .name = "default",
588  .type = AVMEDIA_TYPE_VIDEO,
589  .config_props = config_props,
590  },
591 };
592 
593  const AVFilter ff_vf_rotate = {
594  .name = "rotate",
595  .description = NULL_IF_CONFIG_SMALL("Rotate the input image."),
596  .priv_size = sizeof(RotContext),
597  .init = init,
598  .uninit = uninit,
599  .process_command = process_command,
600  FILTER_INPUTS(rotate_inputs),
601  FILTER_OUTPUTS(rotate_outputs),
602  FILTER_PIXFMTS_ARRAY(pix_fmts),
603  .priv_class = &rotate_class,
604  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
605 };
RotContext::hsub
int hsub
Definition: vf_rotate.c:73
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:101
int_sin
static int64_t int_sin(int64_t a)
Compute the sin of a using integer values.
Definition: vf_rotate.c:202
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:147
td
#define td
Definition: regdef.h:70
FFDrawColor
Definition: drawutils.h:50
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_clip
#define av_clip
Definition: common.h:95
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
out
FILE * out
Definition: movenc.c:54
VAR_N
@ VAR_N
Definition: vf_rotate.c:58
FIXP2
#define FIXP2
Definition: vf_rotate.c:195
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:969
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
av_parse_color
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:356
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:174
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:99
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVOption
AVOption.
Definition: opt.h:251
VAR_T
@ VAR_T
Definition: vf_rotate.c:59
RotContext
Definition: vf_rotate.c:63
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:121
float.h
filter_slice
static int filter_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
Definition: vf_rotate.c:410
RotContext::fillcolor
uint8_t fillcolor[4]
color expressed either in YUVA or RGBA colorspace for the padding area
Definition: vf_rotate.c:70
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
VAR_IW
@ VAR_IW
Definition: vf_rotate.c:53
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:165
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:473
RotContext::color
FFDrawColor color
Definition: vf_rotate.c:79
VAR_OW
@ VAR_OW
Definition: vf_rotate.c:55
FIXP
#define FIXP
Definition: vf_rotate.c:194
video.h
interpolate_bilinear16
static uint8_t * interpolate_bilinear16(uint8_t *dst_color, const uint8_t *src, int src_linesize, int src_linestep, int x, int y, int max_x, int max_y)
Interpolate the color in src at position x and y using bilinear interpolation.
Definition: vf_rotate.c:255
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:154
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_rotate.c:554
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
FFDrawContext::pixelstep
int pixelstep[MAX_PLANES]
Definition: drawutils.h:39
get_rotated_h
static double get_rotated_h(void *opaque, double angle)
Definition: vf_rotate.c:170
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:125
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:685
ff_vf_rotate
const AVFilter ff_vf_rotate
Definition: vf_rotate.c:593
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2928
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(rotate)
simple_rotate_internal
static av_always_inline void simple_rotate_internal(uint8_t *dst, const uint8_t *src, int src_linesize, int angle, int elem_size, int len)
Definition: vf_rotate.c:377
RotContext::angle_expr
AVExpr * angle_expr
parsed expression for the angle
Definition: vf_rotate.c:67
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:261
RotContext::nb_planes
int nb_planes
Definition: vf_rotate.c:74
RotContext::angle
double angle
Definition: vf_rotate.c:65
func1_names
static const char *const func1_names[]
Definition: vf_rotate.c:188
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:149
rotate
static void rotate(const float rot_quaternion[2][4], float *vec)
Rotate vector with given rotation quaternion.
Definition: vf_v360.c:4064
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:269
ThreadData::xi
int xi
Definition: vf_rotate.c:90
TS2T
#define TS2T(ts, tb)
Definition: internal.h:265
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ThreadData::plane
int plane
Definition: vf_blend.c:58
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
VAR_IN_H
@ VAR_IN_H
Definition: vf_rotate.c:54
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
RotContext::interpolate_bilinear
uint8_t *(* interpolate_bilinear)(uint8_t *dst_color, const uint8_t *src, int src_linesize, int src_linestep, int x, int y, int max_x, int max_y)
Definition: vf_rotate.c:80
ThreadData::yi
int yi
Definition: vf_rotate.c:90
VAR_IN_W
@ VAR_IN_W
Definition: vf_rotate.c:53
s1
#define s1
Definition: regdef.h:38
var_name
var_name
Definition: noise_bsf.c:46
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:48
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
xi
#define xi(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:402
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
AVExpr
Definition: eval.c:157
RotContext::outw
int outw
Definition: vf_rotate.c:69
ff_draw_init
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
Definition: drawutils.c:151
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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:66
NAN
#define NAN
Definition: mathematics.h:64
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:194
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_rotate.c:500
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:80
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:155
arg
const char * arg
Definition: jacosubdec.c:67
RotContext::use_bilinear
int use_bilinear
Definition: vf_rotate.c:75
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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:594
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_rotate.c:114
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:78
parseutils.h
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:173
double
double
Definition: af_crystalizer.c:132
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:181
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:258
ThreadData::c
int c
Definition: vf_rotate.c:92
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:169
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
RotContext::vsub
int vsub
Definition: vf_rotate.c:73
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
eval.h
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
simple_rotate
static av_always_inline void simple_rotate(uint8_t *dst, const uint8_t *src, int src_linesize, int angle, int elem_size, int len)
Definition: vf_rotate.c:399
OFFSET
#define OFFSET(x)
Definition: vf_rotate.c:95
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:115
av_expr_parse_and_eval
int av_expr_parse_and_eval(double *d, const char *s, const char *const *const_names, const double *const_values, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), void *opaque, int log_offset, void *log_ctx)
Parse and evaluate an expression.
Definition: eval.c:776
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_rotate.c:60
VAR_IH
@ VAR_IH
Definition: vf_rotate.c:54
VAR_OUT_W
@ VAR_OUT_W
Definition: vf_rotate.c:55
VAR_OH
@ VAR_OH
Definition: vf_rotate.c:56
ff_fill_rectangle
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
Definition: drawutils.c:231
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
ThreadData::yprime
int yprime
Definition: vf_rotate.c:91
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
rotate_inputs
static const AVFilterPad rotate_inputs[]
Definition: vf_rotate.c:577
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:256
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:175
rotate_outputs
static const AVFilterPad rotate_outputs[]
Definition: vf_rotate.c:585
M_PI
#define M_PI
Definition: mathematics.h:52
RotContext::outh_expr_str
char * outh_expr_str
Definition: vf_rotate.c:68
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:142
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
SET_SIZE_EXPR
#define SET_SIZE_EXPR(name, opt_name)
rotate_options
static const AVOption rotate_options[]
Definition: vf_rotate.c:99
ThreadData::s
int s
Definition: vf_rotate.c:92
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_rotate.c:127
func1
static double(*const func1[])(void *, double)
Definition: vf_rotate.c:182
get_rotated_w
static double get_rotated_w(void *opaque, double angle)
Definition: vf_rotate.c:158
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
a2
#define a2
Definition: regdef.h:48
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:777
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FFDrawContext
Definition: drawutils.h:35
ThreadData::xprime
int xprime
Definition: vf_rotate.c:91
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:156
AVFilter
Filter definition.
Definition: avfilter.h:161
ret
ret
Definition: filter_design.txt:187
RotContext::fillcolor_str
char * fillcolor_str
Definition: vf_rotate.c:71
INT_PI
#define INT_PI
Definition: vf_rotate.c:196
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:257
RotContext::cosx
float cosx
Definition: vf_rotate.c:76
RotContext::draw
FFDrawContext draw
Definition: vf_rotate.c:78
FLAGS
#define FLAGS
Definition: vf_rotate.c:96
ThreadData::outh
int outh
Definition: vf_rotate.c:88
config_props
static int config_props(AVFilterLink *outlink)
Definition: vf_rotate.c:281
ThreadData::outw
int outw
Definition: vf_rotate.c:88
RotContext::fillcolor_enable
int fillcolor_enable
Definition: vf_rotate.c:72
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
RotContext::var_values
double var_values[VAR_VARS_NB]
Definition: vf_rotate.c:77
avfilter.h
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:153
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
RotContext::angle_expr_str
char * angle_expr_str
expression for the angle
Definition: vf_rotate.c:66
VAR_VSUB
@ VAR_VSUB
Definition: vf_rotate.c:57
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:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:392
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
RotContext::outh
int outh
Definition: vf_rotate.c:69
var_names
static const char *const var_names[]
Definition: vf_rotate.c:41
s0
#define s0
Definition: regdef.h:37
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:179
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
TFLAGS
#define TFLAGS
Definition: vf_rotate.c:97
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_rotate.c:135
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:195
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ThreadData::inh
int inh
Definition: vf_rotate.c:87
RotContext::outw_expr_str
char * outw_expr_str
Definition: vf_rotate.c:68
int32_t
int32_t
Definition: audioconvert.c:56
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:375
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:255
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:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VAR_OUT_H
@ VAR_OUT_H
Definition: vf_rotate.c:56
interpolate_bilinear8
static uint8_t * interpolate_bilinear8(uint8_t *dst_color, const uint8_t *src, int src_linesize, int src_linestep, int x, int y, int max_x, int max_y)
Interpolate the color in src at position x and y using bilinear interpolation.
Definition: vf_rotate.c:225
avstring.h
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:185
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:146
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
RotContext::sinx
float sinx
Definition: vf_rotate.c:76
copy_elem
static av_always_inline void copy_elem(uint8_t *pout, const uint8_t *pin, int elem_size)
Definition: vf_rotate.c:354
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
VAR_HSUB
@ VAR_HSUB
Definition: vf_rotate.c:57
ThreadData::inw
int inw
Definition: vf_rotate.c:87
Generated on Tue Feb 28 2023 21:33:58 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /