FFmpeg
vf_hue.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
3  * Copyright (c) 2012 Jeremy Tran
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Apply a hue/saturation filter to the input video
25  * Ported from MPlayer libmpcodecs/vf_hue.c.
26  */
27 
28 #include <float.h>
29 #include "libavutil/eval.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 
34 #include "avfilter.h"
35 #include "internal.h"
36 #include "video.h"
37 
38 #define SAT_MIN_VAL -10
39 #define SAT_MAX_VAL 10
40 
41 static const char *const var_names[] = {
42  "n", // frame count
43  "pts", // presentation timestamp expressed in AV_TIME_BASE units
44  "r", // frame rate
45  "t", // timestamp expressed in seconds
46  "tb", // timebase
47  NULL
48 };
49 
50 enum var_name {
57 };
58 
59 typedef struct HueContext {
60  const AVClass *class;
61  float hue_deg; /* hue expressed in degrees */
62  float hue; /* hue expressed in radians */
63  char *hue_deg_expr;
64  char *hue_expr;
67  float saturation;
70  float brightness;
73  int hsub;
74  int vsub;
75  int is_first;
78  double var_values[VAR_NB];
79  uint8_t lut_l[256];
80  uint8_t lut_u[256][256];
81  uint8_t lut_v[256][256];
82  uint16_t lut_l16[65536];
83  uint16_t lut_u10[1024][1024];
84  uint16_t lut_v10[1024][1024];
85 } HueContext;
86 
87 #define OFFSET(x) offsetof(HueContext, x)
88 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
89 static const AVOption hue_options[] = {
90  { "h", "set the hue angle degrees expression", OFFSET(hue_deg_expr), AV_OPT_TYPE_STRING,
91  { .str = NULL }, .flags = FLAGS },
92  { "s", "set the saturation expression", OFFSET(saturation_expr), AV_OPT_TYPE_STRING,
93  { .str = "1" }, .flags = FLAGS },
94  { "H", "set the hue angle radians expression", OFFSET(hue_expr), AV_OPT_TYPE_STRING,
95  { .str = NULL }, .flags = FLAGS },
96  { "b", "set the brightness expression", OFFSET(brightness_expr), AV_OPT_TYPE_STRING,
97  { .str = "0" }, .flags = FLAGS },
98  { NULL }
99 };
100 
102 
103 static inline void compute_sin_and_cos(HueContext *hue)
104 {
105  /*
106  * Scale the value to the norm of the resulting (U,V) vector, that is
107  * the saturation.
108  * This will be useful in the apply_lut function.
109  */
110  hue->hue_sin = lrint(sin(hue->hue) * (1 << 16) * hue->saturation);
111  hue->hue_cos = lrint(cos(hue->hue) * (1 << 16) * hue->saturation);
112 }
113 
114 static inline void create_luma_lut(HueContext *h)
115 {
116  const float b = h->brightness;
117  int i;
118 
119  for (i = 0; i < 256; i++) {
120  h->lut_l[i] = av_clip_uint8(i + b * 25.5);
121  }
122  for (i = 0; i < 65536; i++) {
123  h->lut_l16[i] = av_clip_uintp2(i + b * 102.4, 10);
124  }
125 }
126 
127 static inline void create_chrominance_lut(HueContext *h, const int32_t c,
128  const int32_t s)
129 {
130  int32_t i, j, u, v, new_u, new_v;
131 
132  /*
133  * If we consider U and V as the components of a 2D vector then its angle
134  * is the hue and the norm is the saturation
135  */
136  for (i = 0; i < 256; i++) {
137  for (j = 0; j < 256; j++) {
138  /* Normalize the components from range [16;240] to [-112;112] */
139  u = i - 128;
140  v = j - 128;
141  /*
142  * Apply the rotation of the vector : (c * u) - (s * v)
143  * (s * u) + (c * v)
144  * De-normalize the components (without forgetting to scale 128
145  * by << 16)
146  * Finally scale back the result by >> 16
147  */
148  new_u = ((c * u) - (s * v) + (1 << 15) + (128 << 16)) >> 16;
149  new_v = ((s * u) + (c * v) + (1 << 15) + (128 << 16)) >> 16;
150 
151  /* Prevent a potential overflow */
152  h->lut_u[i][j] = av_clip_uint8(new_u);
153  h->lut_v[i][j] = av_clip_uint8(new_v);
154  }
155  }
156  for (i = 0; i < 1024; i++) {
157  for (j = 0; j < 1024; j++) {
158  u = i - 512;
159  v = j - 512;
160  /*
161  * Apply the rotation of the vector : (c * u) - (s * v)
162  * (s * u) + (c * v)
163  * De-normalize the components (without forgetting to scale 512
164  * by << 16)
165  * Finally scale back the result by >> 16
166  */
167  new_u = ((c * u) - (s * v) + (1 << 15) + (512 << 16)) >> 16;
168  new_v = ((s * u) + (c * v) + (1 << 15) + (512 << 16)) >> 16;
169 
170  /* Prevent a potential overflow */
171  h->lut_u10[i][j] = av_clip_uintp2(new_u, 10);
172  h->lut_v10[i][j] = av_clip_uintp2(new_v, 10);
173  }
174  }
175 }
176 
177 static int set_expr(AVExpr **pexpr_ptr, char **expr_ptr,
178  const char *expr, const char *option, void *log_ctx)
179 {
180  int ret;
181  AVExpr *new_pexpr;
182  char *new_expr;
183 
184  new_expr = av_strdup(expr);
185  if (!new_expr)
186  return AVERROR(ENOMEM);
187  ret = av_expr_parse(&new_pexpr, expr, var_names,
188  NULL, NULL, NULL, NULL, 0, log_ctx);
189  if (ret < 0) {
190  av_log(log_ctx, AV_LOG_ERROR,
191  "Error when evaluating the expression '%s' for %s\n",
192  expr, option);
193  av_free(new_expr);
194  return ret;
195  }
196 
197  if (*pexpr_ptr)
198  av_expr_free(*pexpr_ptr);
199  *pexpr_ptr = new_pexpr;
200  av_freep(expr_ptr);
201  *expr_ptr = new_expr;
202 
203  return 0;
204 }
205 
207 {
208  HueContext *hue = ctx->priv;
209  int ret;
210 
211  if (hue->hue_expr && hue->hue_deg_expr) {
213  "H and h options are incompatible and cannot be specified "
214  "at the same time\n");
215  return AVERROR(EINVAL);
216  }
217 
218 #define SET_EXPR(expr, option) \
219  if (hue->expr##_expr) do { \
220  ret = set_expr(&hue->expr##_pexpr, &hue->expr##_expr, \
221  hue->expr##_expr, option, ctx); \
222  if (ret < 0) \
223  return ret; \
224  } while (0)
225  SET_EXPR(brightness, "b");
226  SET_EXPR(saturation, "s");
227  SET_EXPR(hue_deg, "h");
228  SET_EXPR(hue, "H");
229 #undef SET_EXPR
230 
232  "H_expr:%s h_deg_expr:%s s_expr:%s b_expr:%s\n",
233  hue->hue_expr, hue->hue_deg_expr, hue->saturation_expr, hue->brightness_expr);
234  compute_sin_and_cos(hue);
235  hue->is_first = 1;
236 
237  return 0;
238 }
239 
241 {
242  HueContext *hue = ctx->priv;
243 
246  av_expr_free(hue->hue_pexpr);
248 }
249 
250 static const enum AVPixelFormat pix_fmts[] = {
262 };
263 
265 {
266  HueContext *hue = inlink->dst->priv;
268 
269  hue->hsub = desc->log2_chroma_w;
270  hue->vsub = desc->log2_chroma_h;
271 
272  hue->var_values[VAR_N] = 0;
273  hue->var_values[VAR_TB] = av_q2d(inlink->time_base);
274  hue->var_values[VAR_R] = inlink->frame_rate.num == 0 || inlink->frame_rate.den == 0 ?
275  NAN : av_q2d(inlink->frame_rate);
276 
277  return 0;
278 }
279 
281  uint8_t *ldst, const int dst_linesize,
282  uint8_t *lsrc, const int src_linesize,
283  int w, int h)
284 {
285  int i;
286 
287  while (h--) {
288  for (i = 0; i < w; i++)
289  ldst[i] = s->lut_l[lsrc[i]];
290 
291  lsrc += src_linesize;
292  ldst += dst_linesize;
293  }
294 }
295 
297  uint16_t *ldst, const int dst_linesize,
298  uint16_t *lsrc, const int src_linesize,
299  int w, int h)
300 {
301  int i;
302 
303  while (h--) {
304  for (i = 0; i < w; i++)
305  ldst[i] = s->lut_l16[lsrc[i]];
306 
307  lsrc += src_linesize;
308  ldst += dst_linesize;
309  }
310 }
311 
312 static void apply_lut(HueContext *s,
313  uint8_t *udst, uint8_t *vdst, const int dst_linesize,
314  uint8_t *usrc, uint8_t *vsrc, const int src_linesize,
315  int w, int h)
316 {
317  int i;
318 
319  while (h--) {
320  for (i = 0; i < w; i++) {
321  const int u = usrc[i];
322  const int v = vsrc[i];
323 
324  udst[i] = s->lut_u[u][v];
325  vdst[i] = s->lut_v[u][v];
326  }
327 
328  usrc += src_linesize;
329  vsrc += src_linesize;
330  udst += dst_linesize;
331  vdst += dst_linesize;
332  }
333 }
334 
335 static void apply_lut10(HueContext *s,
336  uint16_t *udst, uint16_t *vdst, const int dst_linesize,
337  uint16_t *usrc, uint16_t *vsrc, const int src_linesize,
338  int w, int h)
339 {
340  int i;
341 
342  while (h--) {
343  for (i = 0; i < w; i++) {
344  const int u = av_clip_uintp2(usrc[i], 10);
345  const int v = av_clip_uintp2(vsrc[i], 10);
346 
347  udst[i] = s->lut_u10[u][v];
348  vdst[i] = s->lut_v10[u][v];
349  }
350 
351  usrc += src_linesize;
352  vsrc += src_linesize;
353  udst += dst_linesize;
354  vdst += dst_linesize;
355  }
356 }
357 
359 {
360  HueContext *hue = inlink->dst->priv;
361  AVFilterLink *outlink = inlink->dst->outputs[0];
362  AVFrame *outpic;
363  const int32_t old_hue_sin = hue->hue_sin, old_hue_cos = hue->hue_cos;
364  const float old_brightness = hue->brightness;
365  int direct = 0;
367  const int bps = desc->comp[0].depth > 8 ? 2 : 1;
368 
370  direct = 1;
371  outpic = inpic;
372  } else {
373  outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
374  if (!outpic) {
376  return AVERROR(ENOMEM);
377  }
378  av_frame_copy_props(outpic, inpic);
379  }
380 
381  hue->var_values[VAR_N] = inlink->frame_count_out;
382  hue->var_values[VAR_T] = TS2T(inpic->pts, inlink->time_base);
383  hue->var_values[VAR_PTS] = TS2D(inpic->pts);
384 
385  if (hue->saturation_expr) {
387 
388  if (hue->saturation < SAT_MIN_VAL || hue->saturation > SAT_MAX_VAL) {
391  "Saturation value not in range [%d,%d]: clipping value to %0.1f\n",
393  }
394  }
395 
396  if (hue->brightness_expr) {
398 
399  if (hue->brightness < -10 || hue->brightness > 10) {
400  hue->brightness = av_clipf(hue->brightness, -10, 10);
402  "Brightness value not in range [%d,%d]: clipping value to %0.1f\n",
403  -10, 10, hue->brightness);
404  }
405  }
406 
407  if (hue->hue_deg_expr) {
408  hue->hue_deg = av_expr_eval(hue->hue_deg_pexpr, hue->var_values, NULL);
409  hue->hue = hue->hue_deg * M_PI / 180;
410  } else if (hue->hue_expr) {
411  hue->hue = av_expr_eval(hue->hue_pexpr, hue->var_values, NULL);
412  hue->hue_deg = hue->hue * 180 / M_PI;
413  }
414 
415  av_log(inlink->dst, AV_LOG_DEBUG,
416  "H:%0.1f*PI h:%0.1f s:%0.1f b:%0.f t:%0.1f n:%d\n",
417  hue->hue/M_PI, hue->hue_deg, hue->saturation, hue->brightness,
418  hue->var_values[VAR_T], (int)hue->var_values[VAR_N]);
419 
420  compute_sin_and_cos(hue);
421  if (hue->is_first || (old_hue_sin != hue->hue_sin || old_hue_cos != hue->hue_cos))
422  create_chrominance_lut(hue, hue->hue_cos, hue->hue_sin);
423 
424  if (hue->is_first || (old_brightness != hue->brightness && hue->brightness))
425  create_luma_lut(hue);
426 
427  if (!direct) {
428  if (!hue->brightness)
429  av_image_copy_plane(outpic->data[0], outpic->linesize[0],
430  inpic->data[0], inpic->linesize[0],
431  inlink->w * bps, inlink->h);
432  if (inpic->data[3])
433  av_image_copy_plane(outpic->data[3], outpic->linesize[3],
434  inpic->data[3], inpic->linesize[3],
435  inlink->w * bps, inlink->h);
436  }
437 
438  if (bps > 1) {
439  apply_lut10(hue, (uint16_t*)outpic->data[1], (uint16_t*)outpic->data[2], outpic->linesize[1]/2,
440  (uint16_t*) inpic->data[1], (uint16_t*) inpic->data[2], inpic->linesize[1]/2,
441  AV_CEIL_RSHIFT(inlink->w, hue->hsub),
442  AV_CEIL_RSHIFT(inlink->h, hue->vsub));
443  if (hue->brightness)
444  apply_luma_lut10(hue, (uint16_t*)outpic->data[0], outpic->linesize[0]/2,
445  (uint16_t*) inpic->data[0], inpic->linesize[0]/2, inlink->w, inlink->h);
446  } else {
447  apply_lut(hue, outpic->data[1], outpic->data[2], outpic->linesize[1],
448  inpic->data[1], inpic->data[2], inpic->linesize[1],
449  AV_CEIL_RSHIFT(inlink->w, hue->hsub),
450  AV_CEIL_RSHIFT(inlink->h, hue->vsub));
451  if (hue->brightness)
452  apply_luma_lut(hue, outpic->data[0], outpic->linesize[0],
453  inpic->data[0], inpic->linesize[0], inlink->w, inlink->h);
454  }
455 
456  if (!direct)
458 
459  hue->is_first = 0;
460  return ff_filter_frame(outlink, outpic);
461 }
462 
463 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
464  char *res, int res_len, int flags)
465 {
466  HueContext *hue = ctx->priv;
467  int ret;
468 
469 #define SET_EXPR(expr, option) \
470  do { \
471  ret = set_expr(&hue->expr##_pexpr, &hue->expr##_expr, \
472  args, option, ctx); \
473  if (ret < 0) \
474  return ret; \
475  } while (0)
476 
477  if (!strcmp(cmd, "h")) {
478  SET_EXPR(hue_deg, "h");
479  av_freep(&hue->hue_expr);
480  } else if (!strcmp(cmd, "H")) {
481  SET_EXPR(hue, "H");
482  av_freep(&hue->hue_deg_expr);
483  } else if (!strcmp(cmd, "s")) {
484  SET_EXPR(saturation, "s");
485  } else if (!strcmp(cmd, "b")) {
486  SET_EXPR(brightness, "b");
487  } else
488  return AVERROR(ENOSYS);
489 
490  return 0;
491 }
492 
493 static const AVFilterPad hue_inputs[] = {
494  {
495  .name = "default",
496  .type = AVMEDIA_TYPE_VIDEO,
497  .filter_frame = filter_frame,
498  .config_props = config_props,
499  },
500 };
501 
503  .name = "hue",
504  .description = NULL_IF_CONFIG_SMALL("Adjust the hue and saturation of the input video."),
505  .priv_size = sizeof(HueContext),
506  .init = init,
507  .uninit = uninit,
512  .priv_class = &hue_class,
514 };
HueContext::hue_expr
char * hue_expr
Definition: vf_hue.c:64
FLAGS
#define FLAGS
Definition: vf_hue.c:88
HueContext::saturation_expr
char * saturation_expr
Definition: vf_hue.c:68
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
HueContext::hue_cos
int32_t hue_cos
Definition: vf_hue.c:77
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
HueContext::hue_sin
int32_t hue_sin
Definition: vf_hue.c:76
HueContext::var_values
double var_values[VAR_NB]
Definition: vf_hue.c:78
av_clip
#define av_clip
Definition: common.h:98
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
var_name
var_name
Definition: noise.c:46
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:250
HueContext::vsub
int vsub
Definition: vf_hue.c:74
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:122
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
compute_sin_and_cos
static void compute_sin_and_cos(HueContext *hue)
Definition: vf_hue.c:103
HueContext::hue_deg_expr
char * hue_deg_expr
Definition: vf_hue.c:63
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:520
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:482
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
apply_luma_lut10
static void apply_luma_lut10(HueContext *s, uint16_t *ldst, const int dst_linesize, uint16_t *lsrc, const int src_linesize, int w, int h)
Definition: vf_hue.c:296
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:521
hue_inputs
static const AVFilterPad hue_inputs[]
Definition: vf_hue.c:493
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
HueContext::saturation_pexpr
AVExpr * saturation_pexpr
Definition: vf_hue.c:69
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_hue.c:463
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:711
create_chrominance_lut
static void create_chrominance_lut(HueContext *h, const int32_t c, const int32_t s)
Definition: vf_hue.c:127
SET_EXPR
#define SET_EXPR(expr, option)
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
Definition: vf_hue.c:358
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:359
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
HueContext::hue_deg_pexpr
AVExpr * hue_deg_pexpr
Definition: vf_hue.c:65
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:485
lrint
#define lrint
Definition: tablegen.h:53
TS2T
#define TS2T(ts, tb)
Definition: internal.h:251
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_vf_hue
const AVFilter ff_vf_hue
Definition: vf_hue.c:502
av_cold
#define av_cold
Definition: attributes.h:90
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:37
SAT_MIN_VAL
#define SAT_MIN_VAL
Definition: vf_hue.c:38
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_hue.c:206
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
VAR_TB
@ VAR_TB
Definition: vf_hue.c:55
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
HueContext
Definition: vf_hue.c:59
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
HueContext::hue
float hue
Definition: vf_hue.c:62
create_luma_lut
static void create_luma_lut(HueContext *h)
Definition: vf_hue.c:114
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:793
AVExpr
Definition: eval.c:159
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
HueContext::hsub
int hsub
Definition: vf_hue.c:73
NAN
#define NAN
Definition: mathematics.h:115
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
option
option
Definition: libkvazaar.c:320
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
TS2D
#define TS2D(ts)
Definition: internal.h:250
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
inpic
av_frame_free & inpic
Definition: vf_mcdeint.c:285
apply_lut
static void apply_lut(HueContext *s, uint8_t *udst, uint8_t *vdst, const int dst_linesize, uint8_t *usrc, uint8_t *vsrc, const int src_linesize, int w, int h)
Definition: vf_hue.c:312
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_hue.c:250
apply_lut10
static void apply_lut10(HueContext *s, uint16_t *udst, uint16_t *vdst, const int dst_linesize, uint16_t *usrc, uint16_t *vsrc, const int src_linesize, int w, int h)
Definition: vf_hue.c:335
HueContext::lut_v10
uint16_t lut_v10[1024][1024]
Definition: vf_hue.c:84
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:484
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:483
av_clipf
av_clipf
Definition: af_crystalizer.c:121
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
eval.h
HueContext::hue_deg
float hue_deg
Definition: vf_hue.c:61
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
bps
unsigned bps
Definition: movenc.c:1787
HueContext::hue_pexpr
AVExpr * hue_pexpr
Definition: vf_hue.c:66
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:666
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_hue.c:240
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:522
M_PI
#define M_PI
Definition: mathematics.h:67
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(hue)
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:147
HueContext::lut_l
uint8_t lut_l[256]
Definition: vf_hue.c:79
HueContext::brightness
float brightness
Definition: vf_hue.c:70
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
OFFSET
#define OFFSET(x)
Definition: vf_hue.c:87
VAR_PTS
@ VAR_PTS
Definition: vf_hue.c:52
HueContext::lut_u10
uint16_t lut_u10[1024][1024]
Definition: vf_hue.c:83
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
HueContext::lut_l16
uint16_t lut_l16[65536]
Definition: vf_hue.c:82
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
hue_options
static const AVOption hue_options[]
Definition: vf_hue.c:89
VAR_T
@ VAR_T
Definition: vf_hue.c:54
set_expr
static int set_expr(AVExpr **pexpr_ptr, char **expr_ptr, const char *expr, const char *option, void *log_ctx)
Definition: vf_hue.c:177
var_names
static const char *const var_names[]
Definition: vf_hue.c:41
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avfilter.h
HueContext::saturation
float saturation
Definition: vf_hue.c:67
HueContext::brightness_pexpr
AVExpr * brightness_pexpr
Definition: vf_hue.c:72
av_clip_uint8
#define av_clip_uint8
Definition: common.h:104
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
HueContext::is_first
int is_first
Definition: vf_hue.c:75
VAR_N
@ VAR_N
Definition: vf_hue.c:51
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
HueContext::lut_u
uint8_t lut_u[256][256]
Definition: vf_hue.c:80
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
config_props
static int config_props(AVFilterLink *inlink)
Definition: vf_hue.c:264
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
HueContext::brightness_expr
char * brightness_expr
Definition: vf_hue.c:71
int32_t
int32_t
Definition: audioconvert.c:56
VAR_NB
@ VAR_NB
Definition: vf_hue.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SAT_MAX_VAL
#define SAT_MAX_VAL
Definition: vf_hue.c:39
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
VAR_R
@ VAR_R
Definition: vf_hue.c:53
apply_luma_lut
static void apply_luma_lut(HueContext *s, uint8_t *ldst, const int dst_linesize, uint8_t *lsrc, const int src_linesize, int w, int h)
Definition: vf_hue.c:280
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
HueContext::lut_v
uint8_t lut_v[256][256]
Definition: vf_hue.c:81