FFmpeg  4.3
vf_misc_vaapi.c
Go to the documentation of this file.
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/avassert.h"
21 #include "libavutil/mem.h"
22 #include "libavutil/opt.h"
23 #include "libavutil/pixdesc.h"
24 
25 #include "avfilter.h"
26 #include "formats.h"
27 #include "internal.h"
28 #include "vaapi_vpp.h"
29 
30 // Denoise min/max/default Values
31 #define DENOISE_MIN 0
32 #define DENOISE_MAX 64
33 #define DENOISE_DEFAULT 0
34 
35 // Sharpness min/max/default values
36 #define SHARPNESS_MIN 0
37 #define SHARPNESS_MAX 64
38 #define SHARPNESS_DEFAULT 44
39 
40 typedef struct DenoiseVAAPIContext {
41  VAAPIVPPContext vpp_ctx; // must be the first field
42 
43  int denoise; // enable denoise algo.
45 
46 typedef struct SharpnessVAAPIContext {
47  VAAPIVPPContext vpp_ctx; // must be the first field
48 
49  int sharpness; // enable sharpness.
51 
52 static float map(int x, int in_min, int in_max, float out_min, float out_max)
53 {
54  double slope, output;
55 
56  slope = 1.0 * (out_max - out_min) / (in_max - in_min);
57  output = out_min + slope * (x - in_min);
58 
59  return (float)output;
60 }
61 
63 {
64  VAAPIVPPContext *vpp_ctx = avctx->priv;
65  DenoiseVAAPIContext *ctx = avctx->priv;
66 
67  VAProcFilterCap caps;
68 
69  VAStatus vas;
70  uint32_t num_caps = 1;
71 
72  VAProcFilterParameterBuffer denoise;
73 
74  vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
75  VAProcFilterNoiseReduction,
76  &caps, &num_caps);
77  if (vas != VA_STATUS_SUCCESS) {
78  av_log(avctx, AV_LOG_ERROR, "Failed to query denoise caps "
79  "context: %d (%s).\n", vas, vaErrorStr(vas));
80  return AVERROR(EIO);
81  }
82 
83  denoise.type = VAProcFilterNoiseReduction;
84  denoise.value = map(ctx->denoise, DENOISE_MIN, DENOISE_MAX,
85  caps.range.min_value,
86  caps.range.max_value);
88  VAProcFilterParameterBufferType,
89  &denoise, sizeof(denoise), 1);
90 }
91 
93 {
94  VAAPIVPPContext *vpp_ctx = avctx->priv;
95  SharpnessVAAPIContext *ctx = avctx->priv;
96 
97  VAProcFilterCap caps;
98 
99  VAStatus vas;
100  uint32_t num_caps = 1;
101 
102  VAProcFilterParameterBuffer sharpness;
103 
104  vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
105  VAProcFilterSharpening,
106  &caps, &num_caps);
107  if (vas != VA_STATUS_SUCCESS) {
108  av_log(avctx, AV_LOG_ERROR, "Failed to query sharpness caps "
109  "context: %d (%s).\n", vas, vaErrorStr(vas));
110  return AVERROR(EIO);
111  }
112 
113  sharpness.type = VAProcFilterSharpening;
114  sharpness.value = map(ctx->sharpness,
116  caps.range.min_value,
117  caps.range.max_value);
118  return ff_vaapi_vpp_make_param_buffers(avctx,
119  VAProcFilterParameterBufferType,
120  &sharpness, sizeof(sharpness), 1);
121 }
122 
123 static int misc_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
124 {
125  AVFilterContext *avctx = inlink->dst;
126  AVFilterLink *outlink = avctx->outputs[0];
127  VAAPIVPPContext *vpp_ctx = avctx->priv;
129  VAProcPipelineParameterBuffer params;
130  int err;
131 
132  av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
133  av_get_pix_fmt_name(input_frame->format),
134  input_frame->width, input_frame->height, input_frame->pts);
135 
136  if (vpp_ctx->va_context == VA_INVALID_ID)
137  return AVERROR(EINVAL);
138 
139  output_frame = ff_get_video_buffer(outlink, vpp_ctx->output_width,
140  vpp_ctx->output_height);
141  if (!output_frame) {
142  err = AVERROR(ENOMEM);
143  goto fail;
144  }
145 
146  err = av_frame_copy_props(output_frame, input_frame);
147  if (err < 0)
148  goto fail;
149 
150  err = ff_vaapi_vpp_init_params(avctx, &params,
151  input_frame, output_frame);
152  if (err < 0)
153  goto fail;
154 
155  if (vpp_ctx->nb_filter_buffers) {
156  params.filters = &vpp_ctx->filter_buffers[0];
157  params.num_filters = vpp_ctx->nb_filter_buffers;
158  }
159 
160  err = ff_vaapi_vpp_render_picture(avctx, &params, output_frame);
161  if (err < 0)
162  goto fail;
163 
164  av_frame_free(&input_frame);
165 
166  av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
167  av_get_pix_fmt_name(output_frame->format),
168  output_frame->width, output_frame->height, output_frame->pts);
169 
170  return ff_filter_frame(outlink, output_frame);
171 
172 fail:
173  av_frame_free(&input_frame);
174  av_frame_free(&output_frame);
175  return err;
176 }
177 
179 {
180  VAAPIVPPContext *vpp_ctx = avctx->priv;
181 
182  ff_vaapi_vpp_ctx_init(avctx);
185  vpp_ctx->output_format = AV_PIX_FMT_NONE;
186 
187  return 0;
188 }
189 
191 {
192  VAAPIVPPContext *vpp_ctx = avctx->priv;
193 
194  ff_vaapi_vpp_ctx_init(avctx);
197  vpp_ctx->output_format = AV_PIX_FMT_NONE;
198 
199  return 0;
200 }
201 
202 #define DOFFSET(x) offsetof(DenoiseVAAPIContext, x)
203 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
204 static const AVOption denoise_vaapi_options[] = {
205  { "denoise", "denoise level",
207  { NULL },
208 };
209 
210 #define SOFFSET(x) offsetof(SharpnessVAAPIContext, x)
212  { "sharpness", "sharpness level",
213  SOFFSET(sharpness), AV_OPT_TYPE_INT, { .i64 = SHARPNESS_DEFAULT }, SHARPNESS_MIN, SHARPNESS_MAX, .flags = FLAGS },
214  { NULL },
215 };
216 
217 AVFILTER_DEFINE_CLASS(denoise_vaapi);
218 AVFILTER_DEFINE_CLASS(sharpness_vaapi);
219 
220 static const AVFilterPad misc_vaapi_inputs[] = {
221  {
222  .name = "default",
223  .type = AVMEDIA_TYPE_VIDEO,
224  .filter_frame = &misc_vaapi_filter_frame,
225  .config_props = &ff_vaapi_vpp_config_input,
226  },
227  { NULL }
228 };
229 
230 static const AVFilterPad misc_vaapi_outputs[] = {
231  {
232  .name = "default",
233  .type = AVMEDIA_TYPE_VIDEO,
234  .config_props = &ff_vaapi_vpp_config_output,
235  },
236  { NULL }
237 };
238 
240  .name = "denoise_vaapi",
241  .description = NULL_IF_CONFIG_SMALL("VAAPI VPP for de-noise"),
242  .priv_size = sizeof(DenoiseVAAPIContext),
246  .inputs = misc_vaapi_inputs,
247  .outputs = misc_vaapi_outputs,
248  .priv_class = &denoise_vaapi_class,
249  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
250 };
251 
253  .name = "sharpness_vaapi",
254  .description = NULL_IF_CONFIG_SMALL("VAAPI VPP for sharpness"),
255  .priv_size = sizeof(SharpnessVAAPIContext),
259  .inputs = misc_vaapi_inputs,
260  .outputs = misc_vaapi_outputs,
261  .priv_class = &sharpness_vaapi_class,
262  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
263 };
#define NULL
Definition: coverity.c:32
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: internal.h:365
static const AVFilterPad misc_vaapi_inputs[]
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
int ff_vaapi_vpp_config_input(AVFilterLink *inlink)
Definition: vaapi_vpp.c:70
AVOption.
Definition: opt.h:246
#define SHARPNESS_DEFAULT
Definition: vf_misc_vaapi.c:38
VAAPIVPPContext vpp_ctx
Definition: vf_misc_vaapi.c:41
Main libavfilter public API header.
Memory handling functions.
int ff_vaapi_vpp_config_output(AVFilterLink *outlink)
Definition: vaapi_vpp.c:95
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int nb_filter_buffers
Definition: vaapi_vpp.h:52
static const AVOption sharpness_vaapi_options[]
static const AVFilterPad misc_vaapi_outputs[]
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
#define av_cold
Definition: attributes.h:88
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
#define av_log(a,...)
#define DENOISE_DEFAULT
Definition: vf_misc_vaapi.c:33
A filter pad used for either input or output.
Definition: internal.h:54
#define SOFFSET(x)
#define DOFFSET(x)
int width
Definition: frame.h:358
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define DENOISE_MIN
Definition: vf_misc_vaapi.c:31
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
static av_cold int sharpness_vaapi_init(AVFilterContext *avctx)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVFILTER_DEFINE_CLASS(denoise_vaapi)
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_vaapi_vpp_make_param_buffers(AVFilterContext *avctx, int type, const void *data, size_t size, int count)
Definition: vaapi_vpp.c:563
#define fail()
Definition: checkasm.h:123
static int misc_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
AVFilter ff_vf_sharpness_vaapi
static av_cold int denoise_vaapi_init(AVFilterContext *avctx)
void ff_vaapi_vpp_pipeline_uninit(AVFilterContext *avctx)
Definition: vaapi_vpp.c:44
AVFormatContext * ctx
Definition: movenc.c:48
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
VADisplay display
The VADisplay handle, to be filled by the user.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:373
VABufferID filter_buffers[VAProcFilterCount]
Definition: vaapi_vpp.h:51
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:849
Filter definition.
Definition: avfilter.h:144
#define DENOISE_MAX
Definition: vf_misc_vaapi.c:32
const char * name
Filter name.
Definition: avfilter.h:148
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
VAContextID va_context
Definition: vaapi_vpp.h:41
enum AVPixelFormat output_format
Definition: vaapi_vpp.h:47
AVVAAPIDeviceContext * hwctx
Definition: vaapi_vpp.h:36
int ff_vaapi_vpp_render_picture(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, AVFrame *output_frame)
Definition: vaapi_vpp.c:592
int ff_vaapi_vpp_query_formats(AVFilterContext *avctx)
Definition: vaapi_vpp.c:27
#define SHARPNESS_MAX
Definition: vf_misc_vaapi.c:37
#define SHARPNESS_MIN
Definition: vf_misc_vaapi.c:36
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:244
void ff_vaapi_vpp_ctx_init(AVFilterContext *avctx)
Definition: vaapi_vpp.c:666
static int sharpness_vaapi_build_filter_params(AVFilterContext *avctx)
Definition: vf_misc_vaapi.c:92
VAAPIVPPContext vpp_ctx
Definition: vf_misc_vaapi.c:47
#define FLAGS
static int denoise_vaapi_build_filter_params(AVFilterContext *avctx)
Definition: vf_misc_vaapi.c:62
static const AVOption denoise_vaapi_options[]
An instance of a filter.
Definition: avfilter.h:338
int height
Definition: frame.h:358
static float map(int x, int in_min, int in_max, float out_min, float out_max)
Definition: vf_misc_vaapi.c:52
int ff_vaapi_vpp_init_params(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, const AVFrame *input_frame, AVFrame *output_frame)
Definition: vaapi_vpp.c:515
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2465
int(* build_filter_params)(AVFilterContext *avctx)
Definition: vaapi_vpp.h:54
internal API functions
void(* pipeline_uninit)(AVFilterContext *avctx)
Definition: vaapi_vpp.h:56
void ff_vaapi_vpp_ctx_uninit(AVFilterContext *avctx)
Definition: vaapi_vpp.c:680
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:659
AVFilter ff_vf_denoise_vaapi