Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 { | |
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 | } RotContext; | |
81 | ||
82 | typedef struct ThreadData { | |
83 | AVFrame *in, *out; | |
84 | int inw, inh; | |
85 | int outw, outh; | |
86 | int plane; | |
87 | int xi, yi; | |
88 | int xprime, yprime; | |
89 | int c, s; | |
90 | } ThreadData; | |
91 | ||
92 | #define OFFSET(x) offsetof(RotContext, x) | |
93 | #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM | |
94 | ||
95 | static const AVOption rotate_options[] = { | |
96 | { "angle", "set angle (in radians)", OFFSET(angle_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
97 | { "a", "set angle (in radians)", OFFSET(angle_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
98 | { "out_w", "set output width expression", OFFSET(outw_expr_str), AV_OPT_TYPE_STRING, {.str="iw"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
99 | { "ow", "set output width expression", OFFSET(outw_expr_str), AV_OPT_TYPE_STRING, {.str="iw"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
100 | { "out_h", "set output height expression", OFFSET(outh_expr_str), AV_OPT_TYPE_STRING, {.str="ih"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
101 | { "oh", "set output height expression", OFFSET(outh_expr_str), AV_OPT_TYPE_STRING, {.str="ih"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
102 | { "fillcolor", "set background fill color", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str="black"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
103 | { "c", "set background fill color", OFFSET(fillcolor_str), AV_OPT_TYPE_STRING, {.str="black"}, CHAR_MIN, CHAR_MAX, .flags=FLAGS }, | |
104 | { "bilinear", "use bilinear interpolation", OFFSET(use_bilinear), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, .flags=FLAGS }, | |
105 | { NULL } | |
106 | }; | |
107 | ||
108 | AVFILTER_DEFINE_CLASS(rotate); | |
109 | ||
110 | static av_cold int init(AVFilterContext *ctx) | |
111 | { | |
112 | RotContext *rot = ctx->priv; | |
113 | ||
114 | if (!strcmp(rot->fillcolor_str, "none")) | |
115 | rot->fillcolor_enable = 0; | |
116 | else if (av_parse_color(rot->fillcolor, rot->fillcolor_str, -1, ctx) >= 0) | |
117 | rot->fillcolor_enable = 1; | |
118 | else | |
119 | return AVERROR(EINVAL); | |
120 | return 0; | |
121 | } | |
122 | ||
123 | static av_cold void uninit(AVFilterContext *ctx) | |
124 | { | |
125 | RotContext *rot = ctx->priv; | |
126 | ||
127 | av_expr_free(rot->angle_expr); | |
128 | rot->angle_expr = NULL; | |
129 | } | |
130 | ||
131 | static int query_formats(AVFilterContext *ctx) | |
132 | { | |
133 | static const enum PixelFormat pix_fmts[] = { | |
134 | AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, | |
135 | AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, | |
136 | AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, | |
137 | AV_PIX_FMT_0RGB, AV_PIX_FMT_RGB0, | |
138 | AV_PIX_FMT_0BGR, AV_PIX_FMT_BGR0, | |
139 | AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, | |
140 | AV_PIX_FMT_GRAY8, | |
141 | AV_PIX_FMT_YUV410P, | |
142 | AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, | |
143 | AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P, | |
144 | AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA420P, | |
145 | AV_PIX_FMT_NONE | |
146 | }; | |
147 | ||
148 | ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); | |
149 | return 0; | |
150 | } | |
151 | ||
152 | static double get_rotated_w(void *opaque, double angle) | |
153 | { | |
154 | RotContext *rot = opaque; | |
155 | double inw = rot->var_values[VAR_IN_W]; | |
156 | double inh = rot->var_values[VAR_IN_H]; | |
157 | float sinx = sin(angle); | |
158 | float cosx = cos(angle); | |
159 | ||
160 | return FFMAX(0, inh * sinx) + FFMAX(0, -inw * cosx) + | |
161 | FFMAX(0, inw * cosx) + FFMAX(0, -inh * sinx); | |
162 | } | |
163 | ||
164 | static double get_rotated_h(void *opaque, double angle) | |
165 | { | |
166 | RotContext *rot = opaque; | |
167 | double inw = rot->var_values[VAR_IN_W]; | |
168 | double inh = rot->var_values[VAR_IN_H]; | |
169 | float sinx = sin(angle); | |
170 | float cosx = cos(angle); | |
171 | ||
172 | return FFMAX(0, -inh * cosx) + FFMAX(0, -inw * sinx) + | |
173 | FFMAX(0, inh * cosx) + FFMAX(0, inw * sinx); | |
174 | } | |
175 | ||
176 | static double (* const func1[])(void *, double) = { | |
177 | get_rotated_w, | |
178 | get_rotated_h, | |
179 | NULL | |
180 | }; | |
181 | ||
182 | static const char * const func1_names[] = { | |
183 | "rotw", | |
184 | "roth", | |
185 | NULL | |
186 | }; | |
187 | ||
188 | static int config_props(AVFilterLink *outlink) | |
189 | { | |
190 | AVFilterContext *ctx = outlink->src; | |
191 | RotContext *rot = ctx->priv; | |
192 | AVFilterLink *inlink = ctx->inputs[0]; | |
193 | const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(inlink->format); | |
194 | int ret; | |
195 | double res; | |
196 | char *expr; | |
197 | ||
198 | ff_draw_init(&rot->draw, inlink->format, 0); | |
199 | ff_draw_color(&rot->draw, &rot->color, rot->fillcolor); | |
200 | ||
201 | rot->hsub = pixdesc->log2_chroma_w; | |
202 | rot->vsub = pixdesc->log2_chroma_h; | |
203 | ||
204 | rot->var_values[VAR_IN_W] = rot->var_values[VAR_IW] = inlink->w; | |
205 | rot->var_values[VAR_IN_H] = rot->var_values[VAR_IH] = inlink->h; | |
206 | rot->var_values[VAR_HSUB] = 1<<rot->hsub; | |
207 | rot->var_values[VAR_VSUB] = 1<<rot->vsub; | |
208 | rot->var_values[VAR_N] = NAN; | |
209 | rot->var_values[VAR_T] = NAN; | |
210 | rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = NAN; | |
211 | rot->var_values[VAR_OUT_H] = rot->var_values[VAR_OH] = NAN; | |
212 | ||
213 | av_expr_free(rot->angle_expr); | |
214 | rot->angle_expr = NULL; | |
215 | if ((ret = av_expr_parse(&rot->angle_expr, expr = rot->angle_expr_str, var_names, | |
216 | func1_names, func1, NULL, NULL, 0, ctx)) < 0) { | |
217 | av_log(ctx, AV_LOG_ERROR, | |
218 | "Error occurred parsing angle expression '%s'\n", rot->angle_expr_str); | |
219 | return ret; | |
220 | } | |
221 | ||
222 | #define SET_SIZE_EXPR(name, opt_name) do { \ | |
223 | ret = av_expr_parse_and_eval(&res, expr = rot->name##_expr_str, \ | |
224 | var_names, rot->var_values, \ | |
225 | func1_names, func1, NULL, NULL, rot, 0, ctx); \ | |
226 | if (ret < 0 || isnan(res) || isinf(res) || res <= 0) { \ | |
227 | av_log(ctx, AV_LOG_ERROR, \ | |
228 | "Error parsing or evaluating expression for option %s: " \ | |
229 | "invalid expression '%s' or non-positive or indefinite value %f\n", \ | |
230 | opt_name, expr, res); \ | |
231 | return ret; \ | |
232 | } \ | |
233 | } while (0) | |
234 | ||
235 | /* evaluate width and height */ | |
236 | av_expr_parse_and_eval(&res, expr = rot->outw_expr_str, var_names, rot->var_values, | |
237 | func1_names, func1, NULL, NULL, rot, 0, ctx); | |
238 | rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = res; | |
239 | rot->outw = res + 0.5; | |
240 | SET_SIZE_EXPR(outh, "out_w"); | |
241 | rot->var_values[VAR_OUT_H] = rot->var_values[VAR_OH] = res; | |
242 | rot->outh = res + 0.5; | |
243 | ||
244 | /* evaluate the width again, as it may depend on the evaluated output height */ | |
245 | SET_SIZE_EXPR(outw, "out_h"); | |
246 | rot->var_values[VAR_OUT_W] = rot->var_values[VAR_OW] = res; | |
247 | rot->outw = res + 0.5; | |
248 | ||
249 | /* compute number of planes */ | |
250 | rot->nb_planes = av_pix_fmt_count_planes(inlink->format); | |
251 | outlink->w = rot->outw; | |
252 | outlink->h = rot->outh; | |
253 | return 0; | |
254 | } | |
255 | ||
256 | #define FIXP (1<<16) | |
257 | #define FIXP2 (1<<20) | |
258 | #define INT_PI 3294199 //(M_PI * FIXP2) | |
259 | ||
260 | /** | |
261 | * Compute the sin of a using integer values. | |
262 | * Input is scaled by FIXP2 and output values are scaled by FIXP. | |
263 | */ | |
264 | static int64_t int_sin(int64_t a) | |
265 | { | |
266 | int64_t a2, res = 0; | |
267 | int i; | |
268 | if (a < 0) a = INT_PI-a; // 0..inf | |
269 | a %= 2 * INT_PI; // 0..2PI | |
270 | ||
271 | if (a >= INT_PI*3/2) a -= 2*INT_PI; // -PI/2 .. 3PI/2 | |
272 | if (a >= INT_PI/2 ) a = INT_PI - a; // -PI/2 .. PI/2 | |
273 | ||
274 | /* compute sin using Taylor series approximated to the fifth term */ | |
275 | a2 = (a*a)/(FIXP2); | |
276 | for (i = 2; i < 11; i += 2) { | |
277 | res += a; | |
278 | a = -a*a2 / (FIXP2*i*(i+1)); | |
279 | } | |
280 | return (res + 8)>>4; | |
281 | } | |
282 | ||
283 | /** | |
284 | * Interpolate the color in src at position x and y using bilinear | |
285 | * interpolation. | |
286 | */ | |
287 | static uint8_t *interpolate_bilinear(uint8_t *dst_color, | |
288 | const uint8_t *src, int src_linesize, int src_linestep, | |
289 | int x, int y, int max_x, int max_y) | |
290 | { | |
291 | int int_x = av_clip(x>>16, 0, max_x); | |
292 | int int_y = av_clip(y>>16, 0, max_y); | |
293 | int frac_x = x&0xFFFF; | |
294 | int frac_y = y&0xFFFF; | |
295 | int i; | |
296 | int int_x1 = FFMIN(int_x+1, max_x); | |
297 | int int_y1 = FFMIN(int_y+1, max_y); | |
298 | ||
299 | for (i = 0; i < src_linestep; i++) { | |
300 | int s00 = src[src_linestep * int_x + i + src_linesize * int_y ]; | |
301 | int s01 = src[src_linestep * int_x1 + i + src_linesize * int_y ]; | |
302 | int s10 = src[src_linestep * int_x + i + src_linesize * int_y1]; | |
303 | int s11 = src[src_linestep * int_x1 + i + src_linesize * int_y1]; | |
304 | int s0 = (((1<<16) - frac_x)*s00 + frac_x*s01); | |
305 | int s1 = (((1<<16) - frac_x)*s10 + frac_x*s11); | |
306 | ||
307 | dst_color[i] = ((int64_t)((1<<16) - frac_y)*s0 + (int64_t)frac_y*s1) >> 32; | |
308 | } | |
309 | ||
310 | return dst_color; | |
311 | } | |
312 | ||
313 | static av_always_inline void copy_elem(uint8_t *pout, const uint8_t *pin, int elem_size) | |
314 | { | |
315 | int v; | |
316 | switch (elem_size) { | |
317 | case 1: | |
318 | *pout = *pin; | |
319 | break; | |
320 | case 2: | |
321 | *((uint16_t *)pout) = *((uint16_t *)pin); | |
322 | break; | |
323 | case 3: | |
324 | v = AV_RB24(pin); | |
325 | AV_WB24(pout, v); | |
326 | break; | |
327 | case 4: | |
328 | *((uint32_t *)pout) = *((uint32_t *)pin); | |
329 | break; | |
330 | default: | |
331 | memcpy(pout, pin, elem_size); | |
332 | break; | |
333 | } | |
334 | } | |
335 | ||
336 | 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) | |
337 | { | |
338 | int i; | |
339 | switch(angle) { | |
340 | case 0: | |
341 | memcpy(dst, src, elem_size * len); | |
342 | break; | |
343 | case 1: | |
344 | for (i = 0; i<len; i++) | |
345 | copy_elem(dst + i*elem_size, src + (len-i-1)*src_linesize, elem_size); | |
346 | break; | |
347 | case 2: | |
348 | for (i = 0; i<len; i++) | |
349 | copy_elem(dst + i*elem_size, src + (len-i-1)*elem_size, elem_size); | |
350 | break; | |
351 | case 3: | |
352 | for (i = 0; i<len; i++) | |
353 | copy_elem(dst + i*elem_size, src + i*src_linesize, elem_size); | |
354 | break; | |
355 | } | |
356 | } | |
357 | ||
358 | static av_always_inline void simple_rotate(uint8_t *dst, const uint8_t *src, int src_linesize, int angle, int elem_size, int len) | |
359 | { | |
360 | switch(elem_size) { | |
361 | case 1 : simple_rotate_internal(dst, src, src_linesize, angle, 1, len); break; | |
362 | case 2 : simple_rotate_internal(dst, src, src_linesize, angle, 2, len); break; | |
363 | case 3 : simple_rotate_internal(dst, src, src_linesize, angle, 3, len); break; | |
364 | case 4 : simple_rotate_internal(dst, src, src_linesize, angle, 4, len); break; | |
365 | default: simple_rotate_internal(dst, src, src_linesize, angle, elem_size, len); break; | |
366 | } | |
367 | } | |
368 | ||
369 | #define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts)*av_q2d(tb)) | |
370 | ||
371 | static int filter_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs) | |
372 | { | |
373 | ThreadData *td = arg; | |
374 | AVFrame *in = td->in; | |
375 | AVFrame *out = td->out; | |
376 | RotContext *rot = ctx->priv; | |
377 | const int outw = td->outw, outh = td->outh; | |
378 | const int inw = td->inw, inh = td->inh; | |
379 | const int plane = td->plane; | |
380 | const int xi = td->xi, yi = td->yi; | |
381 | const int c = td->c, s = td->s; | |
382 | const int start = (outh * job ) / nb_jobs; | |
383 | const int end = (outh * (job+1)) / nb_jobs; | |
384 | int xprime = td->xprime + start * s; | |
385 | int yprime = td->yprime + start * c; | |
386 | int i, j, x, y; | |
387 | ||
388 | for (j = start; j < end; j++) { | |
389 | x = xprime + xi + FIXP*(inw-1)/2; | |
390 | y = yprime + yi + FIXP*(inh-1)/2; | |
391 | ||
392 | if (fabs(rot->angle - 0) < FLT_EPSILON && outw == inw && outh == inh) { | |
393 | simple_rotate(out->data[plane] + j * out->linesize[plane], | |
394 | in->data[plane] + j * in->linesize[plane], | |
395 | in->linesize[plane], 0, rot->draw.pixelstep[plane], outw); | |
396 | } else if (fabs(rot->angle - M_PI/2) < FLT_EPSILON && outw == inh && outh == inw) { | |
397 | simple_rotate(out->data[plane] + j * out->linesize[plane], | |
398 | in->data[plane] + j * rot->draw.pixelstep[plane], | |
399 | in->linesize[plane], 1, rot->draw.pixelstep[plane], outw); | |
400 | } else if (fabs(rot->angle - M_PI) < FLT_EPSILON && outw == inw && outh == inh) { | |
401 | simple_rotate(out->data[plane] + j * out->linesize[plane], | |
402 | in->data[plane] + (outh-j-1) * in->linesize[plane], | |
403 | in->linesize[plane], 2, rot->draw.pixelstep[plane], outw); | |
404 | } else if (fabs(rot->angle - 3*M_PI/2) < FLT_EPSILON && outw == inh && outh == inw) { | |
405 | simple_rotate(out->data[plane] + j * out->linesize[plane], | |
406 | in->data[plane] + (outh-j-1) * rot->draw.pixelstep[plane], | |
407 | in->linesize[plane], 3, rot->draw.pixelstep[plane], outw); | |
408 | } else { | |
409 | ||
410 | for (i = 0; i < outw; i++) { | |
411 | int32_t v; | |
412 | int x1, y1; | |
413 | uint8_t *pin, *pout; | |
414 | x1 = x>>16; | |
415 | y1 = y>>16; | |
416 | ||
417 | /* the out-of-range values avoid border artifacts */ | |
418 | if (x1 >= -1 && x1 <= inw && y1 >= -1 && y1 <= inh) { | |
419 | uint8_t inp_inv[4]; /* interpolated input value */ | |
420 | pout = out->data[plane] + j * out->linesize[plane] + i * rot->draw.pixelstep[plane]; | |
421 | if (rot->use_bilinear) { | |
422 | pin = interpolate_bilinear(inp_inv, | |
423 | in->data[plane], in->linesize[plane], rot->draw.pixelstep[plane], | |
424 | x, y, inw-1, inh-1); | |
425 | } else { | |
426 | int x2 = av_clip(x1, 0, inw-1); | |
427 | int y2 = av_clip(y1, 0, inh-1); | |
428 | pin = in->data[plane] + y2 * in->linesize[plane] + x2 * rot->draw.pixelstep[plane]; | |
429 | } | |
430 | switch (rot->draw.pixelstep[plane]) { | |
431 | case 1: | |
432 | *pout = *pin; | |
433 | break; | |
434 | case 2: | |
435 | *((uint16_t *)pout) = *((uint16_t *)pin); | |
436 | break; | |
437 | case 3: | |
438 | v = AV_RB24(pin); | |
439 | AV_WB24(pout, v); | |
440 | break; | |
441 | case 4: | |
442 | *((uint32_t *)pout) = *((uint32_t *)pin); | |
443 | break; | |
444 | default: | |
445 | memcpy(pout, pin, rot->draw.pixelstep[plane]); | |
446 | break; | |
447 | } | |
448 | } | |
449 | x += c; | |
450 | y -= s; | |
451 | } | |
452 | } | |
453 | xprime += s; | |
454 | yprime += c; | |
455 | } | |
456 | ||
457 | return 0; | |
458 | } | |
459 | ||
460 | static int filter_frame(AVFilterLink *inlink, AVFrame *in) | |
461 | { | |
462 | AVFilterContext *ctx = inlink->dst; | |
463 | AVFilterLink *outlink = ctx->outputs[0]; | |
464 | AVFrame *out; | |
465 | RotContext *rot = ctx->priv; | |
466 | int angle_int, s, c, plane; | |
467 | double res; | |
468 | ||
469 | out = ff_get_video_buffer(outlink, outlink->w, outlink->h); | |
470 | if (!out) { | |
471 | av_frame_free(&in); | |
472 | return AVERROR(ENOMEM); | |
473 | } | |
474 | av_frame_copy_props(out, in); | |
475 | ||
476 | rot->var_values[VAR_N] = inlink->frame_count; | |
477 | rot->var_values[VAR_T] = TS2T(in->pts, inlink->time_base); | |
478 | rot->angle = res = av_expr_eval(rot->angle_expr, rot->var_values, rot); | |
479 | ||
480 | av_log(ctx, AV_LOG_DEBUG, "n:%f time:%f angle:%f/PI\n", | |
481 | rot->var_values[VAR_N], rot->var_values[VAR_T], rot->angle/M_PI); | |
482 | ||
483 | angle_int = res * FIXP * 16; | |
484 | s = int_sin(angle_int); | |
485 | c = int_sin(angle_int + INT_PI/2); | |
486 | ||
487 | /* fill background */ | |
488 | if (rot->fillcolor_enable) | |
489 | ff_fill_rectangle(&rot->draw, &rot->color, out->data, out->linesize, | |
490 | 0, 0, outlink->w, outlink->h); | |
491 | ||
492 | for (plane = 0; plane < rot->nb_planes; plane++) { | |
493 | int hsub = plane == 1 || plane == 2 ? rot->hsub : 0; | |
494 | int vsub = plane == 1 || plane == 2 ? rot->vsub : 0; | |
495 | const int outw = FF_CEIL_RSHIFT(outlink->w, hsub); | |
496 | const int outh = FF_CEIL_RSHIFT(outlink->h, vsub); | |
497 | ThreadData td = { .in = in, .out = out, | |
498 | .inw = FF_CEIL_RSHIFT(inlink->w, hsub), | |
499 | .inh = FF_CEIL_RSHIFT(inlink->h, vsub), | |
500 | .outh = outh, .outw = outw, | |
501 | .xi = -(outw-1) * c / 2, .yi = (outw-1) * s / 2, | |
502 | .xprime = -(outh-1) * s / 2, | |
503 | .yprime = -(outh-1) * c / 2, | |
504 | .plane = plane, .c = c, .s = s }; | |
505 | ||
506 | ||
507 | ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(outh, ctx->graph->nb_threads)); | |
508 | } | |
509 | ||
510 | av_frame_free(&in); | |
511 | return ff_filter_frame(outlink, out); | |
512 | } | |
513 | ||
514 | static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, | |
515 | char *res, int res_len, int flags) | |
516 | { | |
517 | RotContext *rot = ctx->priv; | |
518 | int ret; | |
519 | ||
520 | if (!strcmp(cmd, "angle") || !strcmp(cmd, "a")) { | |
521 | AVExpr *old = rot->angle_expr; | |
522 | ret = av_expr_parse(&rot->angle_expr, args, var_names, | |
523 | NULL, NULL, NULL, NULL, 0, ctx); | |
524 | if (ret < 0) { | |
525 | av_log(ctx, AV_LOG_ERROR, | |
526 | "Error when parsing the expression '%s' for angle command\n", args); | |
527 | rot->angle_expr = old; | |
528 | return ret; | |
529 | } | |
530 | av_expr_free(old); | |
531 | } else | |
532 | ret = AVERROR(ENOSYS); | |
533 | ||
534 | return ret; | |
535 | } | |
536 | ||
537 | static const AVFilterPad rotate_inputs[] = { | |
538 | { | |
539 | .name = "default", | |
540 | .type = AVMEDIA_TYPE_VIDEO, | |
541 | .filter_frame = filter_frame, | |
542 | }, | |
543 | { NULL } | |
544 | }; | |
545 | ||
546 | static const AVFilterPad rotate_outputs[] = { | |
547 | { | |
548 | .name = "default", | |
549 | .type = AVMEDIA_TYPE_VIDEO, | |
550 | .config_props = config_props, | |
551 | }, | |
552 | { NULL } | |
553 | }; | |
554 | ||
555 | AVFilter ff_vf_rotate = { | |
556 | .name = "rotate", | |
557 | .description = NULL_IF_CONFIG_SMALL("Rotate the input image."), | |
558 | .priv_size = sizeof(RotContext), | |
559 | .init = init, | |
560 | .uninit = uninit, | |
561 | .query_formats = query_formats, | |
562 | .process_command = process_command, | |
563 | .inputs = rotate_inputs, | |
564 | .outputs = rotate_outputs, | |
565 | .priv_class = &rotate_class, | |
566 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS, | |
567 | }; |