1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include <string.h>
19
20 #include "libavutil/opt.h"
21 #include "libavutil/pixdesc.h"
22
23 #include "avfilter.h"
24 #include "formats.h"
25 #include "internal.h"
26 #include "vaapi_vpp.h"
27
28 // Denoise min/max/default Values
29 #define DENOISE_MIN 0
30 #define DENOISE_MAX 64
31 #define DENOISE_DEFAULT 0
32
33 // Sharpness min/max/default values
34 #define SHARPNESS_MIN 0
35 #define SHARPNESS_MAX 64
36 #define SHARPNESS_DEFAULT 44
37
38 typedef struct DenoiseVAAPIContext {
39 VAAPIVPPContext vpp_ctx; // must be the first field
40
41 int denoise; // enable denoise algo.
42 } DenoiseVAAPIContext;
43
44 typedef struct SharpnessVAAPIContext {
45 VAAPIVPPContext vpp_ctx; // must be the first field
46
47 int sharpness; // enable sharpness.
48 } SharpnessVAAPIContext;
49
map(int x,int in_min,int in_max,float out_min,float out_max)50 static float map(int x, int in_min, int in_max, float out_min, float out_max)
51 {
52 double slope, output;
53
54 slope = 1.0 * (out_max - out_min) / (in_max - in_min);
55 output = out_min + slope * (x - in_min);
56
57 return (float)output;
58 }
59
denoise_vaapi_build_filter_params(AVFilterContext * avctx)60 static int denoise_vaapi_build_filter_params(AVFilterContext *avctx)
61 {
62 VAAPIVPPContext *vpp_ctx = avctx->priv;
63 DenoiseVAAPIContext *ctx = avctx->priv;
64
65 VAProcFilterCap caps;
66
67 VAStatus vas;
68 uint32_t num_caps = 1;
69
70 VAProcFilterParameterBuffer denoise;
71
72 vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
73 VAProcFilterNoiseReduction,
74 &caps, &num_caps);
75 if (vas != VA_STATUS_SUCCESS) {
76 av_log(avctx, AV_LOG_ERROR, "Failed to query denoise caps "
77 "context: %d (%s).\n", vas, vaErrorStr(vas));
78 return AVERROR(EIO);
79 }
80
81 denoise.type = VAProcFilterNoiseReduction;
82 denoise.value = map(ctx->denoise, DENOISE_MIN, DENOISE_MAX,
83 caps.range.min_value,
84 caps.range.max_value);
85 return ff_vaapi_vpp_make_param_buffers(avctx,
86 VAProcFilterParameterBufferType,
87 &denoise, sizeof(denoise), 1);
88 }
89
sharpness_vaapi_build_filter_params(AVFilterContext * avctx)90 static int sharpness_vaapi_build_filter_params(AVFilterContext *avctx)
91 {
92 VAAPIVPPContext *vpp_ctx = avctx->priv;
93 SharpnessVAAPIContext *ctx = avctx->priv;
94
95 VAProcFilterCap caps;
96
97 VAStatus vas;
98 uint32_t num_caps = 1;
99
100 VAProcFilterParameterBuffer sharpness;
101
102 vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
103 VAProcFilterSharpening,
104 &caps, &num_caps);
105 if (vas != VA_STATUS_SUCCESS) {
106 av_log(avctx, AV_LOG_ERROR, "Failed to query sharpness caps "
107 "context: %d (%s).\n", vas, vaErrorStr(vas));
108 return AVERROR(EIO);
109 }
110
111 sharpness.type = VAProcFilterSharpening;
112 sharpness.value = map(ctx->sharpness,
113 SHARPNESS_MIN, SHARPNESS_MAX,
114 caps.range.min_value,
115 caps.range.max_value);
116 return ff_vaapi_vpp_make_param_buffers(avctx,
117 VAProcFilterParameterBufferType,
118 &sharpness, sizeof(sharpness), 1);
119 }
120
misc_vaapi_filter_frame(AVFilterLink * inlink,AVFrame * input_frame)121 static int misc_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
122 {
123 AVFilterContext *avctx = inlink->dst;
124 AVFilterLink *outlink = avctx->outputs[0];
125 VAAPIVPPContext *vpp_ctx = avctx->priv;
126 AVFrame *output_frame = NULL;
127 VAProcPipelineParameterBuffer params;
128 int err;
129
130 av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
131 av_get_pix_fmt_name(input_frame->format),
132 input_frame->width, input_frame->height, input_frame->pts);
133
134 if (vpp_ctx->va_context == VA_INVALID_ID)
135 return AVERROR(EINVAL);
136
137 output_frame = ff_get_video_buffer(outlink, vpp_ctx->output_width,
138 vpp_ctx->output_height);
139 if (!output_frame) {
140 err = AVERROR(ENOMEM);
141 goto fail;
142 }
143
144 err = av_frame_copy_props(output_frame, input_frame);
145 if (err < 0)
146 goto fail;
147
148 err = ff_vaapi_vpp_init_params(avctx, ¶ms,
149 input_frame, output_frame);
150 if (err < 0)
151 goto fail;
152
153 if (vpp_ctx->nb_filter_buffers) {
154 params.filters = &vpp_ctx->filter_buffers[0];
155 params.num_filters = vpp_ctx->nb_filter_buffers;
156 }
157
158 err = ff_vaapi_vpp_render_picture(avctx, ¶ms, output_frame);
159 if (err < 0)
160 goto fail;
161
162 av_frame_free(&input_frame);
163
164 av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
165 av_get_pix_fmt_name(output_frame->format),
166 output_frame->width, output_frame->height, output_frame->pts);
167
168 return ff_filter_frame(outlink, output_frame);
169
170 fail:
171 av_frame_free(&input_frame);
172 av_frame_free(&output_frame);
173 return err;
174 }
175
denoise_vaapi_init(AVFilterContext * avctx)176 static av_cold int denoise_vaapi_init(AVFilterContext *avctx)
177 {
178 VAAPIVPPContext *vpp_ctx = avctx->priv;
179
180 ff_vaapi_vpp_ctx_init(avctx);
181 vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
182 vpp_ctx->build_filter_params = denoise_vaapi_build_filter_params;
183 vpp_ctx->output_format = AV_PIX_FMT_NONE;
184
185 return 0;
186 }
187
sharpness_vaapi_init(AVFilterContext * avctx)188 static av_cold int sharpness_vaapi_init(AVFilterContext *avctx)
189 {
190 VAAPIVPPContext *vpp_ctx = avctx->priv;
191
192 ff_vaapi_vpp_ctx_init(avctx);
193 vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
194 vpp_ctx->build_filter_params = sharpness_vaapi_build_filter_params;
195 vpp_ctx->output_format = AV_PIX_FMT_NONE;
196
197 return 0;
198 }
199
200 #define DOFFSET(x) offsetof(DenoiseVAAPIContext, x)
201 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
202 static const AVOption denoise_vaapi_options[] = {
203 { "denoise", "denoise level",
204 DOFFSET(denoise), AV_OPT_TYPE_INT, { .i64 = DENOISE_DEFAULT }, DENOISE_MIN, DENOISE_MAX, .flags = FLAGS },
205 { NULL },
206 };
207
208 #define SOFFSET(x) offsetof(SharpnessVAAPIContext, x)
209 static const AVOption sharpness_vaapi_options[] = {
210 { "sharpness", "sharpness level",
211 SOFFSET(sharpness), AV_OPT_TYPE_INT, { .i64 = SHARPNESS_DEFAULT }, SHARPNESS_MIN, SHARPNESS_MAX, .flags = FLAGS },
212 { NULL },
213 };
214
215 AVFILTER_DEFINE_CLASS(denoise_vaapi);
216 AVFILTER_DEFINE_CLASS(sharpness_vaapi);
217
218 static const AVFilterPad misc_vaapi_inputs[] = {
219 {
220 .name = "default",
221 .type = AVMEDIA_TYPE_VIDEO,
222 .filter_frame = &misc_vaapi_filter_frame,
223 .config_props = &ff_vaapi_vpp_config_input,
224 },
225 };
226
227 static const AVFilterPad misc_vaapi_outputs[] = {
228 {
229 .name = "default",
230 .type = AVMEDIA_TYPE_VIDEO,
231 .config_props = &ff_vaapi_vpp_config_output,
232 },
233 };
234
235 const AVFilter ff_vf_denoise_vaapi = {
236 .name = "denoise_vaapi",
237 .description = NULL_IF_CONFIG_SMALL("VAAPI VPP for de-noise"),
238 .priv_size = sizeof(DenoiseVAAPIContext),
239 .init = &denoise_vaapi_init,
240 .uninit = &ff_vaapi_vpp_ctx_uninit,
241 FILTER_INPUTS(misc_vaapi_inputs),
242 FILTER_OUTPUTS(misc_vaapi_outputs),
243 FILTER_QUERY_FUNC(&ff_vaapi_vpp_query_formats),
244 .priv_class = &denoise_vaapi_class,
245 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
246 };
247
248 const AVFilter ff_vf_sharpness_vaapi = {
249 .name = "sharpness_vaapi",
250 .description = NULL_IF_CONFIG_SMALL("VAAPI VPP for sharpness"),
251 .priv_size = sizeof(SharpnessVAAPIContext),
252 .init = &sharpness_vaapi_init,
253 .uninit = &ff_vaapi_vpp_ctx_uninit,
254 FILTER_INPUTS(misc_vaapi_inputs),
255 FILTER_OUTPUTS(misc_vaapi_outputs),
256 FILTER_QUERY_FUNC(&ff_vaapi_vpp_query_formats),
257 .priv_class = &sharpness_vaapi_class,
258 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
259 };
260