FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_procamp_vaapi.c
Date:	2024-11-20 23:03:26

	Total	Coverage
Lines:	82	0.0%
Functions:	4	0.0%
Branches:	22	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include <string.h>
    
      #include "libavutil/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "avfilter.h"
    
      #include "filters.h"
    
      #include "vaapi_vpp.h"
    
      #include "video.h"
    
      // ProcAmp Min/Max/Default Values
    
      #define BRIGHTNESS_MIN     -100.0F
    
      #define BRIGHTNESS_MAX      100.0F
    
      #define BRIGHTNESS_DEFAULT    0.0F
    
      #define CONTRAST_MIN          0.0F
    
      #define CONTRAST_MAX         10.0F
    
      #define CONTRAST_DEFAULT      1.0F
    
      #define HUE_MIN            -180.0F
    
      #define HUE_MAX             180.0F
    
      #define HUE_DEFAULT           0.0F
    
      #define SATURATION_MIN        0.0F
    
      #define SATURATION_MAX       10.0F
    
      #define SATURATION_DEFAULT    1.0F
    
      typedef struct ProcampVAAPIContext {
    
          VAAPIVPPContext vpp_ctx; // must be the first field
    
          float bright;
    
          float hue;
    
          float saturation;
    
          float contrast;
    
      } ProcampVAAPIContext;
    
      ✗
      static float map(float x, float in_min, float in_max, float out_min, float out_max)
    
      {
    
          double slope, output;
    
      ✗
          slope = 1.0 * (out_max - out_min) / (in_max - in_min);
    
      ✗
          output = out_min + slope * (x - in_min);
    
      ✗
          return (float)output;
    
      }
    
      ✗
      static int procamp_vaapi_build_filter_params(AVFilterContext *avctx)
    
      {
    
      ✗
          VAAPIVPPContext *vpp_ctx = avctx->priv;
    
      ✗
          ProcampVAAPIContext *ctx = avctx->priv;
    
          VAStatus vas;
    
          VAProcFilterParameterBufferColorBalance procamp_params[4];
    
          VAProcFilterCapColorBalance procamp_caps[VAProcColorBalanceCount];
    
          int num_caps;
    
      ✗
          int i = 0;
    
      ✗
          memset(&procamp_params, 0, sizeof(procamp_params));
    
      ✗
          memset(&procamp_caps, 0, sizeof(procamp_caps));
    
      ✗
          num_caps = VAProcColorBalanceCount;
    
      ✗
          vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
    
                                           VAProcFilterColorBalance, &procamp_caps, &num_caps);
    
      ✗
          if (vas != VA_STATUS_SUCCESS) {
    
      ✗
              av_log(avctx, AV_LOG_ERROR, "Failed to query procamp "
    
                     "filter caps: %d (%s).\n", vas, vaErrorStr(vas));
    
      ✗
              return AVERROR(EIO);
    
          }
    
          /* brightness */
    
      ✗
          procamp_params[i].type   = VAProcFilterColorBalance;
    
      ✗
          procamp_params[i].attrib = VAProcColorBalanceBrightness;
    
      ✗
          procamp_params[i].value  = map(ctx->bright, BRIGHTNESS_MIN, BRIGHTNESS_MAX,
    
                                         procamp_caps[VAProcColorBalanceBrightness-1].range.min_value,
    
                                         procamp_caps[VAProcColorBalanceBrightness-1].range.max_value);
    
      ✗
          i++;
    
          /* contrast */
    
      ✗
          procamp_params[i].type   = VAProcFilterColorBalance;
    
      ✗
          procamp_params[i].attrib = VAProcColorBalanceContrast;
    
      ✗
          procamp_params[i].value  = map(ctx->contrast, CONTRAST_MIN, CONTRAST_MAX,
    
                                         procamp_caps[VAProcColorBalanceContrast-1].range.min_value,
    
                                         procamp_caps[VAProcColorBalanceContrast-1].range.max_value);
    
      ✗
          i++;
    
          /* hue */
    
      ✗
          procamp_params[i].type   = VAProcFilterColorBalance;
    
      ✗
          procamp_params[i].attrib = VAProcColorBalanceHue;
    
      ✗
          procamp_params[i].value  = map(ctx->hue, HUE_MIN, HUE_MAX,
    
                                         procamp_caps[VAProcColorBalanceHue-1].range.min_value,
    
                                         procamp_caps[VAProcColorBalanceHue-1].range.max_value);
    
      ✗
          i++;
    
          /* saturation */
    
      ✗
          procamp_params[i].type   = VAProcFilterColorBalance;
    
      ✗
          procamp_params[i].attrib = VAProcColorBalanceSaturation;
    
      ✗
          procamp_params[i].value  = map(ctx->saturation, SATURATION_MIN, SATURATION_MAX,
    
                                         procamp_caps[VAProcColorBalanceSaturation-1].range.min_value,
    
                                         procamp_caps[VAProcColorBalanceSaturation-1].range.max_value);
    
      ✗
          i++;
    
      ✗
          return ff_vaapi_vpp_make_param_buffers(avctx,
    
                                                 VAProcFilterParameterBufferType,
    
                                                 &procamp_params,
    
                                                 sizeof(procamp_params[0]),
    
                                                 i);
    
      }
    
      ✗
      static int procamp_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
    
      {
    
      ✗
          AVFilterContext *avctx   = inlink->dst;
    
      ✗
          AVFilterLink *outlink    = avctx->outputs[0];
    
      ✗
          VAAPIVPPContext *vpp_ctx = avctx->priv;
    
      ✗
          AVFrame *output_frame = NULL;
    
          VAProcPipelineParameterBuffer params;
    
          int err;
    
      ✗
          av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
    
      ✗
                 av_get_pix_fmt_name(input_frame->format),
    
      ✗
                 input_frame->width, input_frame->height, input_frame->pts);
    
      ✗
          if (vpp_ctx->passthrough)
    
      ✗
              return ff_filter_frame(outlink, input_frame);
    
      ✗
          if (vpp_ctx->va_context == VA_INVALID_ID)
    
      ✗
              return AVERROR(EINVAL);
    
      ✗
          output_frame = ff_get_video_buffer(outlink, vpp_ctx->output_width,
    
                                             vpp_ctx->output_height);
    
      ✗
          if (!output_frame) {
    
      ✗
              err = AVERROR(ENOMEM);
    
      ✗
              goto fail;
    
          }
    
      ✗
          err = av_frame_copy_props(output_frame, input_frame);
    
      ✗
          if (err < 0)
    
      ✗
              goto fail;
    
      ✗
          err = ff_vaapi_vpp_init_params(avctx, &params,
    
                                         input_frame, output_frame);
    
      ✗
          if (err < 0)
    
      ✗
              goto fail;
    
      ✗
          params.filters     = &vpp_ctx->filter_buffers[0];
    
      ✗
          params.num_filters = 1;
    
      ✗
          err = ff_vaapi_vpp_render_picture(avctx, &params, output_frame);
    
      ✗
          if (err < 0)
    
      ✗
              goto fail;
    
      ✗
          av_frame_free(&input_frame);
    
      ✗
          av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
    
      ✗
                 av_get_pix_fmt_name(output_frame->format),
    
      ✗
                 output_frame->width, output_frame->height, output_frame->pts);
    
      ✗
          return ff_filter_frame(outlink, output_frame);
    
      ✗
      fail:
    
      ✗
          av_frame_free(&input_frame);
    
      ✗
          av_frame_free(&output_frame);
    
      ✗
          return err;
    
      }
    
      ✗
      static av_cold int procamp_vaapi_init(AVFilterContext *avctx)
    
      {
    
      ✗
          VAAPIVPPContext *vpp_ctx = avctx->priv;
    
      ✗
          ProcampVAAPIContext *ctx = avctx->priv;
    
      ✗
          float eps = 1.0e-10f;
    
      ✗
          ff_vaapi_vpp_ctx_init(avctx);
    
      ✗
          vpp_ctx->pipeline_uninit     = ff_vaapi_vpp_pipeline_uninit;
    
      ✗
          vpp_ctx->build_filter_params = procamp_vaapi_build_filter_params;
    
      ✗
          vpp_ctx->output_format       = AV_PIX_FMT_NONE;
    
      ✗
          if (fabs(ctx->saturation - SATURATION_DEFAULT) < eps &&
    
      ✗
              fabs(ctx->bright - BRIGHTNESS_DEFAULT) < eps &&
    
      ✗
              fabs(ctx->contrast - CONTRAST_DEFAULT) < eps &&
    
      ✗
              fabs(ctx->hue - HUE_DEFAULT) < eps)
    
      ✗
              vpp_ctx->passthrough = 1;
    
      ✗
          return 0;
    
      }
    
      #define OFFSET(x) offsetof(ProcampVAAPIContext, x)
    
      #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
    
      static const AVOption procamp_vaapi_options[] = {
    
          { "b", "Output video brightness",
    
            OFFSET(bright),  AV_OPT_TYPE_FLOAT, { .dbl = BRIGHTNESS_DEFAULT }, BRIGHTNESS_MIN, BRIGHTNESS_MAX, .flags = FLAGS },
    
          { "brightness", "Output video brightness",
    
            OFFSET(bright),  AV_OPT_TYPE_FLOAT, { .dbl = BRIGHTNESS_DEFAULT }, BRIGHTNESS_MIN, BRIGHTNESS_MAX, .flags = FLAGS },
    
          { "s", "Output video saturation",
    
            OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = SATURATION_DEFAULT }, SATURATION_MIN, SATURATION_MAX, .flags = FLAGS },
    
          { "saturatio", "Output video saturation",
    
            OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = SATURATION_DEFAULT }, SATURATION_MIN, SATURATION_MAX, .flags = FLAGS },
    
          { "c", "Output video contrast",
    
            OFFSET(contrast),  AV_OPT_TYPE_FLOAT, { .dbl = CONTRAST_DEFAULT }, CONTRAST_MIN, CONTRAST_MAX, .flags = FLAGS },
    
          { "contrast", "Output video contrast",
    
            OFFSET(contrast),  AV_OPT_TYPE_FLOAT, { .dbl = CONTRAST_DEFAULT }, CONTRAST_MIN, CONTRAST_MAX, .flags = FLAGS },
    
          { "h", "Output video hue",
    
            OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = HUE_DEFAULT }, HUE_MIN, HUE_MAX, .flags = FLAGS },
    
          { "hue", "Output video hue",
    
            OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = HUE_DEFAULT }, HUE_MIN, HUE_MAX, .flags = FLAGS },
    
          { NULL },
    
      };
    
      AVFILTER_DEFINE_CLASS(procamp_vaapi);
    
      static const AVFilterPad procamp_vaapi_inputs[] = {
    
          {
    
              .name         = "default",
    
              .type         = AVMEDIA_TYPE_VIDEO,
    
              .filter_frame = &procamp_vaapi_filter_frame,
    
              .config_props = &ff_vaapi_vpp_config_input,
    
          },
    
      };
    
      static const AVFilterPad procamp_vaapi_outputs[] = {
    
          {
    
              .name = "default",
    
              .type = AVMEDIA_TYPE_VIDEO,
    
              .config_props = &ff_vaapi_vpp_config_output,
    
          },
    
      };
    
      const AVFilter ff_vf_procamp_vaapi = {
    
          .name          = "procamp_vaapi",
    
          .description   = NULL_IF_CONFIG_SMALL("ProcAmp (color balance) adjustments for hue, saturation, brightness, contrast"),
    
          .priv_size     = sizeof(ProcampVAAPIContext),
    
          .init          = &procamp_vaapi_init,
    
          .uninit        = &ff_vaapi_vpp_ctx_uninit,
    
          FILTER_INPUTS(procamp_vaapi_inputs),
    
          FILTER_OUTPUTS(procamp_vaapi_outputs),
    
          FILTER_QUERY_FUNC2(&ff_vaapi_vpp_query_formats),
    
          .priv_class    = &procamp_vaapi_class,
    
          .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
    
      };

Line	Exec	Source
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 "filters.h"
25		#include "vaapi_vpp.h"
26		#include "video.h"
27
28		// ProcAmp Min/Max/Default Values
29		#define BRIGHTNESS_MIN -100.0F
30		#define BRIGHTNESS_MAX 100.0F
31		#define BRIGHTNESS_DEFAULT 0.0F
32
33		#define CONTRAST_MIN 0.0F
34		#define CONTRAST_MAX 10.0F
35		#define CONTRAST_DEFAULT 1.0F
36
37		#define HUE_MIN -180.0F
38		#define HUE_MAX 180.0F
39		#define HUE_DEFAULT 0.0F
40
41		#define SATURATION_MIN 0.0F
42		#define SATURATION_MAX 10.0F
43		#define SATURATION_DEFAULT 1.0F
44
45		typedef struct ProcampVAAPIContext {
46		VAAPIVPPContext vpp_ctx; // must be the first field
47
48		float bright;
49		float hue;
50		float saturation;
51		float contrast;
52		} ProcampVAAPIContext;
53
54	✗	static float map(float x, float in_min, float in_max, float out_min, float out_max)
55		{
56		double slope, output;
57
58	✗	slope = 1.0 * (out_max - out_min) / (in_max - in_min);
59	✗	output = out_min + slope * (x - in_min);
60
61	✗	return (float)output;
62		}
63
64	✗	static int procamp_vaapi_build_filter_params(AVFilterContext *avctx)
65		{
66	✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
67	✗	ProcampVAAPIContext *ctx = avctx->priv;
68		VAStatus vas;
69		VAProcFilterParameterBufferColorBalance procamp_params[4];
70		VAProcFilterCapColorBalance procamp_caps[VAProcColorBalanceCount];
71		int num_caps;
72	✗	int i = 0;
73
74	✗	memset(&procamp_params, 0, sizeof(procamp_params));
75	✗	memset(&procamp_caps, 0, sizeof(procamp_caps));
76
77	✗	num_caps = VAProcColorBalanceCount;
78	✗	vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display, vpp_ctx->va_context,
79		VAProcFilterColorBalance, &procamp_caps, &num_caps);
80
81	✗	if (vas != VA_STATUS_SUCCESS) {
82	✗	av_log(avctx, AV_LOG_ERROR, "Failed to query procamp "
83		"filter caps: %d (%s).\n", vas, vaErrorStr(vas));
84	✗	return AVERROR(EIO);
85		}
86
87		/* brightness */
88	✗	procamp_params[i].type = VAProcFilterColorBalance;
89	✗	procamp_params[i].attrib = VAProcColorBalanceBrightness;
90	✗	procamp_params[i].value = map(ctx->bright, BRIGHTNESS_MIN, BRIGHTNESS_MAX,
91		procamp_caps[VAProcColorBalanceBrightness-1].range.min_value,
92		procamp_caps[VAProcColorBalanceBrightness-1].range.max_value);
93	✗	i++;
94
95		/* contrast */
96	✗	procamp_params[i].type = VAProcFilterColorBalance;
97	✗	procamp_params[i].attrib = VAProcColorBalanceContrast;
98	✗	procamp_params[i].value = map(ctx->contrast, CONTRAST_MIN, CONTRAST_MAX,
99		procamp_caps[VAProcColorBalanceContrast-1].range.min_value,
100		procamp_caps[VAProcColorBalanceContrast-1].range.max_value);
101	✗	i++;
102
103		/* hue */
104	✗	procamp_params[i].type = VAProcFilterColorBalance;
105	✗	procamp_params[i].attrib = VAProcColorBalanceHue;
106	✗	procamp_params[i].value = map(ctx->hue, HUE_MIN, HUE_MAX,
107		procamp_caps[VAProcColorBalanceHue-1].range.min_value,
108		procamp_caps[VAProcColorBalanceHue-1].range.max_value);
109	✗	i++;
110
111		/* saturation */
112	✗	procamp_params[i].type = VAProcFilterColorBalance;
113	✗	procamp_params[i].attrib = VAProcColorBalanceSaturation;
114	✗	procamp_params[i].value = map(ctx->saturation, SATURATION_MIN, SATURATION_MAX,
115		procamp_caps[VAProcColorBalanceSaturation-1].range.min_value,
116		procamp_caps[VAProcColorBalanceSaturation-1].range.max_value);
117	✗	i++;
118
119	✗	return ff_vaapi_vpp_make_param_buffers(avctx,
120		VAProcFilterParameterBufferType,
121		&procamp_params,
122		sizeof(procamp_params[0]),
123		i);
124		}
125
126	✗	static int procamp_vaapi_filter_frame(AVFilterLink inlink, AVFrame input_frame)
127		{
128	✗	AVFilterContext *avctx = inlink->dst;
129	✗	AVFilterLink *outlink = avctx->outputs[0];
130	✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
131	✗	AVFrame *output_frame = NULL;
132		VAProcPipelineParameterBuffer params;
133		int err;
134
135	✗	av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
136	✗	av_get_pix_fmt_name(input_frame->format),
137	✗	input_frame->width, input_frame->height, input_frame->pts);
138
139	✗	if (vpp_ctx->passthrough)
140	✗	return ff_filter_frame(outlink, input_frame);
141
142	✗	if (vpp_ctx->va_context == VA_INVALID_ID)
143	✗	return AVERROR(EINVAL);
144
145	✗	output_frame = ff_get_video_buffer(outlink, vpp_ctx->output_width,
146		vpp_ctx->output_height);
147	✗	if (!output_frame) {
148	✗	err = AVERROR(ENOMEM);
149	✗	goto fail;
150		}
151
152	✗	err = av_frame_copy_props(output_frame, input_frame);
153	✗	if (err < 0)
154	✗	goto fail;
155
156	✗	err = ff_vaapi_vpp_init_params(avctx, &params,
157		input_frame, output_frame);
158	✗	if (err < 0)
159	✗	goto fail;
160
161	✗	params.filters = &vpp_ctx->filter_buffers[0];
162	✗	params.num_filters = 1;
163
164	✗	err = ff_vaapi_vpp_render_picture(avctx, &params, output_frame);
165	✗	if (err < 0)
166	✗	goto fail;
167
168	✗	av_frame_free(&input_frame);
169
170	✗	av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
171	✗	av_get_pix_fmt_name(output_frame->format),
172	✗	output_frame->width, output_frame->height, output_frame->pts);
173
174	✗	return ff_filter_frame(outlink, output_frame);
175
176	✗	fail:
177	✗	av_frame_free(&input_frame);
178	✗	av_frame_free(&output_frame);
179	✗	return err;
180		}
181
182	✗	static av_cold int procamp_vaapi_init(AVFilterContext *avctx)
183		{
184	✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
185	✗	ProcampVAAPIContext *ctx = avctx->priv;
186	✗	float eps = 1.0e-10f;
187
188	✗	ff_vaapi_vpp_ctx_init(avctx);
189	✗	vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
190	✗	vpp_ctx->build_filter_params = procamp_vaapi_build_filter_params;
191	✗	vpp_ctx->output_format = AV_PIX_FMT_NONE;
192	✗	if (fabs(ctx->saturation - SATURATION_DEFAULT) < eps &&
193	✗	fabs(ctx->bright - BRIGHTNESS_DEFAULT) < eps &&
194	✗	fabs(ctx->contrast - CONTRAST_DEFAULT) < eps &&
195	✗	fabs(ctx->hue - HUE_DEFAULT) < eps)
196	✗	vpp_ctx->passthrough = 1;
197
198	✗	return 0;
199		}
200
201		#define OFFSET(x) offsetof(ProcampVAAPIContext, x)
202		#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_FILTERING_PARAM)
203		static const AVOption procamp_vaapi_options[] = {
204		{ "b", "Output video brightness",
205		OFFSET(bright), AV_OPT_TYPE_FLOAT, { .dbl = BRIGHTNESS_DEFAULT }, BRIGHTNESS_MIN, BRIGHTNESS_MAX, .flags = FLAGS },
206		{ "brightness", "Output video brightness",
207		OFFSET(bright), AV_OPT_TYPE_FLOAT, { .dbl = BRIGHTNESS_DEFAULT }, BRIGHTNESS_MIN, BRIGHTNESS_MAX, .flags = FLAGS },
208		{ "s", "Output video saturation",
209		OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = SATURATION_DEFAULT }, SATURATION_MIN, SATURATION_MAX, .flags = FLAGS },
210		{ "saturatio", "Output video saturation",
211		OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = SATURATION_DEFAULT }, SATURATION_MIN, SATURATION_MAX, .flags = FLAGS },
212		{ "c", "Output video contrast",
213		OFFSET(contrast), AV_OPT_TYPE_FLOAT, { .dbl = CONTRAST_DEFAULT }, CONTRAST_MIN, CONTRAST_MAX, .flags = FLAGS },
214		{ "contrast", "Output video contrast",
215		OFFSET(contrast), AV_OPT_TYPE_FLOAT, { .dbl = CONTRAST_DEFAULT }, CONTRAST_MIN, CONTRAST_MAX, .flags = FLAGS },
216		{ "h", "Output video hue",
217		OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = HUE_DEFAULT }, HUE_MIN, HUE_MAX, .flags = FLAGS },
218		{ "hue", "Output video hue",
219		OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = HUE_DEFAULT }, HUE_MIN, HUE_MAX, .flags = FLAGS },
220		{ NULL },
221		};
222
223		AVFILTER_DEFINE_CLASS(procamp_vaapi);
224
225		static const AVFilterPad procamp_vaapi_inputs[] = {
226		{
227		.name = "default",
228		.type = AVMEDIA_TYPE_VIDEO,
229		.filter_frame = &procamp_vaapi_filter_frame,
230		.config_props = &ff_vaapi_vpp_config_input,
231		},
232		};
233
234		static const AVFilterPad procamp_vaapi_outputs[] = {
235		{
236		.name = "default",
237		.type = AVMEDIA_TYPE_VIDEO,
238		.config_props = &ff_vaapi_vpp_config_output,
239		},
240		};
241
242		const AVFilter ff_vf_procamp_vaapi = {
243		.name = "procamp_vaapi",
244		.description = NULL_IF_CONFIG_SMALL("ProcAmp (color balance) adjustments for hue, saturation, brightness, contrast"),
245		.priv_size = sizeof(ProcampVAAPIContext),
246		.init = &procamp_vaapi_init,
247		.uninit = &ff_vaapi_vpp_ctx_uninit,
248		FILTER_INPUTS(procamp_vaapi_inputs),
249		FILTER_OUTPUTS(procamp_vaapi_outputs),
250		FILTER_QUERY_FUNC2(&ff_vaapi_vpp_query_formats),
251		.priv_class = &procamp_vaapi_class,
252		.flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
253		};
254

Function (Line)	Call count	Block coverage
map (line 54)	not called	0.0%
procamp_vaapi_build_filter_params (line 64)	not called	0.0%
procamp_vaapi_filter_frame (line 126)	not called	0.0%
procamp_vaapi_init (line 182)	not called	0.0%