lavfi/hue: add process_command callback
[ffmpeg.git] / libavfilter / vf_hue.c
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
3  * Copyright (c) 2012 Jeremy Tran
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (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
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 /**
23  * @file
24  * Apply a hue/saturation filter to the input video
25  * Ported from MPlayer libmpcodecs/vf_hue.c.
26  */
27
28 #include <float.h>
29 #include "libavutil/imgutils.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32
33 #include "avfilter.h"
34 #include "formats.h"
35 #include "internal.h"
36 #include "video.h"
37
38 #define HUE_DEFAULT_VAL 0
39 #define SAT_DEFAULT_VAL 1
40
41 typedef struct {
42     const    AVClass *class;
43     float    hue_deg; /* hue expressed in degrees */
44     float    hue; /* hue expressed in radians */
45     float    saturation;
46     int      hsub;
47     int      vsub;
48     int32_t hue_sin;
49     int32_t hue_cos;
50 } HueContext;
51
52 #define OFFSET(x) offsetof(HueContext, x)
53 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
54 static const AVOption hue_options[] = {
55     { "h", "set the hue angle degrees", OFFSET(hue_deg), AV_OPT_TYPE_FLOAT,
56       { -FLT_MAX }, -FLT_MAX, FLT_MAX, FLAGS },
57     { "H", "set the hue angle radians", OFFSET(hue), AV_OPT_TYPE_FLOAT,
58       { -FLT_MAX }, -FLT_MAX, FLT_MAX, FLAGS },
59     { "s", "set the saturation value", OFFSET(saturation), AV_OPT_TYPE_FLOAT,
60       { SAT_DEFAULT_VAL }, -10, 10, FLAGS },
61     { NULL }
62 };
63
64 AVFILTER_DEFINE_CLASS(hue);
65
66 static inline int set_options(AVFilterContext *ctx, const char *args)
67 {
68     HueContext *hue = ctx->priv;
69     int n, ret;
70     char c1 = 0, c2 = 0;
71     char *equal;
72
73     if (args) {
74         /* named options syntax */
75         if (equal = strchr(args, '=')) {
76             hue->hue     = -FLT_MAX;
77             hue->hue_deg = -FLT_MAX;
78
79             if ((ret = av_set_options_string(hue, args, "=", ":")) < 0)
80                 return ret;
81             if (hue->hue != -FLT_MAX && hue->hue_deg != -FLT_MAX) {
82                 av_log(ctx, AV_LOG_ERROR,
83                        "H and h options are incompatible and cannot be specified "
84                        "at the same time\n");
85                 return AVERROR(EINVAL);
86             }
87         /* compatibility h:s syntax */
88         } else {
89             n = sscanf(args, "%f%c%f%c", &hue->hue_deg, &c1, &hue->saturation, &c2);
90             if (n != 1 && (n != 3 || c1 != ':')) {
91                 av_log(ctx, AV_LOG_ERROR,
92                        "Invalid syntax for argument '%s': "
93                        "must be in the form 'hue[:saturation]'\n", args);
94                 return AVERROR(EINVAL);
95             }
96
97             if (hue->saturation < -10 || hue->saturation > 10) {
98                 av_log(ctx, AV_LOG_ERROR,
99                        "Invalid value for saturation %0.1f: "
100                        "must be included between range -10 and +10\n", hue->saturation);
101                 return AVERROR(EINVAL);
102             }
103         }
104     }
105
106     return 0;
107 }
108
109 static av_cold int init(AVFilterContext *ctx, const char *args)
110 {
111     HueContext *hue = ctx->priv;
112     int ret;
113
114     hue->class = &hue_class;
115     av_opt_set_defaults(hue);
116
117     if ((ret = set_options(ctx, args)) < 0)
118         return ret;
119
120     if (hue->saturation == -FLT_MAX)
121         hue->hue = SAT_DEFAULT_VAL;
122     if (hue->hue == -FLT_MAX)
123         hue->hue = HUE_DEFAULT_VAL;
124     if (hue->hue_deg != -FLT_MAX)
125         /* Convert angle from degrees to radians */
126         hue->hue = hue->hue_deg * M_PI / 180;
127
128     av_log(ctx, AV_LOG_VERBOSE, "hue:%f*PI hue_deg:%f saturation:%f\n",
129            hue->hue/M_PI, hue->hue*180/M_PI, hue->saturation);
130     return 0;
131 }
132
133 static av_cold void uninit(AVFilterContext *ctx)
134 {
135     HueContext *hue = ctx->priv;
136
137     av_opt_free(hue);
138 }
139
140 static int query_formats(AVFilterContext *ctx)
141 {
142     static const enum PixelFormat pix_fmts[] = {
143         PIX_FMT_YUV444P,      PIX_FMT_YUV422P,
144         PIX_FMT_YUV420P,      PIX_FMT_YUV411P,
145         PIX_FMT_YUV410P,      PIX_FMT_YUV440P,
146         PIX_FMT_YUVA420P,
147         PIX_FMT_NONE
148     };
149
150     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
151
152     return 0;
153 }
154
155 static int config_props(AVFilterLink *inlink)
156 {
157     HueContext *hue = inlink->dst->priv;
158     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[inlink->format];
159
160     hue->hsub = desc->log2_chroma_w;
161     hue->vsub = desc->log2_chroma_h;
162     /*
163      * Scale the value to the norm of the resulting (U,V) vector, that is
164      * the saturation.
165      * This will be useful in the process_chrominance function.
166      */
167     hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
168     hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
169
170     return 0;
171 }
172
173 static void process_chrominance(uint8_t *udst, uint8_t *vdst, const int dst_linesize,
174                                 uint8_t *usrc, uint8_t *vsrc, const int src_linesize,
175                                 int w, int h,
176                                 const int32_t c, const int32_t s)
177 {
178     int32_t u, v, new_u, new_v;
179     int i;
180
181     /*
182      * If we consider U and V as the components of a 2D vector then its angle
183      * is the hue and the norm is the saturation
184      */
185     while (h--) {
186         for (i = 0; i < w; i++) {
187             /* Normalize the components from range [16;140] to [-112;112] */
188             u = usrc[i] - 128;
189             v = vsrc[i] - 128;
190             /*
191              * Apply the rotation of the vector : (c * u) - (s * v)
192              *                                    (s * u) + (c * v)
193              * De-normalize the components (without forgetting to scale 128
194              * by << 16)
195              * Finally scale back the result by >> 16
196              */
197             new_u = ((c * u) - (s * v) + (1 << 15) + (128 << 16)) >> 16;
198             new_v = ((s * u) + (c * v) + (1 << 15) + (128 << 16)) >> 16;
199
200             /* Prevent a potential overflow */
201             udst[i] = av_clip_uint8_c(new_u);
202             vdst[i] = av_clip_uint8_c(new_v);
203         }
204
205         usrc += src_linesize;
206         vsrc += src_linesize;
207         udst += dst_linesize;
208         vdst += dst_linesize;
209     }
210 }
211
212 static int draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
213 {
214     HueContext        *hue    = inlink->dst->priv;
215     AVFilterBufferRef *inpic  = inlink->cur_buf;
216     AVFilterBufferRef *outpic = inlink->dst->outputs[0]->out_buf;
217     uint8_t *inrow[3], *outrow[3]; // 0 : Y, 1 : U, 2 : V
218     int plane;
219
220     inrow[0]  = inpic->data[0]  + y * inpic->linesize[0];
221     outrow[0] = outpic->data[0] + y * outpic->linesize[0];
222
223     for (plane = 1; plane < 3; plane++) {
224         inrow[plane]  = inpic->data[plane]  + (y >> hue->vsub) * inpic->linesize[plane];
225         outrow[plane] = outpic->data[plane] + (y >> hue->vsub) * outpic->linesize[plane];
226     }
227
228     av_image_copy_plane(outrow[0], outpic->linesize[0],
229                         inrow[0],  inpic->linesize[0],
230                         inlink->w, inlink->h);
231
232     process_chrominance(outrow[1], outrow[2], outpic->linesize[1],
233                         inrow[1], inrow[2], inpic->linesize[1],
234                         inlink->w >> hue->hsub, inlink->h >> hue->vsub,
235                         hue->hue_cos, hue->hue_sin);
236
237     return ff_draw_slice(inlink->dst->outputs[0], y, h, slice_dir);
238 }
239
240 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
241                            char *res, int res_len, int flags)
242 {
243     HueContext *hue = ctx->priv;
244     int ret;
245
246     if (!strcmp(cmd, "reinit")) {
247         if ((ret = set_options(ctx, args)) < 0)
248             return ret;
249
250         if (hue->hue_deg != -FLT_MAX)
251             /* Convert angle from degrees to radians */
252             hue->hue = hue->hue_deg * M_PI / 180;
253
254         hue->hue_sin = rint(sin(hue->hue) * (1 << 16) * hue->saturation);
255         hue->hue_cos = rint(cos(hue->hue) * (1 << 16) * hue->saturation);
256     } else
257         return AVERROR(ENOSYS);
258
259     return 0;
260 }
261
262 AVFilter avfilter_vf_hue = {
263     .name        = "hue",
264     .description = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
265
266     .priv_size = sizeof(HueContext),
267
268     .init          = init,
269     .uninit        = uninit,
270     .query_formats = query_formats,
271     .process_command = process_command,
272
273     .inputs = (const AVFilterPad[]) {
274         {
275             .name         = "default",
276             .type         = AVMEDIA_TYPE_VIDEO,
277             .draw_slice   = draw_slice,
278             .config_props = config_props,
279             .min_perms    = AV_PERM_READ,
280         },
281         { .name = NULL }
282     },
283     .outputs = (const AVFilterPad[]) {
284         {
285             .name         = "default",
286             .type         = AVMEDIA_TYPE_VIDEO,
287         },
288         { .name = NULL }
289     },
290     .priv_class = &hue_class,
291 };