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 |
|
65536 |
static uint8_t do_colorkey_pixel(ColorkeyContext *ctx, uint8_t r, uint8_t g, uint8_t b) |
43 |
|
|
{ |
44 |
|
65536 |
int dr = (int)r - ctx->colorkey_rgba[0]; |
45 |
|
65536 |
int dg = (int)g - ctx->colorkey_rgba[1]; |
46 |
|
65536 |
int db = (int)b - ctx->colorkey_rgba[2]; |
47 |
|
|
|
48 |
|
65536 |
double diff = sqrt((dr * dr + dg * dg + db * db) / (255.0 * 255.0 * 3.0)); |
49 |
|
|
|
50 |
✓✗ |
65536 |
if (ctx->blend > 0.0001) { |
51 |
|
65536 |
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 |
|
9 |
static int do_colorkey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs) |
58 |
|
|
{ |
59 |
|
9 |
AVFrame *frame = arg; |
60 |
|
|
|
61 |
|
9 |
const int slice_start = (frame->height * jobnr) / nb_jobs; |
62 |
|
9 |
const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs; |
63 |
|
|
|
64 |
|
9 |
ColorkeyContext *ctx = avctx->priv; |
65 |
|
|
|
66 |
|
|
int o, x, y; |
67 |
|
|
|
68 |
✓✓ |
265 |
for (y = slice_start; y < slice_end; ++y) { |
69 |
✓✓ |
65792 |
for (x = 0; x < frame->width; ++x) { |
70 |
|
65536 |
o = frame->linesize[0] * y + x * 4; |
71 |
|
|
|
72 |
|
65536 |
frame->data[0][o + ctx->co[3]] = |
73 |
|
65536 |
do_colorkey_pixel(ctx, |
74 |
|
65536 |
frame->data[0][o + ctx->co[0]], |
75 |
|
65536 |
frame->data[0][o + ctx->co[1]], |
76 |
|
65536 |
frame->data[0][o + ctx->co[2]]); |
77 |
|
|
} |
78 |
|
|
} |
79 |
|
|
|
80 |
|
9 |
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 |
|
2 |
static av_cold int init_filter(AVFilterContext *avctx) |
120 |
|
|
{ |
121 |
|
2 |
ColorkeyContext *ctx = avctx->priv; |
122 |
|
|
|
123 |
✓✗ |
2 |
if (!strcmp(avctx->filter->name, "colorkey")) { |
124 |
|
2 |
ctx->do_slice = do_colorkey_slice; |
125 |
|
|
} else { |
126 |
|
|
ctx->do_slice = do_colorhold_slice; |
127 |
|
|
} |
128 |
|
|
|
129 |
|
2 |
return 0; |
130 |
|
|
} |
131 |
|
|
|
132 |
|
1 |
static int filter_frame(AVFilterLink *link, AVFrame *frame) |
133 |
|
|
{ |
134 |
|
1 |
AVFilterContext *avctx = link->dst; |
135 |
|
1 |
ColorkeyContext *ctx = avctx->priv; |
136 |
|
|
int res; |
137 |
|
|
|
138 |
✗✓ |
1 |
if (res = av_frame_make_writable(frame)) |
139 |
|
|
return res; |
140 |
|
|
|
141 |
✓✗✗✓
|
1 |
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 |
|
1 |
return ff_filter_frame(avctx->outputs[0], frame); |
145 |
|
|
} |
146 |
|
|
|
147 |
|
1 |
static av_cold int config_output(AVFilterLink *outlink) |
148 |
|
|
{ |
149 |
|
1 |
AVFilterContext *avctx = outlink->src; |
150 |
|
1 |
ColorkeyContext *ctx = avctx->priv; |
151 |
|
1 |
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format); |
152 |
|
|
int i; |
153 |
|
|
|
154 |
|
1 |
outlink->w = avctx->inputs[0]->w; |
155 |
|
1 |
outlink->h = avctx->inputs[0]->h; |
156 |
|
1 |
outlink->time_base = avctx->inputs[0]->time_base; |
157 |
|
|
|
158 |
✓✓ |
5 |
for (i = 0; i < 4; ++i) |
159 |
|
4 |
ctx->co[i] = desc->comp[i].offset; |
160 |
|
|
|
161 |
|
1 |
return 0; |
162 |
|
|
} |
163 |
|
|
|
164 |
|
1 |
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 |
|
1 |
AVFilterFormats *formats = NULL; |
175 |
|
|
|
176 |
|
1 |
formats = ff_make_format_list(pixel_fmts); |
177 |
✗✓ |
1 |
if (!formats) |
178 |
|
|
return AVERROR(ENOMEM); |
179 |
|
|
|
180 |
|
1 |
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|AV_OPT_FLAG_RUNTIME_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" }, 0, 0, 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 |
|
|
.process_command = ff_filter_process_command, |
226 |
|
|
}; |
227 |
|
|
|
228 |
|
|
#endif /* CONFIG_COLORKEY_FILTER */ |
229 |
|
|
#if CONFIG_COLORHOLD_FILTER |
230 |
|
|
|
231 |
|
|
static const AVOption colorhold_options[] = { |
232 |
|
|
{ "color", "set the colorhold key color", OFFSET(colorkey_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, 0, 0, FLAGS }, |
233 |
|
|
{ "similarity", "set the colorhold similarity value", OFFSET(similarity), AV_OPT_TYPE_FLOAT, { .dbl = 0.01 }, 0.01, 1.0, FLAGS }, |
234 |
|
|
{ "blend", "set the colorhold blend value", OFFSET(blend), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, 0.0, 1.0, FLAGS }, |
235 |
|
|
{ NULL } |
236 |
|
|
}; |
237 |
|
|
|
238 |
|
|
AVFILTER_DEFINE_CLASS(colorhold); |
239 |
|
|
|
240 |
|
|
AVFilter ff_vf_colorhold = { |
241 |
|
|
.name = "colorhold", |
242 |
|
|
.description = NULL_IF_CONFIG_SMALL("Turns a certain color range into gray. Operates on RGB colors."), |
243 |
|
|
.priv_size = sizeof(ColorkeyContext), |
244 |
|
|
.priv_class = &colorhold_class, |
245 |
|
|
.query_formats = query_formats, |
246 |
|
|
.init = init_filter, |
247 |
|
|
.inputs = colorkey_inputs, |
248 |
|
|
.outputs = colorkey_outputs, |
249 |
|
|
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS, |
250 |
|
|
.process_command = ff_filter_process_command, |
251 |
|
|
}; |
252 |
|
|
|
253 |
|
|
#endif /* CONFIG_COLORHOLD_FILTER */ |