lavf/hlsenc: free the old_filname to avoid memory leak
[ffmpeg.git] / libavfilter / vf_colorkey.c
1 /*
2  * Copyright (c) 2015 Timo Rothenpieler <timo@rothenpieler.org>
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 #include "libavutil/opt.h"
22 #include "libavutil/imgutils.h"
23 #include "avfilter.h"
24 #include "formats.h"
25 #include "internal.h"
26 #include "video.h"
27
28 typedef struct ColorkeyContext {
29     const AVClass *class;
30
31     /* color offsets rgba */
32     int co[4];
33
34     uint8_t colorkey_rgba[4];
35     float similarity;
36     float blend;
37
38     int (*do_slice)(AVFilterContext *ctx, void *arg,
39                     int jobnr, int nb_jobs);
40 } ColorkeyContext;
41
42 static uint8_t do_colorkey_pixel(ColorkeyContext *ctx, uint8_t r, uint8_t g, uint8_t b)
43 {
44     int dr = (int)r - ctx->colorkey_rgba[0];
45     int dg = (int)g - ctx->colorkey_rgba[1];
46     int db = (int)b - ctx->colorkey_rgba[2];
47
48     double diff = sqrt((dr * dr + dg * dg + db * db) / (255.0 * 255.0));
49
50     if (ctx->blend > 0.0001) {
51         return av_clipd((diff - ctx->similarity) / ctx->blend, 0.0, 1.0) * 255.0;
52     } else {
53         return (diff > ctx->similarity) ? 255 : 0;
54     }
55 }
56
57 static int do_colorkey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
58 {
59     AVFrame *frame = arg;
60
61     const int slice_start = (frame->height * jobnr) / nb_jobs;
62     const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
63
64     ColorkeyContext *ctx = avctx->priv;
65
66     int o, x, y;
67
68     for (y = slice_start; y < slice_end; ++y) {
69         for (x = 0; x < frame->width; ++x) {
70             o = frame->linesize[0] * y + x * 4;
71
72             frame->data[0][o + ctx->co[3]] =
73                 do_colorkey_pixel(ctx,
74                                   frame->data[0][o + ctx->co[0]],
75                                   frame->data[0][o + ctx->co[1]],
76                                   frame->data[0][o + ctx->co[2]]);
77         }
78     }
79
80     return 0;
81 }
82
83 static int do_colorhold_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
84 {
85     AVFrame *frame = arg;
86
87     const int slice_start = (frame->height * jobnr) / nb_jobs;
88     const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
89
90     ColorkeyContext *ctx = avctx->priv;
91
92     int x, y;
93
94     for (y = slice_start; y < slice_end; ++y) {
95         for (x = 0; x < frame->width; ++x) {
96             int o, t, r, g, b;
97
98             o = frame->linesize[0] * y + x * 4;
99             r = frame->data[0][o + ctx->co[0]];
100             g = frame->data[0][o + ctx->co[1]];
101             b = frame->data[0][o + ctx->co[2]];
102
103             t = do_colorkey_pixel(ctx, r, g, b);
104
105             if (t > 0) {
106                 int a = (r + g + b) / 3;
107                 int rt = 255 - t;
108
109                 frame->data[0][o + ctx->co[0]] = (a * t + r * rt + 127) >> 8;
110                 frame->data[0][o + ctx->co[1]] = (a * t + g * rt + 127) >> 8;
111                 frame->data[0][o + ctx->co[2]] = (a * t + b * rt + 127) >> 8;
112             }
113         }
114     }
115
116     return 0;
117 }
118
119 static av_cold int init_filter(AVFilterContext *avctx)
120 {
121     ColorkeyContext *ctx = avctx->priv;
122
123     if (!strcmp(avctx->filter->name, "colorkey")) {
124         ctx->do_slice = do_colorkey_slice;
125     } else {
126         ctx->do_slice = do_colorhold_slice;
127     }
128
129     return 0;
130 }
131
132 static int filter_frame(AVFilterLink *link, AVFrame *frame)
133 {
134     AVFilterContext *avctx = link->dst;
135     ColorkeyContext *ctx = avctx->priv;
136     int res;
137
138     if (res = av_frame_make_writable(frame))
139         return res;
140
141     if (res = avctx->internal->execute(avctx, ctx->do_slice, frame, NULL, FFMIN(frame->height, ff_filter_get_nb_threads(avctx))))
142         return res;
143
144     return ff_filter_frame(avctx->outputs[0], frame);
145 }
146
147 static av_cold int config_output(AVFilterLink *outlink)
148 {
149     AVFilterContext *avctx = outlink->src;
150     ColorkeyContext *ctx = avctx->priv;
151     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
152     int i;
153
154     outlink->w = avctx->inputs[0]->w;
155     outlink->h = avctx->inputs[0]->h;
156     outlink->time_base = avctx->inputs[0]->time_base;
157
158     for (i = 0; i < 4; ++i)
159         ctx->co[i] = desc->comp[i].offset;
160
161     return 0;
162 }
163
164 static av_cold int query_formats(AVFilterContext *avctx)
165 {
166     static const enum AVPixelFormat pixel_fmts[] = {
167         AV_PIX_FMT_ARGB,
168         AV_PIX_FMT_RGBA,
169         AV_PIX_FMT_ABGR,
170         AV_PIX_FMT_BGRA,
171         AV_PIX_FMT_NONE
172     };
173
174     AVFilterFormats *formats = NULL;
175
176     formats = ff_make_format_list(pixel_fmts);
177     if (!formats)
178         return AVERROR(ENOMEM);
179
180     return ff_set_common_formats(avctx, formats);
181 }
182
183 static const AVFilterPad colorkey_inputs[] = {
184     {
185         .name = "default",
186         .type = AVMEDIA_TYPE_VIDEO,
187         .filter_frame = filter_frame,
188     },
189     { NULL }
190 };
191
192 static const AVFilterPad colorkey_outputs[] = {
193     {
194         .name = "default",
195         .type = AVMEDIA_TYPE_VIDEO,
196         .config_props  = config_output,
197     },
198     { NULL }
199 };
200
201 #define OFFSET(x) offsetof(ColorkeyContext, x)
202 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
203
204 #if CONFIG_COLORKEY_FILTER
205
206 static const AVOption colorkey_options[] = {
207     { "color", "set the colorkey key color", OFFSET(colorkey_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, CHAR_MIN, CHAR_MAX, FLAGS },
208     { "similarity", "set the colorkey similarity value", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.01 }, 0.01, 1.0, FLAGS },
209     { "blend", "set the colorkey key blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS },
210     { NULL }
211 };
212
213 AVFILTER_DEFINE_CLASS(colorkey);
214
215 AVFilter ff_vf_colorkey = {
216     .name          = "colorkey",
217     .description   = NULL_IF_CONFIG_SMALL("Turns a certain color into transparency. Operates on RGB colors."),
218     .priv_size     = sizeof(ColorkeyContext),
219     .priv_class    = &colorkey_class,
220     .query_formats = query_formats,
221     .init          = init_filter,
222     .inputs        = colorkey_inputs,
223     .outputs       = colorkey_outputs,
224     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
225 };
226
227 #endif /* CONFIG_COLORKEY_FILTER */
228 #if CONFIG_COLORHOLD_FILTER
229
230 static const AVOption colorhold_options[] = {
231     { "color", "set the colorhold key color", OFFSET(colorkey_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, CHAR_MIN, CHAR_MAX, FLAGS },
232     { "similarity", "set the colorhold similarity value", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.01 }, 0.01, 1.0, FLAGS },
233     { "blend", "set the colorhold blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS },
234     { NULL }
235 };
236
237 AVFILTER_DEFINE_CLASS(colorhold);
238
239 AVFilter ff_vf_colorhold = {
240     .name          = "colorhold",
241     .description   = NULL_IF_CONFIG_SMALL("Turns a certain color range into gray. Operates on RGB colors."),
242     .priv_size     = sizeof(ColorkeyContext),
243     .priv_class    = &colorhold_class,
244     .query_formats = query_formats,
245     .init          = init_filter,
246     .inputs        = colorkey_inputs,
247     .outputs       = colorkey_outputs,
248     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
249 };
250
251 #endif /* CONFIG_COLORHOLD_FILTER */