FFmpeg
vf_libplacebo.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 
19 #include "libavutil/avassert.h"
20 #include "libavutil/eval.h"
21 #include "libavutil/fifo.h"
22 #include "libavutil/file.h"
23 #include "libavutil/frame.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
27 #include "formats.h"
28 #include "filters.h"
29 #include "video.h"
30 #include "vulkan_filter.h"
31 #include "scale_eval.h"
32 
33 #include <libplacebo/renderer.h>
34 #include <libplacebo/utils/libav.h>
35 #include <libplacebo/utils/frame_queue.h>
36 #include <libplacebo/vulkan.h>
37 
38 /* Backwards compatibility with older libplacebo */
39 #if PL_API_VER < 276
40 static inline AVFrame *pl_get_mapped_avframe(const struct pl_frame *frame)
41 {
42  return frame->user_data;
43 }
44 #endif
45 
46 #if PL_API_VER >= 309
47 #include <libplacebo/options.h>
48 #else
49 typedef struct pl_options_t {
50  // Backwards compatibility shim of this struct
51  struct pl_render_params params;
52  struct pl_deinterlace_params deinterlace_params;
53  struct pl_deband_params deband_params;
54  struct pl_sigmoid_params sigmoid_params;
55  struct pl_color_adjustment color_adjustment;
56  struct pl_peak_detect_params peak_detect_params;
57  struct pl_color_map_params color_map_params;
58  struct pl_dither_params dither_params;
59  struct pl_cone_params cone_params;
60 } *pl_options;
61 
62 #define pl_options_alloc(log) av_mallocz(sizeof(struct pl_options_t))
63 #define pl_options_free(ptr) av_freep(ptr)
64 #endif
65 
66 enum {
67  TONE_MAP_AUTO,
68  TONE_MAP_CLIP,
69  TONE_MAP_ST2094_40,
70  TONE_MAP_ST2094_10,
71  TONE_MAP_BT2390,
72  TONE_MAP_BT2446A,
73  TONE_MAP_SPLINE,
74  TONE_MAP_REINHARD,
75  TONE_MAP_MOBIUS,
76  TONE_MAP_HABLE,
77  TONE_MAP_GAMMA,
78  TONE_MAP_LINEAR,
79  TONE_MAP_COUNT,
80 };
81 
82 enum {
83  GAMUT_MAP_CLIP,
84  GAMUT_MAP_PERCEPTUAL,
85  GAMUT_MAP_RELATIVE,
86  GAMUT_MAP_SATURATION,
87  GAMUT_MAP_ABSOLUTE,
88  GAMUT_MAP_DESATURATE,
89  GAMUT_MAP_DARKEN,
90  GAMUT_MAP_HIGHLIGHT,
91  GAMUT_MAP_LINEAR,
92  GAMUT_MAP_COUNT,
93 };
94 
95 static const char *const var_names[] = {
96  "in_idx", "idx",///< index of input
97  "in_w", "iw", ///< width of the input video frame
98  "in_h", "ih", ///< height of the input video frame
99  "out_w", "ow", ///< width of the output video frame
100  "out_h", "oh", ///< height of the output video frame
101  "crop_w", "cw", ///< evaluated input crop width
102  "crop_h", "ch", ///< evaluated input crop height
103  "pos_w", "pw", ///< evaluated output placement width
104  "pos_h", "ph", ///< evaluated output placement height
105  "a", ///< iw/ih
106  "sar", ///< input pixel aspect ratio
107  "dar", ///< output pixel aspect ratio
108  "hsub", ///< input horizontal subsampling factor
109  "vsub", ///< input vertical subsampling factor
110  "ohsub", ///< output horizontal subsampling factor
111  "ovsub", ///< output vertical subsampling factor
112  "in_t", "t", ///< input frame pts
113  "out_t", "ot", ///< output frame pts
114  "n", ///< number of frame
115  NULL,
116 };
117 
118 enum var_name {
119  VAR_IN_IDX, VAR_IDX,
120  VAR_IN_W, VAR_IW,
121  VAR_IN_H, VAR_IH,
122  VAR_OUT_W, VAR_OW,
123  VAR_OUT_H, VAR_OH,
124  VAR_CROP_W, VAR_CW,
125  VAR_CROP_H, VAR_CH,
126  VAR_POS_W, VAR_PW,
127  VAR_POS_H, VAR_PH,
128  VAR_A,
129  VAR_SAR,
130  VAR_DAR,
131  VAR_HSUB,
132  VAR_VSUB,
133  VAR_OHSUB,
134  VAR_OVSUB,
135  VAR_IN_T, VAR_T,
136  VAR_OUT_T, VAR_OT,
137  VAR_N,
138  VAR_VARS_NB
139 };
140 
141 /* per-input dynamic filter state */
142 typedef struct LibplaceboInput {
143  int idx;
144  pl_renderer renderer;
145  pl_queue queue;
146  enum pl_queue_status qstatus;
147  struct pl_frame_mix mix; ///< temporary storage
148  AVFifo *out_pts; ///< timestamps of wanted output frames
149  int64_t status_pts;
150  int status;
151 } LibplaceboInput;
152 
153 typedef struct LibplaceboContext {
154  /* lavfi vulkan*/
155  FFVulkanContext vkctx;
156 
157  /* libplacebo */
158  pl_log log;
159  pl_vulkan vulkan;
160  pl_gpu gpu;
161  pl_tex tex[4];
162 
163  /* dedicated renderer for linear output composition */
164  pl_renderer linear_rr;
165  pl_tex linear_tex;
166 
167  /* input state */
168  LibplaceboInput *inputs;
169  int nb_inputs;
170  int64_t status_pts; ///< tracks status of most recently used input
171  int status;
172 
173  /* settings */
174  char *out_format_string;
175  enum AVPixelFormat out_format;
176  uint8_t fillcolor[4];
177  double var_values[VAR_VARS_NB];
178  char *w_expr;
179  char *h_expr;
180  char *fps_string;
181  AVRational fps; ///< parsed FPS, or 0/0 for "none"
182  char *crop_x_expr, *crop_y_expr;
183  char *crop_w_expr, *crop_h_expr;
184  char *pos_x_expr, *pos_y_expr;
185  char *pos_w_expr, *pos_h_expr;
186  // Parsed expressions for input/output crop
187  AVExpr *crop_x_pexpr, *crop_y_pexpr, *crop_w_pexpr, *crop_h_pexpr;
188  AVExpr *pos_x_pexpr, *pos_y_pexpr, *pos_w_pexpr, *pos_h_pexpr;
189  float pad_crop_ratio;
190  float corner_rounding;
191  int force_original_aspect_ratio;
192  int force_divisible_by;
193  int reset_sar;
194  int normalize_sar;
195  int apply_filmgrain;
196  int apply_dovi;
197  int colorspace;
198  int color_range;
199  int color_primaries;
200  int color_trc;
201  int rotation;
202  AVDictionary *extra_opts;
203 
204 #if PL_API_VER >= 351
205  pl_cache cache;
206  char *shader_cache;
207 #endif
208 
209  int have_hwdevice;
210 
211  /* pl_render_params */
212  pl_options opts;
213  char *upscaler;
214  char *downscaler;
215  char *frame_mixer;
216  float antiringing;
217  int sigmoid;
218  int skip_aa;
219  int disable_linear;
220  int disable_builtin;
221  int force_dither;
222  int disable_fbos;
223 
224  /* pl_deinterlace_params */
225  int deinterlace;
226  int skip_spatial_check;
227  int send_fields;
228 
229  /* pl_deband_params */
230  int deband;
231  int deband_iterations;
232  float deband_threshold;
233  float deband_radius;
234  float deband_grain;
235 
236  /* pl_color_adjustment */
237  float brightness;
238  float contrast;
239  float saturation;
240  float hue;
241  float gamma;
242 
243  /* pl_peak_detect_params */
244  int peakdetect;
245  float smoothing;
246  float scene_low;
247  float scene_high;
248  float percentile;
249 
250  /* pl_color_map_params */
251  int gamut_mode;
252  int tonemapping;
253  float tonemapping_param;
254  int inverse_tonemapping;
255  int tonemapping_lut_size;
256  float contrast_recovery;
257  float contrast_smoothness;
258 
259  /* pl_dither_params */
260  int dithering;
261  int dither_lut_size;
262  int dither_temporal;
263 
264  /* pl_cone_params */
265  int cones;
266  float cone_str;
267 
268  /* custom shaders */
269  char *shader_path;
270  void *shader_bin;
271  int shader_bin_len;
272  const struct pl_hook *hooks[2];
273  int num_hooks;
274 } LibplaceboContext;
275 
276 static inline enum pl_log_level get_log_level(void)
277 {
278  int av_lev = av_log_get_level();
279  return av_lev >= AV_LOG_TRACE ? PL_LOG_TRACE :
280  av_lev >= AV_LOG_DEBUG ? PL_LOG_DEBUG :
281  av_lev >= AV_LOG_VERBOSE ? PL_LOG_INFO :
282  av_lev >= AV_LOG_WARNING ? PL_LOG_WARN :
283  av_lev >= AV_LOG_ERROR ? PL_LOG_ERR :
284  av_lev >= AV_LOG_FATAL ? PL_LOG_FATAL :
285  PL_LOG_NONE;
286 }
287 
288 static void pl_av_log(void *log_ctx, enum pl_log_level level, const char *msg)
289 {
290  int av_lev;
291 
292  switch (level) {
293  case PL_LOG_FATAL: av_lev = AV_LOG_FATAL; break;
294  case PL_LOG_ERR: av_lev = AV_LOG_ERROR; break;
295  case PL_LOG_WARN: av_lev = AV_LOG_WARNING; break;
296  case PL_LOG_INFO: av_lev = AV_LOG_VERBOSE; break;
297  case PL_LOG_DEBUG: av_lev = AV_LOG_DEBUG; break;
298  case PL_LOG_TRACE: av_lev = AV_LOG_TRACE; break;
299  default: return;
300  }
301 
302  av_log(log_ctx, av_lev, "%s\n", msg);
303 }
304 
305 static const struct pl_tone_map_function *get_tonemapping_func(int tm) {
306  switch (tm) {
307  case TONE_MAP_AUTO: return &pl_tone_map_auto;
308  case TONE_MAP_CLIP: return &pl_tone_map_clip;
309 #if PL_API_VER >= 246
310  case TONE_MAP_ST2094_40: return &pl_tone_map_st2094_40;
311  case TONE_MAP_ST2094_10: return &pl_tone_map_st2094_10;
312 #endif
313  case TONE_MAP_BT2390: return &pl_tone_map_bt2390;
314  case TONE_MAP_BT2446A: return &pl_tone_map_bt2446a;
315  case TONE_MAP_SPLINE: return &pl_tone_map_spline;
316  case TONE_MAP_REINHARD: return &pl_tone_map_reinhard;
317  case TONE_MAP_MOBIUS: return &pl_tone_map_mobius;
318  case TONE_MAP_HABLE: return &pl_tone_map_hable;
319  case TONE_MAP_GAMMA: return &pl_tone_map_gamma;
320  case TONE_MAP_LINEAR: return &pl_tone_map_linear;
321  default: av_assert0(0);
322  }
323 }
324 
325 static void set_gamut_mode(struct pl_color_map_params *p, int gamut_mode)
326 {
327  switch (gamut_mode) {
328 #if PL_API_VER >= 269
329  case GAMUT_MAP_CLIP: p->gamut_mapping = &pl_gamut_map_clip; return;
330  case GAMUT_MAP_PERCEPTUAL: p->gamut_mapping = &pl_gamut_map_perceptual; return;
331  case GAMUT_MAP_RELATIVE: p->gamut_mapping = &pl_gamut_map_relative; return;
332  case GAMUT_MAP_SATURATION: p->gamut_mapping = &pl_gamut_map_saturation; return;
333  case GAMUT_MAP_ABSOLUTE: p->gamut_mapping = &pl_gamut_map_absolute; return;
334  case GAMUT_MAP_DESATURATE: p->gamut_mapping = &pl_gamut_map_desaturate; return;
335  case GAMUT_MAP_DARKEN: p->gamut_mapping = &pl_gamut_map_darken; return;
336  case GAMUT_MAP_HIGHLIGHT: p->gamut_mapping = &pl_gamut_map_highlight; return;
337  case GAMUT_MAP_LINEAR: p->gamut_mapping = &pl_gamut_map_linear; return;
338 #else
339  case GAMUT_MAP_RELATIVE: p->intent = PL_INTENT_RELATIVE_COLORIMETRIC; return;
340  case GAMUT_MAP_SATURATION: p->intent = PL_INTENT_SATURATION; return;
341  case GAMUT_MAP_ABSOLUTE: p->intent = PL_INTENT_ABSOLUTE_COLORIMETRIC; return;
342  case GAMUT_MAP_DESATURATE: p->gamut_mode = PL_GAMUT_DESATURATE; return;
343  case GAMUT_MAP_DARKEN: p->gamut_mode = PL_GAMUT_DARKEN; return;
344  case GAMUT_MAP_HIGHLIGHT: p->gamut_mode = PL_GAMUT_WARN; return;
345  /* Use defaults for all other cases */
346  default: return;
347 #endif
348  }
349 
350  av_assert0(0);
351 };
352 
353 static int find_scaler(AVFilterContext *avctx,
354  const struct pl_filter_config **opt,
355  const char *name, int frame_mixing)
356 {
357  const struct pl_filter_preset *preset, *presets_avail;
358  presets_avail = frame_mixing ? pl_frame_mixers : pl_scale_filters;
359 
360  if (!strcmp(name, "help")) {
361  av_log(avctx, AV_LOG_INFO, "Available scaler presets:\n");
362  for (preset = presets_avail; preset->name; preset++)
363  av_log(avctx, AV_LOG_INFO, " %s\n", preset->name);
364  return AVERROR_EXIT;
365  }
366 
367  for (preset = presets_avail; preset->name; preset++) {
368  if (!strcmp(name, preset->name)) {
369  *opt = preset->filter;
370  return 0;
371  }
372  }
373 
374  av_log(avctx, AV_LOG_ERROR, "No such scaler preset '%s'.\n", name);
375  return AVERROR(EINVAL);
376 }
377 
378 static int update_settings(AVFilterContext *ctx)
379 {
380  int err = 0;
381  LibplaceboContext *s = ctx->priv;
382  AVDictionaryEntry *e = NULL;
383  pl_options opts = s->opts;
384  int gamut_mode = s->gamut_mode;
385 
386  opts->deinterlace_params = *pl_deinterlace_params(
387  .algo = s->deinterlace,
388  .skip_spatial_check = s->skip_spatial_check,
389  );
390 
391  opts->deband_params = *pl_deband_params(
392  .iterations = s->deband_iterations,
393  .threshold = s->deband_threshold,
394  .radius = s->deband_radius,
395  .grain = s->deband_grain,
396  );
397 
398  opts->sigmoid_params = pl_sigmoid_default_params;
399 
400  opts->color_adjustment = (struct pl_color_adjustment) {
401  .brightness = s->brightness,
402  .contrast = s->contrast,
403  .saturation = s->saturation,
404  .hue = s->hue,
405  .gamma = s->gamma,
406  };
407 
408  opts->peak_detect_params = *pl_peak_detect_params(
409  .smoothing_period = s->smoothing,
410  .scene_threshold_low = s->scene_low,
411  .scene_threshold_high = s->scene_high,
412 #if PL_API_VER >= 263
413  .percentile = s->percentile,
414 #endif
415  );
416 
417  opts->color_map_params = *pl_color_map_params(
418  .tone_mapping_function = get_tonemapping_func(s->tonemapping),
419  .tone_mapping_param = s->tonemapping_param,
420  .inverse_tone_mapping = s->inverse_tonemapping,
421  .lut_size = s->tonemapping_lut_size,
422 #if PL_API_VER >= 285
423  .contrast_recovery = s->contrast_recovery,
424  .contrast_smoothness = s->contrast_smoothness,
425 #endif
426  );
427 
428  set_gamut_mode(&opts->color_map_params, gamut_mode);
429 
430  opts->dither_params = *pl_dither_params(
431  .method = s->dithering,
432  .lut_size = s->dither_lut_size,
433  .temporal = s->dither_temporal,
434  );
435 
436  opts->cone_params = *pl_cone_params(
437  .cones = s->cones,
438  .strength = s->cone_str,
439  );
440 
441  opts->params = *pl_render_params(
442  .antiringing_strength = s->antiringing,
443  .background_transparency = 1.0f - (float) s->fillcolor[3] / UINT8_MAX,
444  .background_color = {
445  (float) s->fillcolor[0] / UINT8_MAX,
446  (float) s->fillcolor[1] / UINT8_MAX,
447  (float) s->fillcolor[2] / UINT8_MAX,
448  },
449 #if PL_API_VER >= 277
450  .corner_rounding = s->corner_rounding,
451 #endif
452 
453  .deinterlace_params = &opts->deinterlace_params,
454  .deband_params = s->deband ? &opts->deband_params : NULL,
455  .sigmoid_params = s->sigmoid ? &opts->sigmoid_params : NULL,
456  .color_adjustment = &opts->color_adjustment,
457  .peak_detect_params = s->peakdetect ? &opts->peak_detect_params : NULL,
458  .color_map_params = &opts->color_map_params,
459  .dither_params = s->dithering >= 0 ? &opts->dither_params : NULL,
460  .cone_params = s->cones ? &opts->cone_params : NULL,
461 
462  .hooks = s->hooks,
463  .num_hooks = s->num_hooks,
464 
465  .skip_anti_aliasing = s->skip_aa,
466  .disable_linear_scaling = s->disable_linear,
467  .disable_builtin_scalers = s->disable_builtin,
468  .force_dither = s->force_dither,
469  .disable_fbos = s->disable_fbos,
470  );
471 
472  RET(find_scaler(ctx, &opts->params.upscaler, s->upscaler, 0));
473  RET(find_scaler(ctx, &opts->params.downscaler, s->downscaler, 0));
474  RET(find_scaler(ctx, &opts->params.frame_mixer, s->frame_mixer, 1));
475 
476 #if PL_API_VER >= 309
477  while ((e = av_dict_get(s->extra_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
478  if (!pl_options_set_str(s->opts, e->key, e->value)) {
479  err = AVERROR(EINVAL);
480  goto fail;
481  }
482  }
483 #else
484  (void) e;
485  if (av_dict_count(s->extra_opts) > 0)
486  av_log(s, AV_LOG_WARNING, "extra_opts requires libplacebo >= 6.309!\n");
487 #endif
488 
489  return 0;
490 
491 fail:
492  return err;
493 }
494 
495 static int parse_shader(AVFilterContext *avctx, const void *shader, size_t len)
496 {
497  LibplaceboContext *s = avctx->priv;
498  const struct pl_hook *hook;
499 
500  hook = pl_mpv_user_shader_parse(s->gpu, shader, len);
501  if (!hook) {
502  av_log(s, AV_LOG_ERROR, "Failed parsing custom shader!\n");
503  return AVERROR(EINVAL);
504  }
505 
506  s->hooks[s->num_hooks++] = hook;
507  return update_settings(avctx);
508 }
509 
510 static void libplacebo_uninit(AVFilterContext *avctx);
511 static int libplacebo_config_input(AVFilterLink *inlink);
512 static int init_vulkan(AVFilterContext *avctx, const AVVulkanDeviceContext *hwctx);
513 
514 static int libplacebo_init(AVFilterContext *avctx)
515 {
516  int err = 0;
517  LibplaceboContext *s = avctx->priv;
518  const AVVulkanDeviceContext *vkhwctx = NULL;
519 
520  /* Create libplacebo log context */
521  s->log = pl_log_create(PL_API_VER, pl_log_params(
522  .log_level = get_log_level(),
523  .log_cb = pl_av_log,
524  .log_priv = s,
525  ));
526 
527  if (!s->log)
528  return AVERROR(ENOMEM);
529 
530  s->opts = pl_options_alloc(s->log);
531  if (!s->opts) {
532  libplacebo_uninit(avctx);
533  return AVERROR(ENOMEM);
534  }
535 
536 #if PL_API_VER >= 351
537  if (s->shader_cache && s->shader_cache[0]) {
538  s->cache = pl_cache_create(pl_cache_params(
539  .log = s->log,
540  .get = pl_cache_get_file,
541  .set = pl_cache_set_file,
542  .priv = s->shader_cache,
543  ));
544  if (!s->cache) {
545  libplacebo_uninit(avctx);
546  return AVERROR(ENOMEM);
547  }
548  }
549 #endif
550 
551  if (s->out_format_string) {
552  s->out_format = av_get_pix_fmt(s->out_format_string);
553  if (s->out_format == AV_PIX_FMT_NONE) {
554  av_log(avctx, AV_LOG_ERROR, "Invalid output format: %s\n",
555  s->out_format_string);
556  libplacebo_uninit(avctx);
557  return AVERROR(EINVAL);
558  }
559  } else {
560  s->out_format = AV_PIX_FMT_NONE;
561  }
562 
563  for (int i = 0; i < s->nb_inputs; i++) {
564  AVFilterPad pad = {
565  .name = av_asprintf("input%d", i),
566  .type = AVMEDIA_TYPE_VIDEO,
567  .config_props = &libplacebo_config_input,
568  };
569  if (!pad.name)
570  return AVERROR(ENOMEM);
571  RET(ff_append_inpad_free_name(avctx, &pad));
572  }
573 
574  RET(update_settings(avctx));
575  RET(av_expr_parse(&s->crop_x_pexpr, s->crop_x_expr, var_names,
576  NULL, NULL, NULL, NULL, 0, s));
577  RET(av_expr_parse(&s->crop_y_pexpr, s->crop_y_expr, var_names,
578  NULL, NULL, NULL, NULL, 0, s));
579  RET(av_expr_parse(&s->crop_w_pexpr, s->crop_w_expr, var_names,
580  NULL, NULL, NULL, NULL, 0, s));
581  RET(av_expr_parse(&s->crop_h_pexpr, s->crop_h_expr, var_names,
582  NULL, NULL, NULL, NULL, 0, s));
583  RET(av_expr_parse(&s->pos_x_pexpr, s->pos_x_expr, var_names,
584  NULL, NULL, NULL, NULL, 0, s));
585  RET(av_expr_parse(&s->pos_y_pexpr, s->pos_y_expr, var_names,
586  NULL, NULL, NULL, NULL, 0, s));
587  RET(av_expr_parse(&s->pos_w_pexpr, s->pos_w_expr, var_names,
588  NULL, NULL, NULL, NULL, 0, s));
589  RET(av_expr_parse(&s->pos_h_pexpr, s->pos_h_expr, var_names,
590  NULL, NULL, NULL, NULL, 0, s));
591 
592  if (strcmp(s->fps_string, "none") != 0)
593  RET(av_parse_video_rate(&s->fps, s->fps_string));
594 
595  if (avctx->hw_device_ctx) {
596  const AVHWDeviceContext *avhwctx = (void *) avctx->hw_device_ctx->data;
597  if (avhwctx->type == AV_HWDEVICE_TYPE_VULKAN)
598  vkhwctx = avhwctx->hwctx;
599  }
600 
601  RET(init_vulkan(avctx, vkhwctx));
602 
603  return 0;
604 
605 fail:
606  return err;
607 }
608 
609 #if PL_API_VER >= 278
610 static void lock_queue(void *priv, uint32_t qf, uint32_t qidx)
611 {
612  AVHWDeviceContext *avhwctx = priv;
613  const AVVulkanDeviceContext *hwctx = avhwctx->hwctx;
614  hwctx->lock_queue(avhwctx, qf, qidx);
615 }
616 
617 static void unlock_queue(void *priv, uint32_t qf, uint32_t qidx)
618 {
619  AVHWDeviceContext *avhwctx = priv;
620  const AVVulkanDeviceContext *hwctx = avhwctx->hwctx;
621  hwctx->unlock_queue(avhwctx, qf, qidx);
622 }
623 #endif
624 
625 static int input_init(AVFilterContext *avctx, LibplaceboInput *input, int idx)
626 {
627  LibplaceboContext *s = avctx->priv;
628 
629  input->out_pts = av_fifo_alloc2(1, sizeof(int64_t), AV_FIFO_FLAG_AUTO_GROW);
630  if (!input->out_pts)
631  return AVERROR(ENOMEM);
632  input->queue = pl_queue_create(s->gpu);
633  input->renderer = pl_renderer_create(s->log, s->gpu);
634  input->idx = idx;
635 
636  return 0;
637 }
638 
639 static void input_uninit(LibplaceboInput *input)
640 {
641  pl_renderer_destroy(&input->renderer);
642  pl_queue_destroy(&input->queue);
643  av_fifo_freep2(&input->out_pts);
644 }
645 
646 static int init_vulkan(AVFilterContext *avctx, const AVVulkanDeviceContext *hwctx)
647 {
648  int err = 0;
649  LibplaceboContext *s = avctx->priv;
650  uint8_t *buf = NULL;
651  size_t buf_len;
652 
653  if (hwctx) {
654 #if PL_API_VER >= 278
655  struct pl_vulkan_import_params import_params = {
656  .instance = hwctx->inst,
657  .get_proc_addr = hwctx->get_proc_addr,
658  .phys_device = hwctx->phys_dev,
659  .device = hwctx->act_dev,
660  .extensions = hwctx->enabled_dev_extensions,
661  .num_extensions = hwctx->nb_enabled_dev_extensions,
662  .features = &hwctx->device_features,
663  .lock_queue = lock_queue,
664  .unlock_queue = unlock_queue,
665  .queue_ctx = avctx->hw_device_ctx->data,
666  .queue_graphics = {
667  .index = VK_QUEUE_FAMILY_IGNORED,
668  .count = 0,
669  },
670  .queue_compute = {
671  .index = VK_QUEUE_FAMILY_IGNORED,
672  .count = 0,
673  },
674  .queue_transfer = {
675  .index = VK_QUEUE_FAMILY_IGNORED,
676  .count = 0,
677  },
678  /* This is the highest version created by hwcontext_vulkan.c */
679  .max_api_version = VK_API_VERSION_1_3,
680  };
681  for (int i = 0; i < hwctx->nb_qf; i++) {
682  const AVVulkanDeviceQueueFamily *qf = &hwctx->qf[i];
683 
684  if (qf->flags & VK_QUEUE_GRAPHICS_BIT) {
685  import_params.queue_graphics.index = qf->idx;
686  import_params.queue_graphics.count = qf->num;
687  }
688  if (qf->flags & VK_QUEUE_COMPUTE_BIT) {
689  import_params.queue_compute.index = qf->idx;
690  import_params.queue_compute.count = qf->num;
691  }
692  if (qf->flags & VK_QUEUE_TRANSFER_BIT) {
693  import_params.queue_transfer.index = qf->idx;
694  import_params.queue_transfer.count = qf->num;
695  }
696  }
697 
698  /* Import libavfilter vulkan context into libplacebo */
699  s->vulkan = pl_vulkan_import(s->log, &import_params);
700 #else
701  av_log(s, AV_LOG_ERROR, "libplacebo version %s too old to import "
702  "Vulkan device, remove it or upgrade libplacebo to >= 5.278\n",
703  PL_VERSION);
704  err = AVERROR_EXTERNAL;
705  goto fail;
706 #endif
707 
708  s->have_hwdevice = 1;
709  } else {
710  s->vulkan = pl_vulkan_create(s->log, pl_vulkan_params(
711  .queue_count = 0, /* enable all queues for parallelization */
712  ));
713  }
714 
715  if (!s->vulkan) {
716  av_log(s, AV_LOG_ERROR, "Failed %s Vulkan device!\n",
717  hwctx ? "importing" : "creating");
718  err = AVERROR_EXTERNAL;
719  goto fail;
720  }
721 
722  s->gpu = s->vulkan->gpu;
723 #if PL_API_VER >= 351
724  pl_gpu_set_cache(s->gpu, s->cache);
725 #endif
726 
727  /* Parse the user shaders, if requested */
728  if (s->shader_bin_len)
729  RET(parse_shader(avctx, s->shader_bin, s->shader_bin_len));
730 
731  if (s->shader_path && s->shader_path[0]) {
732  RET(av_file_map(s->shader_path, &buf, &buf_len, 0, s));
733  RET(parse_shader(avctx, buf, buf_len));
734  }
735 
736  /* Initialize inputs */
737  s->inputs = av_calloc(s->nb_inputs, sizeof(*s->inputs));
738  if (!s->inputs)
739  return AVERROR(ENOMEM);
740  for (int i = 0; i < s->nb_inputs; i++)
741  RET(input_init(avctx, &s->inputs[i], i));
742  s->linear_rr = pl_renderer_create(s->log, s->gpu);
743 
744  /* fall through */
745 fail:
746  if (buf)
747  av_file_unmap(buf, buf_len);
748  return err;
749 }
750 
751 static void libplacebo_uninit(AVFilterContext *avctx)
752 {
753  LibplaceboContext *s = avctx->priv;
754 
755  for (int i = 0; i < FF_ARRAY_ELEMS(s->tex); i++)
756  pl_tex_destroy(s->gpu, &s->tex[i]);
757  for (int i = 0; i < s->num_hooks; i++)
758  pl_mpv_user_shader_destroy(&s->hooks[i]);
759  if (s->inputs) {
760  for (int i = 0; i < s->nb_inputs; i++)
761  input_uninit(&s->inputs[i]);
762  av_freep(&s->inputs);
763  }
764 
765 #if PL_API_VER >= 351
766  pl_cache_destroy(&s->cache);
767 #endif
768  pl_renderer_destroy(&s->linear_rr);
769  pl_tex_destroy(s->gpu, &s->linear_tex);
770  pl_options_free(&s->opts);
771  pl_vulkan_destroy(&s->vulkan);
772  pl_log_destroy(&s->log);
773  ff_vk_uninit(&s->vkctx);
774  s->gpu = NULL;
775 
776  av_expr_free(s->crop_x_pexpr);
777  av_expr_free(s->crop_y_pexpr);
778  av_expr_free(s->crop_w_pexpr);
779  av_expr_free(s->crop_h_pexpr);
780  av_expr_free(s->pos_x_pexpr);
781  av_expr_free(s->pos_y_pexpr);
782  av_expr_free(s->pos_w_pexpr);
783  av_expr_free(s->pos_h_pexpr);
784 }
785 
786 static int libplacebo_process_command(AVFilterContext *ctx, const char *cmd,
787  const char *arg, char *res, int res_len,
788  int flags)
789 {
790  int err = 0;
791  RET(ff_filter_process_command(ctx, cmd, arg, res, res_len, flags));
792  RET(update_settings(ctx));
793  return 0;
794 
795 fail:
796  return err;
797 }
798 
799 static const AVFrame *ref_frame(const struct pl_frame_mix *mix)
800 {
801  for (int i = 0; i < mix->num_frames; i++) {
802  if (i+1 == mix->num_frames || mix->timestamps[i+1] > 0)
803  return pl_get_mapped_avframe(mix->frames[i]);
804  }
805  return NULL;
806 }
807 
808 static void update_crops(AVFilterContext *ctx, LibplaceboInput *in,
809  struct pl_frame *target, double target_pts)
810 {
811  FilterLink *outl = ff_filter_link(ctx->outputs[0]);
812  LibplaceboContext *s = ctx->priv;
813  const AVFilterLink *inlink = ctx->inputs[in->idx];
814  const AVFrame *ref = ref_frame(&in->mix);
815 
816  for (int i = 0; i < in->mix.num_frames; i++) {
817  // Mutate the `pl_frame.crop` fields in-place. This is fine because we
818  // own the entire pl_queue, and hence, the pointed-at frames.
819  struct pl_frame *image = (struct pl_frame *) in->mix.frames[i];
820  const AVFrame *src = pl_get_mapped_avframe(image);
821  double image_pts = src->pts * av_q2d(inlink->time_base);
822 
823  /* Update dynamic variables */
824  s->var_values[VAR_IN_IDX] = s->var_values[VAR_IDX] = in->idx;
825  s->var_values[VAR_IN_W] = s->var_values[VAR_IW] = inlink->w;
826  s->var_values[VAR_IN_H] = s->var_values[VAR_IH] = inlink->h;
827  s->var_values[VAR_A] = (double) inlink->w / inlink->h;
828  s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ?
829  av_q2d(inlink->sample_aspect_ratio) : 1.0;
830  s->var_values[VAR_IN_T] = s->var_values[VAR_T] = image_pts;
831  s->var_values[VAR_OUT_T] = s->var_values[VAR_OT] = target_pts;
832  s->var_values[VAR_N] = outl->frame_count_out;
833 
834  /* Clear these explicitly to avoid leaking previous frames' state */
835  s->var_values[VAR_CROP_W] = s->var_values[VAR_CW] = NAN;
836  s->var_values[VAR_CROP_H] = s->var_values[VAR_CH] = NAN;
837  s->var_values[VAR_POS_W] = s->var_values[VAR_PW] = NAN;
838  s->var_values[VAR_POS_H] = s->var_values[VAR_PH] = NAN;
839 
840  /* Compute dimensions first and placement second */
841  s->var_values[VAR_CROP_W] = s->var_values[VAR_CW] =
842  av_expr_eval(s->crop_w_pexpr, s->var_values, NULL);
843  s->var_values[VAR_CROP_H] = s->var_values[VAR_CH] =
844  av_expr_eval(s->crop_h_pexpr, s->var_values, NULL);
845  s->var_values[VAR_CROP_W] = s->var_values[VAR_CW] =
846  av_expr_eval(s->crop_w_pexpr, s->var_values, NULL);
847  s->var_values[VAR_POS_W] = s->var_values[VAR_PW] =
848  av_expr_eval(s->pos_w_pexpr, s->var_values, NULL);
849  s->var_values[VAR_POS_H] = s->var_values[VAR_PH] =
850  av_expr_eval(s->pos_h_pexpr, s->var_values, NULL);
851  s->var_values[VAR_POS_W] = s->var_values[VAR_PW] =
852  av_expr_eval(s->pos_w_pexpr, s->var_values, NULL);
853 
854  image->crop.x0 = av_expr_eval(s->crop_x_pexpr, s->var_values, NULL);
855  image->crop.y0 = av_expr_eval(s->crop_y_pexpr, s->var_values, NULL);
856  image->crop.x1 = image->crop.x0 + s->var_values[VAR_CROP_W];
857  image->crop.y1 = image->crop.y0 + s->var_values[VAR_CROP_H];
858  image->rotation = s->rotation;
859  if (s->rotation % PL_ROTATION_180 == PL_ROTATION_90) {
860  /* Libplacebo expects the input crop relative to the actual frame
861  * dimensions, so un-transpose them here */
862  FFSWAP(float, image->crop.x0, image->crop.y0);
863  FFSWAP(float, image->crop.x1, image->crop.y1);
864  }
865 
866  if (src == ref) {
867  /* Only update the target crop once, for the 'reference' frame */
868  target->crop.x0 = av_expr_eval(s->pos_x_pexpr, s->var_values, NULL);
869  target->crop.y0 = av_expr_eval(s->pos_y_pexpr, s->var_values, NULL);
870  target->crop.x1 = target->crop.x0 + s->var_values[VAR_POS_W];
871  target->crop.y1 = target->crop.y0 + s->var_values[VAR_POS_H];
872  if (s->normalize_sar) {
873  float aspect = pl_rect2df_aspect(&image->crop);
874  aspect *= av_q2d(inlink->sample_aspect_ratio);
875  pl_rect2df_aspect_set(&target->crop, aspect, s->pad_crop_ratio);
876  }
877  }
878  }
879 }
880 
881 /* Construct and emit an output frame for a given timestamp */
882 static int output_frame(AVFilterContext *ctx, int64_t pts)
883 {
884  int err = 0, ok, changed = 0;
885  LibplaceboContext *s = ctx->priv;
886  pl_options opts = s->opts;
887  AVFilterLink *outlink = ctx->outputs[0];
888  const AVPixFmtDescriptor *outdesc = av_pix_fmt_desc_get(outlink->format);
889  struct pl_frame target;
890  const AVFrame *ref = NULL;
891  AVFrame *out;
892 
893  /* Use the first active input as metadata reference */
894  for (int i = 0; i < s->nb_inputs; i++) {
895  const LibplaceboInput *in = &s->inputs[i];
896  if (in->qstatus == PL_QUEUE_OK && (ref = ref_frame(&in->mix)))
897  break;
898  }
899  if (!ref)
900  return 0;
901 
902  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
903  if (!out)
904  return AVERROR(ENOMEM);
905 
906  RET(av_frame_copy_props(out, ref));
907  out->pts = pts;
908  out->width = outlink->w;
909  out->height = outlink->h;
910  out->colorspace = outlink->colorspace;
911  out->color_range = outlink->color_range;
912  if (s->fps.num)
913  out->duration = 1;
914  if (s->deinterlace)
915  out->flags &= ~(AV_FRAME_FLAG_INTERLACED | AV_FRAME_FLAG_TOP_FIELD_FIRST);
916 
917  if (s->apply_dovi && av_frame_get_side_data(ref, AV_FRAME_DATA_DOVI_METADATA)) {
918  /* Output of dovi reshaping is always BT.2020+PQ, so infer the correct
919  * output colorspace defaults */
920  out->color_primaries = AVCOL_PRI_BT2020;
921  out->color_trc = AVCOL_TRC_SMPTE2084;
922  changed |= AV_SIDE_DATA_PROP_COLOR_DEPENDENT;
923  }
924 
925  if (s->color_trc >= 0)
926  out->color_trc = s->color_trc;
927  if (s->color_primaries >= 0)
928  out->color_primaries = s->color_primaries;
929 
930  /* Strip side data if no longer relevant */
931  if (out->width != ref->width || out->height != ref->height)
932  changed |= AV_SIDE_DATA_PROP_SIZE_DEPENDENT;
933  if (ref->color_trc != out->color_trc || ref->color_primaries != out->color_primaries)
934  changed |= AV_SIDE_DATA_PROP_COLOR_DEPENDENT;
935  av_frame_side_data_remove_by_props(&out->side_data, &out->nb_side_data, changed);
936 
937  if (s->apply_filmgrain)
938  av_frame_remove_side_data(out, AV_FRAME_DATA_FILM_GRAIN_PARAMS);
939 
940  if (s->reset_sar) {
941  out->sample_aspect_ratio = ref->sample_aspect_ratio;
942  } else {
943  const AVRational ar_ref = { ref->width, ref->height };
944  const AVRational ar_out = { out->width, out->height };
945  const AVRational stretch = av_div_q(ar_ref, ar_out);
946  out->sample_aspect_ratio = av_mul_q(ref->sample_aspect_ratio, stretch);
947  }
948 
949  /* Map, render and unmap output frame */
950  if (outdesc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
951  ok = pl_map_avframe_ex(s->gpu, &target, pl_avframe_params(
952  .frame = out,
953  .map_dovi = false,
954  ));
955  } else {
956  ok = pl_frame_recreate_from_avframe(s->gpu, &target, s->tex, out);
957  }
958  if (!ok) {
959  err = AVERROR_EXTERNAL;
960  goto fail;
961  }
962 
963  struct pl_frame orig_target = target;
964  bool use_linear_compositor = false;
965  if (s->linear_tex && target.color.transfer != PL_COLOR_TRC_LINEAR && !s->disable_linear) {
966  use_linear_compositor = true;
967  target.color.transfer = PL_COLOR_TRC_LINEAR;
968  target.repr = pl_color_repr_rgb;
969  target.num_planes = 1;
970  target.planes[0] = (struct pl_plane) {
971  .components = 4,
972  .component_mapping = {0, 1, 2, 3},
973  .texture = s->linear_tex,
974  };
975  }
976 
977  /* Draw first frame opaque, others with blending */
978  opts->params.blend_params = NULL;
979 #if PL_API_VER >= 346
980  opts->params.background = opts->params.border = PL_CLEAR_COLOR;
981 #else
982  opts->params.skip_target_clearing = false;
983 #endif
984  for (int i = 0; i < s->nb_inputs; i++) {
985  LibplaceboInput *in = &s->inputs[i];
986  FilterLink *il = ff_filter_link(ctx->inputs[in->idx]);
987  FilterLink *ol = ff_filter_link(outlink);
988  int high_fps = av_cmp_q(il->frame_rate, ol->frame_rate) >= 0;
989  if (in->qstatus != PL_QUEUE_OK)
990  continue;
991  opts->params.skip_caching_single_frame = high_fps;
992  update_crops(ctx, in, &target, out->pts * av_q2d(outlink->time_base));
993  pl_render_image_mix(in->renderer, &in->mix, &target, &opts->params);
994 
995  /* Force straight output and set correct blend mode */
996  target.repr.alpha = PL_ALPHA_INDEPENDENT;
997  opts->params.blend_params = &pl_alpha_overlay;
998 #if PL_API_VER >= 346
999  opts->params.background = opts->params.border = PL_CLEAR_SKIP;
1000 #else
1001  opts->params.skip_target_clearing = true;
1002 #endif
1003  }
1004 
1005  if (use_linear_compositor) {
1006  /* Blit the linear intermediate image to the output frame */
1007  target.crop = orig_target.crop = (struct pl_rect2df) {0};
1008  pl_render_image(s->linear_rr, &target, &orig_target, &opts->params);
1009  target = orig_target;
1010  }
1011 
1012  if (outdesc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1013  pl_unmap_avframe(s->gpu, &target);
1014  } else if (!pl_download_avframe(s->gpu, &target, out)) {
1015  err = AVERROR_EXTERNAL;
1016  goto fail;
1017  }
1018  return ff_filter_frame(outlink, out);
1019 
1020 fail:
1021  av_frame_free(&out);
1022  return err;
1023 }
1024 
1025 static bool map_frame(pl_gpu gpu, pl_tex *tex,
1026  const struct pl_source_frame *src,
1027  struct pl_frame *out)
1028 {
1029  AVFrame *avframe = src->frame_data;
1030  LibplaceboContext *s = avframe->opaque;
1031  bool ok = pl_map_avframe_ex(gpu, out, pl_avframe_params(
1032  .frame = avframe,
1033  .tex = tex,
1034  .map_dovi = s->apply_dovi,
1035  ));
1036 
1037  if (!s->apply_filmgrain)
1038  out->film_grain.type = PL_FILM_GRAIN_NONE;
1039 
1040  av_frame_free(&avframe);
1041  return ok;
1042 }
1043 
1044 static void unmap_frame(pl_gpu gpu, struct pl_frame *frame,
1045  const struct pl_source_frame *src)
1046 {
1047  pl_unmap_avframe(gpu, frame);
1048 }
1049 
1050 static void discard_frame(const struct pl_source_frame *src)
1051 {
1052  AVFrame *avframe = src->frame_data;
1053  av_frame_free(&avframe);
1054 }
1055 
1056 static int handle_input(AVFilterContext *ctx, LibplaceboInput *input)
1057 {
1058  int ret, status;
1059  LibplaceboContext *s = ctx->priv;
1060  AVFilterLink *outlink = ctx->outputs[0];
1061  AVFilterLink *inlink = ctx->inputs[input->idx];
1062  AVFrame *in;
1063  int64_t pts;
1064 
1065  while ((ret = ff_inlink_consume_frame(inlink, &in)) > 0) {
1066  struct pl_source_frame src = {
1067  .pts = in->pts * av_q2d(inlink->time_base),
1068  .duration = in->duration * av_q2d(inlink->time_base),
1069  .first_field = s->deinterlace ? pl_field_from_avframe(in) : PL_FIELD_NONE,
1070  .frame_data = in,
1071  .map = map_frame,
1072  .unmap = unmap_frame,
1073  .discard = discard_frame,
1074  };
1075 
1076  in->opaque = s;
1077  pl_queue_push(input->queue, &src);
1078 
1079  if (!s->fps.num) {
1080  /* Internally queue an output frame for the same PTS */
1081  pts = av_rescale_q(in->pts, inlink->time_base, outlink->time_base);
1082  av_fifo_write(input->out_pts, &pts, 1);
1083 
1084  if (s->send_fields && src.first_field != PL_FIELD_NONE) {
1085  /* Queue the second field for interlaced content */
1086  pts += av_rescale_q(in->duration, inlink->time_base, outlink->time_base) / 2;
1087  av_fifo_write(input->out_pts, &pts, 1);
1088  }
1089  }
1090  }
1091 
1092  if (ret < 0)
1093  return ret;
1094 
1095  if (!input->status && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
1096  pts = av_rescale_q_rnd(pts, inlink->time_base, outlink->time_base,
1097  AV_ROUND_UP);
1098  pl_queue_push(input->queue, NULL); /* Signal EOF to pl_queue */
1099  input->status = status;
1100  input->status_pts = pts;
1101  if (!s->status || pts >= s->status_pts) {
1102  /* Also propagate to output unless overwritten by later status change */
1103  s->status = status;
1104  s->status_pts = pts;
1105  }
1106  }
1107 
1108  return 0;
1109 }
1110 
1111 static void drain_input_pts(LibplaceboInput *in, int64_t until)
1112 {
1113  int64_t pts;
1114  while (av_fifo_peek(in->out_pts, &pts, 1, 0) >= 0 && pts <= until)
1115  av_fifo_drain2(in->out_pts, 1);
1116 }
1117 
1118 static int libplacebo_activate(AVFilterContext *ctx)
1119 {
1120  int ret, ok = 0, retry = 0;
1121  LibplaceboContext *s = ctx->priv;
1122  AVFilterLink *outlink = ctx->outputs[0];
1123  FilterLink *outl = ff_filter_link(outlink);
1124  int64_t pts, out_pts;
1125 
1126  FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
1127  pl_log_level_update(s->log, get_log_level());
1128 
1129  for (int i = 0; i < s->nb_inputs; i++) {
1130  if ((ret = handle_input(ctx, &s->inputs[i])) < 0)
1131  return ret;
1132  }
1133 
1134  if (ff_outlink_frame_wanted(outlink)) {
1135  if (s->fps.num) {
1136  out_pts = outl->frame_count_out;
1137  } else {
1138  /* Determine the PTS of the next frame from any active input */
1139  out_pts = INT64_MAX;
1140  for (int i = 0; i < s->nb_inputs; i++) {
1141  LibplaceboInput *in = &s->inputs[i];
1142  if (av_fifo_peek(in->out_pts, &pts, 1, 0) >= 0) {
1143  out_pts = FFMIN(out_pts, pts);
1144  } else if (!in->status) {
1145  ff_inlink_request_frame(ctx->inputs[in->idx]);
1146  retry = true;
1147  }
1148  }
1149 
1150  if (retry) /* some inputs are incomplete */
1151  return 0;
1152  }
1153 
1154  /* Update all input queues to the chosen out_pts */
1155  for (int i = 0; i < s->nb_inputs; i++) {
1156  LibplaceboInput *in = &s->inputs[i];
1157  FilterLink *l = ff_filter_link(outlink);
1158  if (in->status && out_pts >= in->status_pts) {
1159  in->qstatus = PL_QUEUE_EOF;
1160  continue;
1161  }
1162 
1163  in->qstatus = pl_queue_update(in->queue, &in->mix, pl_queue_params(
1164  .pts = out_pts * av_q2d(outlink->time_base),
1165  .radius = pl_frame_mix_radius(&s->opts->params),
1166  .vsync_duration = l->frame_rate.num ? av_q2d(av_inv_q(l->frame_rate)) : 0,
1167  ));
1168 
1169  switch (in->qstatus) {
1170  case PL_QUEUE_MORE:
1171  ff_inlink_request_frame(ctx->inputs[in->idx]);
1172  retry = true;
1173  break;
1174  case PL_QUEUE_OK:
1175  ok = true;
1176  break;
1177  case PL_QUEUE_ERR:
1178  return AVERROR_EXTERNAL;
1179  }
1180  }
1181 
1182  if (retry) {
1183  return 0;
1184  } else if (ok) {
1185  /* Got any valid frame mixes, drain PTS queue and render output */
1186  for (int i = 0; i < s->nb_inputs; i++)
1187  drain_input_pts(&s->inputs[i], out_pts);
1188  return output_frame(ctx, out_pts);
1189  } else if (s->status) {
1190  ff_outlink_set_status(outlink, s->status, s->status_pts);
1191  return 0;
1192  }
1193 
1194  return AVERROR_BUG;
1195  }
1196 
1197  return FFERROR_NOT_READY;
1198 }
1199 
1200 static int libplacebo_query_format(const AVFilterContext *ctx,
1201  AVFilterFormatsConfig **cfg_in,
1202  AVFilterFormatsConfig **cfg_out)
1203 {
1204  int err;
1205  const LibplaceboContext *s = ctx->priv;
1206  const AVPixFmtDescriptor *desc = NULL;
1207  AVFilterFormats *infmts = NULL, *outfmts = NULL;
1208 
1209  /* List AV_PIX_FMT_VULKAN first to prefer it when possible */
1210  if (s->have_hwdevice) {
1211  RET(ff_add_format(&infmts, AV_PIX_FMT_VULKAN));
1212  if (s->out_format == AV_PIX_FMT_NONE || av_vkfmt_from_pixfmt(s->out_format))
1213  RET(ff_add_format(&outfmts, AV_PIX_FMT_VULKAN));
1214  }
1215 
1216  while ((desc = av_pix_fmt_desc_next(desc))) {
1217  enum AVPixelFormat pixfmt = av_pix_fmt_desc_get_id(desc);
1218  if (pixfmt == AV_PIX_FMT_VULKAN)
1219  continue; /* Handled above */
1220 
1221 #if PL_API_VER < 232
1222  // Older libplacebo can't handle >64-bit pixel formats, so safe-guard
1223  // this to prevent triggering an assertion
1224  if (av_get_bits_per_pixel(desc) > 64)
1225  continue;
1226 #endif
1227 
1228  if (!pl_test_pixfmt(s->gpu, pixfmt))
1229  continue;
1230 
1231  RET(ff_add_format(&infmts, pixfmt));
1232 
1233  /* Filter for supported output pixel formats */
1234  if (desc->flags & AV_PIX_FMT_FLAG_BE)
1235  continue; /* BE formats are not supported by pl_download_avframe */
1236 
1237  /* Mask based on user specified format */
1238  if (pixfmt != s->out_format && s->out_format != AV_PIX_FMT_NONE)
1239  continue;
1240 
1241 #if PL_API_VER >= 293
1242  if (!pl_test_pixfmt_caps(s->gpu, pixfmt, PL_FMT_CAP_RENDERABLE))
1243  continue;
1244 #endif
1245 
1246  RET(ff_add_format(&outfmts, pixfmt));
1247  }
1248 
1249  if (!infmts || !outfmts) {
1250  err = AVERROR(EINVAL);
1251  goto fail;
1252  }
1253 
1254  for (int i = 0; i < s->nb_inputs; i++) {
1255  if (i > 0) {
1256  /* Duplicate the format list for each subsequent input */
1257  infmts = NULL;
1258  for (int n = 0; n < cfg_in[0]->formats->nb_formats; n++)
1259  RET(ff_add_format(&infmts, cfg_in[0]->formats->formats[n]));
1260  }
1261  RET(ff_formats_ref(infmts, &cfg_in[i]->formats));
1262  RET(ff_formats_ref(ff_all_color_spaces(), &cfg_in[i]->color_spaces));
1263  RET(ff_formats_ref(ff_all_color_ranges(), &cfg_in[i]->color_ranges));
1264  }
1265 
1266  RET(ff_formats_ref(outfmts, &cfg_out[0]->formats));
1267 
1268  outfmts = s->colorspace > 0 ? ff_make_formats_list_singleton(s->colorspace)
1269  : ff_all_color_spaces();
1270  RET(ff_formats_ref(outfmts, &cfg_out[0]->color_spaces));
1271 
1272  outfmts = s->color_range > 0 ? ff_make_formats_list_singleton(s->color_range)
1273  : ff_all_color_ranges();
1274  RET(ff_formats_ref(outfmts, &cfg_out[0]->color_ranges));
1275  return 0;
1276 
1277 fail:
1278  if (infmts && !infmts->refcount)
1279  ff_formats_unref(&infmts);
1280  if (outfmts && !outfmts->refcount)
1281  ff_formats_unref(&outfmts);
1282  return err;
1283 }
1284 
1285 static int libplacebo_config_input(AVFilterLink *inlink)
1286 {
1287  AVFilterContext *avctx = inlink->dst;
1288  LibplaceboContext *s = avctx->priv;
1289 
1290  if (s->rotation % PL_ROTATION_180 == PL_ROTATION_90) {
1291  /* Swap width and height for 90 degree rotations to make the size and
1292  * scaling calculations work out correctly */
1293  FFSWAP(int, inlink->w, inlink->h);
1294  if (inlink->sample_aspect_ratio.num)
1295  inlink->sample_aspect_ratio = av_inv_q(inlink->sample_aspect_ratio);
1296  }
1297 
1298  if (inlink->format == AV_PIX_FMT_VULKAN)
1299  return ff_vk_filter_config_input(inlink);
1300 
1301  /* Forward this to the vkctx for format selection */
1302  s->vkctx.input_format = inlink->format;
1303 
1304  return 0;
1305 }
1306 
1307 static inline AVRational max_q(AVRational a, AVRational b)
1308 {
1309  return av_cmp_q(a, b) < 0 ? b : a;
1310 }
1311 
1312 static int libplacebo_config_output(AVFilterLink *outlink)
1313 {
1314  int err;
1315  FilterLink *l = ff_filter_link(outlink);
1316  AVFilterContext *avctx = outlink->src;
1317  LibplaceboContext *s = avctx->priv;
1318  AVFilterLink *inlink = outlink->src->inputs[0];
1319  FilterLink *ol = ff_filter_link(outlink);
1320  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
1321  const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
1322  AVHWFramesContext *hwfc;
1323  AVVulkanFramesContext *vkfc;
1324 
1325  /* Frame dimensions */
1326  RET(ff_scale_eval_dimensions(s, s->w_expr, s->h_expr, inlink, outlink,
1327  &outlink->w, &outlink->h));
1328 
1329  s->reset_sar |= s->normalize_sar || s->nb_inputs > 1;
1330  double sar_in = inlink->sample_aspect_ratio.num ?
1331  av_q2d(inlink->sample_aspect_ratio) : 1.0;
1332 
1333  ff_scale_adjust_dimensions(inlink, &outlink->w, &outlink->h,
1334  s->force_original_aspect_ratio,
1335  s->force_divisible_by,
1336  s->reset_sar ? sar_in : 1.0);
1337 
1338 
1339  if (s->nb_inputs > 1 && !s->disable_fbos) {
1340  /* Create a separate renderer and composition texture */
1341  pl_fmt fmt = pl_find_fmt(s->gpu, PL_FMT_FLOAT, 4, 16, 0, PL_FMT_CAP_BLENDABLE);
1342  bool ok = !!fmt;
1343  if (ok) {
1344  ok = pl_tex_recreate(s->gpu, &s->linear_tex, pl_tex_params(
1345  .format = fmt,
1346  .w = outlink->w,
1347  .h = outlink->h,
1348  .renderable = true,
1349  .sampleable = true,
1350  .storable = fmt->caps & PL_FMT_CAP_STORABLE,
1351  ));
1352  }
1353 
1354  if (!ok) {
1355  av_log(s, AV_LOG_WARNING, "Failed to create a linear texture for "
1356  "compositing multiple inputs, falling back to non-linear "
1357  "blending.\n");
1358  }
1359  }
1360 
1361  if (s->reset_sar) {
1362  /* SAR is normalized, or we have multiple inputs, set out to 1:1 */
1363  outlink->sample_aspect_ratio = (AVRational){ 1, 1 };
1364  } else if (inlink->sample_aspect_ratio.num) {
1365  /* This is consistent with other scale_* filters, which only
1366  * set the outlink SAR to be equal to the scale SAR iff the input SAR
1367  * was set to something nonzero */
1368  const AVRational ar_in = { inlink->w, inlink->h };
1369  const AVRational ar_out = { outlink->w, outlink->h };
1370  const AVRational stretch = av_div_q(ar_in, ar_out);
1371  outlink->sample_aspect_ratio = av_mul_q(inlink->sample_aspect_ratio, stretch);
1372  } else {
1373  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
1374  }
1375 
1376  /* Frame rate */
1377  if (s->fps.num) {
1378  ol->frame_rate = s->fps;
1379  outlink->time_base = av_inv_q(s->fps);
1380  } else {
1381  FilterLink *il = ff_filter_link(avctx->inputs[0]);
1382  ol->frame_rate = il->frame_rate;
1383  outlink->time_base = avctx->inputs[0]->time_base;
1384  for (int i = 1; i < s->nb_inputs; i++) {
1385  il = ff_filter_link(avctx->inputs[i]);
1386  ol->frame_rate = max_q(ol->frame_rate, il->frame_rate);
1387  outlink->time_base = av_gcd_q(outlink->time_base,
1388  avctx->inputs[i]->time_base,
1389  AV_TIME_BASE / 2, AV_TIME_BASE_Q);
1390  }
1391 
1392  if (s->deinterlace && s->send_fields) {
1393  const AVRational q2 = { 2, 1 };
1394  ol->frame_rate = av_mul_q(ol->frame_rate, q2);
1395  /* Ensure output frame timestamps are divisible by two */
1396  outlink->time_base = av_div_q(outlink->time_base, q2);
1397  }
1398  }
1399 
1400  /* Static variables */
1401  s->var_values[VAR_OUT_W] = s->var_values[VAR_OW] = outlink->w;
1402  s->var_values[VAR_OUT_H] = s->var_values[VAR_OH] = outlink->h;
1403  s->var_values[VAR_DAR] = outlink->sample_aspect_ratio.num ?
1404  av_q2d(outlink->sample_aspect_ratio) : 1.0;
1405  s->var_values[VAR_HSUB] = 1 << desc->log2_chroma_w;
1406  s->var_values[VAR_VSUB] = 1 << desc->log2_chroma_h;
1407  s->var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;
1408  s->var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;
1409 
1410  if (outlink->format != AV_PIX_FMT_VULKAN)
1411  return 0;
1412 
1413  s->vkctx.output_width = outlink->w;
1414  s->vkctx.output_height = outlink->h;
1415  /* Default to reusing the input format */
1416  if (s->out_format == AV_PIX_FMT_NONE || s->out_format == AV_PIX_FMT_VULKAN) {
1417  s->vkctx.output_format = s->vkctx.input_format;
1418  } else {
1419  s->vkctx.output_format = s->out_format;
1420  }
1421  RET(ff_vk_filter_config_output(outlink));
1422  hwfc = (AVHWFramesContext *)l->hw_frames_ctx->data;
1423  vkfc = hwfc->hwctx;
1424  vkfc->usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1425 
1426  return 0;
1427 
1428 fail:
1429  return err;
1430 }
1431 
1432 #define OFFSET(x) offsetof(LibplaceboContext, x)
1433 #define STATIC (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
1434 #define DYNAMIC (STATIC | AV_OPT_FLAG_RUNTIME_PARAM)
1435 
1436 static const AVOption libplacebo_options[] = {
1437  { "inputs", "Number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags = STATIC },
1438  { "w", "Output video frame width", OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, .flags = STATIC },
1439  { "h", "Output video frame height", OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, .flags = STATIC },
1440  { "fps", "Output video frame rate", OFFSET(fps_string), AV_OPT_TYPE_STRING, {.str = "none"}, .flags = STATIC },
1441  { "crop_x", "Input video crop x", OFFSET(crop_x_expr), AV_OPT_TYPE_STRING, {.str = "(iw-cw)/2"}, .flags = DYNAMIC },
1442  { "crop_y", "Input video crop y", OFFSET(crop_y_expr), AV_OPT_TYPE_STRING, {.str = "(ih-ch)/2"}, .flags = DYNAMIC },
1443  { "crop_w", "Input video crop w", OFFSET(crop_w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, .flags = DYNAMIC },
1444  { "crop_h", "Input video crop h", OFFSET(crop_h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, .flags = DYNAMIC },
1445  { "pos_x", "Output video placement x", OFFSET(pos_x_expr), AV_OPT_TYPE_STRING, {.str = "(ow-pw)/2"}, .flags = DYNAMIC },
1446  { "pos_y", "Output video placement y", OFFSET(pos_y_expr), AV_OPT_TYPE_STRING, {.str = "(oh-ph)/2"}, .flags = DYNAMIC },
1447  { "pos_w", "Output video placement w", OFFSET(pos_w_expr), AV_OPT_TYPE_STRING, {.str = "ow"}, .flags = DYNAMIC },
1448  { "pos_h", "Output video placement h", OFFSET(pos_h_expr), AV_OPT_TYPE_STRING, {.str = "oh"}, .flags = DYNAMIC },
1449  { "format", "Output video format", OFFSET(out_format_string), AV_OPT_TYPE_STRING, .flags = STATIC },
1450  { "force_original_aspect_ratio", "decrease or increase w/h if necessary to keep the original AR", OFFSET(force_original_aspect_ratio), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, STATIC, .unit = "force_oar" },
1451  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, STATIC, .unit = "force_oar" },
1452  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, STATIC, .unit = "force_oar" },
1453  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, STATIC, .unit = "force_oar" },
1454  { "force_divisible_by", "enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used", OFFSET(force_divisible_by), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 256, STATIC },
1455  { "reset_sar", "force SAR normalization to 1:1 by adjusting pos_x/y/w/h", OFFSET(reset_sar), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, STATIC },
1456  { "normalize_sar", "like reset_sar, but pad/crop instead of stretching the video", OFFSET(normalize_sar), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, STATIC },
1457  { "pad_crop_ratio", "ratio between padding and cropping when normalizing SAR (0=pad, 1=crop)", OFFSET(pad_crop_ratio), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, 1.0, DYNAMIC },
1458  { "fillcolor", "Background fill color", OFFSET(fillcolor), AV_OPT_TYPE_COLOR, {.str = "black@0"}, .flags = DYNAMIC },
1459  { "corner_rounding", "Corner rounding radius", OFFSET(corner_rounding), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, 0.0, 1.0, .flags = DYNAMIC },
1460  { "extra_opts", "Pass extra libplacebo-specific options using a :-separated list of key=value pairs", OFFSET(extra_opts), AV_OPT_TYPE_DICT, .flags = DYNAMIC },
1461 #if PL_API_VER >= 351
1462  { "shader_cache", "Set shader cache path", OFFSET(shader_cache), AV_OPT_TYPE_STRING, {.str = NULL}, .flags = STATIC },
1463 #endif
1464 
1465  {"colorspace", "select colorspace", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64=-1}, -1, AVCOL_SPC_NB-1, DYNAMIC, .unit = "colorspace"},
1466  {"auto", "keep the same colorspace", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1467  {"gbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_RGB}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1468  {"bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT709}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1469  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_UNSPECIFIED}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1470  {"bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT470BG}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1471  {"smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_SMPTE170M}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1472  {"smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_SMPTE240M}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1473  {"ycgco", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_YCGCO}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1474  {"bt2020nc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT2020_NCL}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1475  {"bt2020c", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT2020_CL}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1476  {"ictcp", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_ICTCP}, INT_MIN, INT_MAX, STATIC, .unit = "colorspace"},
1477 
1478  {"range", "select color range", OFFSET(color_range), AV_OPT_TYPE_INT, {.i64=-1}, -1, AVCOL_RANGE_NB-1, DYNAMIC, .unit = "range"},
1479  {"auto", "keep the same color range", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, STATIC, .unit = "range"},
1480  {"unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_UNSPECIFIED}, 0, 0, STATIC, .unit = "range"},
1481  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_UNSPECIFIED}, 0, 0, STATIC, .unit = "range"},
1482  {"limited", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, STATIC, .unit = "range"},
1483  {"tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, STATIC, .unit = "range"},
1484  {"mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, STATIC, .unit = "range"},
1485  {"full", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, STATIC, .unit = "range"},
1486  {"pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, STATIC, .unit = "range"},
1487  {"jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, STATIC, .unit = "range"},
1488 
1489  {"color_primaries", "select color primaries", OFFSET(color_primaries), AV_OPT_TYPE_INT, {.i64=-1}, -1, AVCOL_PRI_NB-1, DYNAMIC, .unit = "color_primaries"},
1490  {"auto", "keep the same color primaries", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1491  {"bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT709}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1492  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_UNSPECIFIED}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1493  {"bt470m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT470M}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1494  {"bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT470BG}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1495  {"smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE170M}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1496  {"smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE240M}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1497  {"film", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_FILM}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1498  {"bt2020", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT2020}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1499  {"smpte428", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE428}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1500  {"smpte431", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE431}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1501  {"smpte432", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE432}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1502  {"jedec-p22", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_JEDEC_P22}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1503  {"ebu3213", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_EBU3213}, INT_MIN, INT_MAX, STATIC, .unit = "color_primaries"},
1504 
1505  {"color_trc", "select color transfer", OFFSET(color_trc), AV_OPT_TYPE_INT, {.i64=-1}, -1, AVCOL_TRC_NB-1, DYNAMIC, .unit = "color_trc"},
1506  {"auto", "keep the same color transfer", 0, AV_OPT_TYPE_CONST, {.i64=-1}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1507  {"bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT709}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1508  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_UNSPECIFIED}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1509  {"bt470m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA22}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1510  {"bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA28}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1511  {"smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE170M}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1512  {"smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE240M}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1513  {"linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_LINEAR}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1514  {"iec61966-2-4", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_4}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1515  {"bt1361e", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT1361_ECG}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1516  {"iec61966-2-1", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_1}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1517  {"bt2020-10", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT2020_10}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1518  {"bt2020-12", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT2020_12}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1519  {"smpte2084", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE2084}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1520  {"arib-std-b67", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_ARIB_STD_B67}, INT_MIN, INT_MAX, STATIC, .unit = "color_trc"},
1521 
1522  {"rotate", "rotate the input clockwise", OFFSET(rotation), AV_OPT_TYPE_INT, {.i64=PL_ROTATION_0}, PL_ROTATION_0, PL_ROTATION_360, DYNAMIC, .unit = "rotation"},
1523  {"0", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PL_ROTATION_0}, .flags = STATIC, .unit = "rotation"},
1524  {"90", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PL_ROTATION_90}, .flags = STATIC, .unit = "rotation"},
1525  {"180", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PL_ROTATION_180}, .flags = STATIC, .unit = "rotation"},
1526  {"270", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PL_ROTATION_270}, .flags = STATIC, .unit = "rotation"},
1527  {"360", NULL, 0, AV_OPT_TYPE_CONST, {.i64=PL_ROTATION_360}, .flags = STATIC, .unit = "rotation"},
1528 
1529  { "upscaler", "Upscaler function", OFFSET(upscaler), AV_OPT_TYPE_STRING, {.str = "spline36"}, .flags = DYNAMIC },
1530  { "downscaler", "Downscaler function", OFFSET(downscaler), AV_OPT_TYPE_STRING, {.str = "mitchell"}, .flags = DYNAMIC },
1531  { "frame_mixer", "Frame mixing function", OFFSET(frame_mixer), AV_OPT_TYPE_STRING, {.str = "none"}, .flags = DYNAMIC },
1532  { "antiringing", "Antiringing strength (for non-EWA filters)", OFFSET(antiringing), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, 0.0, 1.0, DYNAMIC },
1533  { "sigmoid", "Enable sigmoid upscaling", OFFSET(sigmoid), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DYNAMIC },
1534  { "apply_filmgrain", "Apply film grain metadata", OFFSET(apply_filmgrain), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DYNAMIC },
1535  { "apply_dolbyvision", "Apply Dolby Vision metadata", OFFSET(apply_dovi), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DYNAMIC },
1536 
1537  { "deinterlace", "Deinterlacing mode", OFFSET(deinterlace), AV_OPT_TYPE_INT, {.i64 = PL_DEINTERLACE_WEAVE}, 0, PL_DEINTERLACE_ALGORITHM_COUNT - 1, DYNAMIC, .unit = "deinterlace" },
1538  { "weave", "Weave fields together (no-op)", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DEINTERLACE_WEAVE}, 0, 0, STATIC, .unit = "deinterlace" },
1539  { "bob", "Naive bob deinterlacing", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DEINTERLACE_BOB}, 0, 0, STATIC, .unit = "deinterlace" },
1540  { "yadif", "Yet another deinterlacing filter", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DEINTERLACE_YADIF}, 0, 0, STATIC, .unit = "deinterlace" },
1541  { "skip_spatial_check", "Skip yadif spatial check", OFFSET(skip_spatial_check), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1542  { "send_fields", "Output a frame for each field", OFFSET(send_fields), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1543 
1544  { "deband", "Enable debanding", OFFSET(deband), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1545  { "deband_iterations", "Deband iterations", OFFSET(deband_iterations), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 16, DYNAMIC },
1546  { "deband_threshold", "Deband threshold", OFFSET(deband_threshold), AV_OPT_TYPE_FLOAT, {.dbl = 4.0}, 0.0, 1024.0, DYNAMIC },
1547  { "deband_radius", "Deband radius", OFFSET(deband_radius), AV_OPT_TYPE_FLOAT, {.dbl = 16.0}, 0.0, 1024.0, DYNAMIC },
1548  { "deband_grain", "Deband grain", OFFSET(deband_grain), AV_OPT_TYPE_FLOAT, {.dbl = 6.0}, 0.0, 1024.0, DYNAMIC },
1549 
1550  { "brightness", "Brightness boost", OFFSET(brightness), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, -1.0, 1.0, DYNAMIC },
1551  { "contrast", "Contrast gain", OFFSET(contrast), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 16.0, DYNAMIC },
1552  { "saturation", "Saturation gain", OFFSET(saturation), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 16.0, DYNAMIC },
1553  { "hue", "Hue shift", OFFSET(hue), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, -M_PI, M_PI, DYNAMIC },
1554  { "gamma", "Gamma adjustment", OFFSET(gamma), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 16.0, DYNAMIC },
1555 
1556  { "peak_detect", "Enable dynamic peak detection for HDR tone-mapping", OFFSET(peakdetect), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DYNAMIC },
1557  { "smoothing_period", "Peak detection smoothing period", OFFSET(smoothing), AV_OPT_TYPE_FLOAT, {.dbl = 100.0}, 0.0, 1000.0, DYNAMIC },
1558  { "scene_threshold_low", "Scene change low threshold", OFFSET(scene_low), AV_OPT_TYPE_FLOAT, {.dbl = 5.5}, -1.0, 100.0, DYNAMIC },
1559  { "scene_threshold_high", "Scene change high threshold", OFFSET(scene_high), AV_OPT_TYPE_FLOAT, {.dbl = 10.0}, -1.0, 100.0, DYNAMIC },
1560  { "percentile", "Peak detection percentile", OFFSET(percentile), AV_OPT_TYPE_FLOAT, {.dbl = 99.995}, 0.0, 100.0, DYNAMIC },
1561 
1562  { "gamut_mode", "Gamut-mapping mode", OFFSET(gamut_mode), AV_OPT_TYPE_INT, {.i64 = GAMUT_MAP_PERCEPTUAL}, 0, GAMUT_MAP_COUNT - 1, DYNAMIC, .unit = "gamut_mode" },
1563  { "clip", "Hard-clip (RGB per-channel)", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_CLIP}, 0, 0, STATIC, .unit = "gamut_mode" },
1564  { "perceptual", "Colorimetric soft clipping", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_PERCEPTUAL}, 0, 0, STATIC, .unit = "gamut_mode" },
1565  { "relative", "Relative colorimetric clipping", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_RELATIVE}, 0, 0, STATIC, .unit = "gamut_mode" },
1566  { "saturation", "Saturation mapping (RGB -> RGB)", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_SATURATION}, 0, 0, STATIC, .unit = "gamut_mode" },
1567  { "absolute", "Absolute colorimetric clipping", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_ABSOLUTE}, 0, 0, STATIC, .unit = "gamut_mode" },
1568  { "desaturate", "Colorimetrically desaturate colors towards white", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_DESATURATE}, 0, 0, STATIC, .unit = "gamut_mode" },
1569  { "darken", "Colorimetric clip with bias towards darkening image to fit gamut", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_DARKEN}, 0, 0, STATIC, .unit = "gamut_mode" },
1570  { "warn", "Highlight out-of-gamut colors", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_HIGHLIGHT}, 0, 0, STATIC, .unit = "gamut_mode" },
1571  { "linear", "Linearly reduce chromaticity to fit gamut", 0, AV_OPT_TYPE_CONST, {.i64 = GAMUT_MAP_LINEAR}, 0, 0, STATIC, .unit = "gamut_mode" },
1572  { "tonemapping", "Tone-mapping algorithm", OFFSET(tonemapping), AV_OPT_TYPE_INT, {.i64 = TONE_MAP_AUTO}, 0, TONE_MAP_COUNT - 1, DYNAMIC, .unit = "tonemap" },
1573  { "auto", "Automatic selection", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_AUTO}, 0, 0, STATIC, .unit = "tonemap" },
1574  { "clip", "No tone mapping (clip", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_CLIP}, 0, 0, STATIC, .unit = "tonemap" },
1575 #if PL_API_VER >= 246
1576  { "st2094-40", "SMPTE ST 2094-40", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_ST2094_40}, 0, 0, STATIC, .unit = "tonemap" },
1577  { "st2094-10", "SMPTE ST 2094-10", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_ST2094_10}, 0, 0, STATIC, .unit = "tonemap" },
1578 #endif
1579  { "bt.2390", "ITU-R BT.2390 EETF", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_BT2390}, 0, 0, STATIC, .unit = "tonemap" },
1580  { "bt.2446a", "ITU-R BT.2446 Method A", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_BT2446A}, 0, 0, STATIC, .unit = "tonemap" },
1581  { "spline", "Single-pivot polynomial spline", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_SPLINE}, 0, 0, STATIC, .unit = "tonemap" },
1582  { "reinhard", "Reinhard", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_REINHARD}, 0, 0, STATIC, .unit = "tonemap" },
1583  { "mobius", "Mobius", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_MOBIUS}, 0, 0, STATIC, .unit = "tonemap" },
1584  { "hable", "Filmic tone-mapping (Hable)", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_HABLE}, 0, 0, STATIC, .unit = "tonemap" },
1585  { "gamma", "Gamma function with knee", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_GAMMA}, 0, 0, STATIC, .unit = "tonemap" },
1586  { "linear", "Perceptually linear stretch", 0, AV_OPT_TYPE_CONST, {.i64 = TONE_MAP_LINEAR}, 0, 0, STATIC, .unit = "tonemap" },
1587  { "tonemapping_param", "Tunable parameter for some tone-mapping functions", OFFSET(tonemapping_param), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, 0.0, 100.0, .flags = DYNAMIC },
1588  { "inverse_tonemapping", "Inverse tone mapping (range expansion)", OFFSET(inverse_tonemapping), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1589  { "tonemapping_lut_size", "Tone-mapping LUT size", OFFSET(tonemapping_lut_size), AV_OPT_TYPE_INT, {.i64 = 256}, 2, 1024, DYNAMIC },
1590  { "contrast_recovery", "HDR contrast recovery strength", OFFSET(contrast_recovery), AV_OPT_TYPE_FLOAT, {.dbl = 0.30}, 0.0, 3.0, DYNAMIC },
1591  { "contrast_smoothness", "HDR contrast recovery smoothness", OFFSET(contrast_smoothness), AV_OPT_TYPE_FLOAT, {.dbl = 3.50}, 1.0, 32.0, DYNAMIC },
1592 
1593  { "dithering", "Dither method to use", OFFSET(dithering), AV_OPT_TYPE_INT, {.i64 = PL_DITHER_BLUE_NOISE}, -1, PL_DITHER_METHOD_COUNT - 1, DYNAMIC, .unit = "dither" },
1594  { "none", "Disable dithering", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, STATIC, .unit = "dither" },
1595  { "blue", "Blue noise", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DITHER_BLUE_NOISE}, 0, 0, STATIC, .unit = "dither" },
1596  { "ordered", "Ordered LUT", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DITHER_ORDERED_LUT}, 0, 0, STATIC, .unit = "dither" },
1597  { "ordered_fixed", "Fixed function ordered", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DITHER_ORDERED_FIXED}, 0, 0, STATIC, .unit = "dither" },
1598  { "white", "White noise", 0, AV_OPT_TYPE_CONST, {.i64 = PL_DITHER_WHITE_NOISE}, 0, 0, STATIC, .unit = "dither" },
1599  { "dither_lut_size", "Dithering LUT size", OFFSET(dither_lut_size), AV_OPT_TYPE_INT, {.i64 = 6}, 1, 8, STATIC },
1600  { "dither_temporal", "Enable temporal dithering", OFFSET(dither_temporal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1601 
1602  { "cones", "Colorblindness adaptation model", OFFSET(cones), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, PL_CONE_LMS, DYNAMIC, .unit = "cone" },
1603  { "l", "L cone", 0, AV_OPT_TYPE_CONST, {.i64 = PL_CONE_L}, 0, 0, STATIC, .unit = "cone" },
1604  { "m", "M cone", 0, AV_OPT_TYPE_CONST, {.i64 = PL_CONE_M}, 0, 0, STATIC, .unit = "cone" },
1605  { "s", "S cone", 0, AV_OPT_TYPE_CONST, {.i64 = PL_CONE_S}, 0, 0, STATIC, .unit = "cone" },
1606  { "cone-strength", "Colorblindness adaptation strength", OFFSET(cone_str), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, 0.0, 10.0, DYNAMIC },
1607 
1608  { "custom_shader_path", "Path to custom user shader (mpv .hook format)", OFFSET(shader_path), AV_OPT_TYPE_STRING, .flags = STATIC },
1609  { "custom_shader_bin", "Custom user shader as binary (mpv .hook format)", OFFSET(shader_bin), AV_OPT_TYPE_BINARY, .flags = STATIC },
1610 
1611  /* Performance/quality tradeoff options */
1612  { "skip_aa", "Skip anti-aliasing", OFFSET(skip_aa), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1613  { "disable_linear", "Disable linear scaling", OFFSET(disable_linear), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1614  { "disable_builtin", "Disable built-in scalers", OFFSET(disable_builtin), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1615  { "force_dither", "Force dithering", OFFSET(force_dither), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1616  { "disable_fbos", "Force-disable FBOs", OFFSET(disable_fbos), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC },
1617  { NULL },
1618 };
1619 
1620 AVFILTER_DEFINE_CLASS(libplacebo);
1621 
1622 static const AVFilterPad libplacebo_outputs[] = {
1623  {
1624  .name = "default",
1625  .type = AVMEDIA_TYPE_VIDEO,
1626  .config_props = &libplacebo_config_output,
1627  },
1628 };
1629 
1630 const FFFilter ff_vf_libplacebo = {
1631  .p.name = "libplacebo",
1632  .p.description = NULL_IF_CONFIG_SMALL("Apply various GPU filters from libplacebo"),
1633  .p.priv_class = &libplacebo_class,
1634  .p.flags = AVFILTER_FLAG_HWDEVICE | AVFILTER_FLAG_DYNAMIC_INPUTS,
1635  .priv_size = sizeof(LibplaceboContext),
1636  .init = &libplacebo_init,
1637  .uninit = &libplacebo_uninit,
1638  .activate = &libplacebo_activate,
1639  .process_command = &libplacebo_process_command,
1640  FILTER_OUTPUTS(libplacebo_outputs),
1641  FILTER_QUERY_FUNC2(libplacebo_query_format),
1642  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
1643 };
flags
const SwsFlags flags[]
Definition: swscale.c:61
GAMUT_MAP_DARKEN
@ GAMUT_MAP_DARKEN
Definition: vf_libplacebo.c:89
formats
formats
Definition: signature.h:47
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:116
TONE_MAP_COUNT
@ TONE_MAP_COUNT
Definition: vf_libplacebo.c:79
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:88
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
av_fifo_drain2
void av_fifo_drain2(AVFifo *f, size_t size)
Discard the specified amount of data from an AVFifo.
Definition: fifo.c:266
LibplaceboContext::colorspace
int colorspace
Definition: vf_libplacebo.c:197
dithering
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion dithering
Definition: swscale-v2.txt:9
VAR_IH
@ VAR_IH
Definition: vf_libplacebo.c:121
LibplaceboContext::out_format
enum AVPixelFormat out_format
Definition: vf_libplacebo.c:175
AVVulkanDeviceContext::phys_dev
VkPhysicalDevice phys_dev
Physical device.
Definition: hwcontext_vulkan.h:79
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
level
uint8_t level
Definition: svq3.c:208
AVCOL_PRI_EBU3213
@ AVCOL_PRI_EBU3213
EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors.
Definition: pixfmt.h:652
TONE_MAP_SPLINE
@ TONE_MAP_SPLINE
Definition: vf_libplacebo.c:73
mix
static int mix(int c0, int c1)
Definition: 4xm.c:717
LibplaceboContext::fps_string
char * fps_string
Definition: vf_libplacebo.c:180
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
LibplaceboContext::percentile
float percentile
Definition: vf_libplacebo.c:248
LibplaceboContext::deband
int deband
Definition: vf_libplacebo.c:230
var_name
var_name
Definition: noise.c:47
GAMUT_MAP_CLIP
@ GAMUT_MAP_CLIP
Definition: vf_libplacebo.c:83
LibplaceboContext::deband_iterations
int deband_iterations
Definition: vf_libplacebo.c:231
LibplaceboContext::deband_threshold
float deband_threshold
Definition: vf_libplacebo.c:232
LibplaceboContext::gamut_mode
int gamut_mode
Definition: vf_libplacebo.c:251
out
FILE * out
Definition: movenc.c:55
VAR_IN_H
@ VAR_IN_H
Definition: vf_libplacebo.c:121
LibplaceboContext::crop_y_pexpr
AVExpr * crop_y_pexpr
Definition: vf_libplacebo.c:187
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:657
LibplaceboContext::linear_tex
pl_tex linear_tex
Definition: vf_libplacebo.c:165
LibplaceboContext::deinterlace
int deinterlace
Definition: vf_libplacebo.c:225
LibplaceboContext::contrast
float contrast
Definition: vf_libplacebo.c:238
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:769
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3441
VAR_OUT_T
@ VAR_OUT_T
Definition: vf_libplacebo.c:136
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
RET
#define RET(x)
Definition: vulkan.h:66
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:670
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:37
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
TONE_MAP_REINHARD
@ TONE_MAP_REINHARD
Definition: vf_libplacebo.c:74
pl_options_t::sigmoid_params
struct pl_sigmoid_params sigmoid_params
Definition: vf_libplacebo.c:54
saturation
static IPT saturation(const CmsCtx *ctx, IPT ipt)
Definition: cms.c:559
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
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_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
TONE_MAP_GAMMA
@ TONE_MAP_GAMMA
Definition: vf_libplacebo.c:77
VAR_OHSUB
@ VAR_OHSUB
Definition: vf_libplacebo.c:133
LibplaceboContext::apply_filmgrain
int apply_filmgrain
Definition: vf_libplacebo.c:195
find_scaler
static int find_scaler(AVFilterContext *avctx, const struct pl_filter_config **opt, const char *name, int frame_mixing)
Definition: vf_libplacebo.c:353
normalize.log
log
Definition: normalize.py:21
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:63
VAR_IN_IDX
@ VAR_IN_IDX
Definition: vf_libplacebo.c:119
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:559
update_settings
static int update_settings(AVFilterContext *ctx)
Definition: vf_libplacebo.c:378
av_fifo_peek
int av_fifo_peek(const AVFifo *f, void *buf, size_t nb_elems, size_t offset)
Read data from a FIFO without modifying FIFO state.
Definition: fifo.c:255
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:683
pl_options_t::deband_params
struct pl_deband_params deband_params
Definition: vf_libplacebo.c:53
AVVulkanDeviceContext::get_proc_addr
PFN_vkGetInstanceProcAddr get_proc_addr
Pointer to a vkGetInstanceProcAddr loading function.
Definition: hwcontext_vulkan.h:69
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:523
GAMUT_MAP_HIGHLIGHT
@ GAMUT_MAP_HIGHLIGHT
Definition: vf_libplacebo.c:90
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:767
pl_av_log
static void pl_av_log(void *log_ctx, enum pl_log_level level, const char *msg)
Definition: vf_libplacebo.c:288
AVOption
AVOption.
Definition: opt.h:429
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:710
b
#define b
Definition: input.c:42
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:664
LibplaceboContext
Definition: vf_libplacebo.c:153
LibplaceboInput::status
int status
Definition: vf_libplacebo.c:150
GAMUT_MAP_COUNT
@ GAMUT_MAP_COUNT
Definition: vf_libplacebo.c:92
LibplaceboContext::crop_h_pexpr
AVExpr * crop_h_pexpr
Definition: vf_libplacebo.c:187
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:3448
AVVulkanDeviceContext::inst
VkInstance inst
Vulkan instance.
Definition: hwcontext_vulkan.h:74
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
TONE_MAP_CLIP
@ TONE_MAP_CLIP
Definition: vf_libplacebo.c:68
AVCOL_PRI_JEDEC_P22
@ AVCOL_PRI_JEDEC_P22
Definition: pixfmt.h:653
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
LibplaceboContext::tex
pl_tex tex[4]
Definition: vf_libplacebo.c:161
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:691
ff_scale_eval_dimensions
int ff_scale_eval_dimensions(void *log_ctx, const char *w_expr, const char *h_expr, AVFilterLink *inlink, AVFilterLink *outlink, int *ret_w, int *ret_h)
Parse and evaluate string expressions for width and height.
Definition: scale_eval.c:57
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:677
handle_input
static int handle_input(AVFilterContext *ctx, LibplaceboInput *input)
Definition: vf_libplacebo.c:1056
AVFilterContext::hw_device_ctx
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
Definition: avfilter.h:351
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:3393
ff_vk_uninit
void ff_vk_uninit(FFVulkanContext *s)
Frees main context.
Definition: vulkan.c:2963
LibplaceboContext::sigmoid
int sigmoid
Definition: vf_libplacebo.c:217
LibplaceboContext::crop_h_expr
char * crop_h_expr
Definition: vf_libplacebo.c:183
AVDictionary
Definition: dict.c:32
pl_get_mapped_avframe
static AVFrame * pl_get_mapped_avframe(const struct pl_frame *frame)
Definition: vf_libplacebo.c:40
map_frame
static bool map_frame(pl_gpu gpu, pl_tex *tex, const struct pl_source_frame *src, struct pl_frame *out)
Definition: vf_libplacebo.c:1025
VAR_OT
@ VAR_OT
Definition: vf_libplacebo.c:136
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:215
pl_options_t::color_adjustment
struct pl_color_adjustment color_adjustment
Definition: vf_libplacebo.c:55
video.h
LibplaceboContext::vkctx
FFVulkanContext vkctx
Definition: vf_libplacebo.c:155
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:702
ff_make_formats_list_singleton
AVFilterFormats * ff_make_formats_list_singleton(int fmt)
Equivalent to ff_make_format_list({const int[]}{ fmt, -1 })
Definition: formats.c:529
VAR_CROP_H
@ VAR_CROP_H
Definition: vf_libplacebo.c:125
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
libplacebo_activate
static int libplacebo_activate(AVFilterContext *ctx)
Definition: vf_libplacebo.c:1118
AV_HWDEVICE_TYPE_VULKAN
@ AV_HWDEVICE_TYPE_VULKAN
Definition: hwcontext.h:39
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:649
formats.h
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:710
unmap_frame
static void unmap_frame(pl_gpu gpu, struct pl_frame *frame, const struct pl_source_frame *src)
Definition: vf_libplacebo.c:1044
VAR_VSUB
@ VAR_VSUB
Definition: vf_libplacebo.c:132
libplacebo_config_output
static int libplacebo_config_output(AVFilterLink *outlink)
Definition: vf_libplacebo.c:1312
VAR_PH
@ VAR_PH
Definition: vf_libplacebo.c:127
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1510
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:696
FF_FILTER_FORWARD_STATUS_BACK_ALL
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:651
fifo.h
AV_OPT_TYPE_BINARY
@ AV_OPT_TYPE_BINARY
Underlying C type is a uint8_t* that is either NULL or points to an array allocated with the av_mallo...
Definition: opt.h:286
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:675
av_file_map
int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, int log_offset, void *log_ctx)
Read the file with name filename, and put its content in a newly allocated buffer or map it with mmap...
Definition: file.c:55
LibplaceboContext::pos_w_pexpr
AVExpr * pos_w_pexpr
Definition: vf_libplacebo.c:188
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:284
LibplaceboContext::shader_bin_len
int shader_bin_len
Definition: vf_libplacebo.c:271
fail
#define fail()
Definition: checkasm.h:199
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
TONE_MAP_ST2094_10
@ TONE_MAP_ST2094_10
Definition: vf_libplacebo.c:70
vulkan_filter.h
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
AVCOL_RANGE_NB
@ AVCOL_RANGE_NB
Not part of ABI.
Definition: pixfmt.h:768
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:667
AVVulkanFramesContext
Allocated as AVHWFramesContext.hwctx, used to set pool-specific options.
Definition: hwcontext_vulkan.h:208
LibplaceboContext::nb_inputs
int nb_inputs
Definition: vf_libplacebo.c:169
lock_queue
static void lock_queue(AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index)
Definition: hwcontext_vulkan.c:1786
TONE_MAP_BT2390
@ TONE_MAP_BT2390
Definition: vf_libplacebo.c:71
LibplaceboContext::pos_y_expr
char * pos_y_expr
Definition: vf_libplacebo.c:184
pts
static int64_t pts
Definition: transcode_aac.c:644
LibplaceboContext::crop_y_expr
char * crop_y_expr
Definition: vf_libplacebo.c:182
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:151
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVRational::num
int num
Numerator.
Definition: rational.h:59
LibplaceboContext::contrast_smoothness
float contrast_smoothness
Definition: vf_libplacebo.c:257
VAR_CROP_W
@ VAR_CROP_W
Definition: vf_libplacebo.c:124
AV_SIDE_DATA_PROP_SIZE_DEPENDENT
@ AV_SIDE_DATA_PROP_SIZE_DEPENDENT
Side data depends on the video dimensions.
Definition: frame.h:303
LibplaceboInput::renderer
pl_renderer renderer
Definition: vf_libplacebo.c:144
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:666
GAMUT_MAP_LINEAR
@ GAMUT_MAP_LINEAR
Definition: vf_libplacebo.c:91
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
LibplaceboContext::extra_opts
AVDictionary * extra_opts
Definition: vf_libplacebo.c:202
VAR_OW
@ VAR_OW
Definition: vf_libplacebo.c:122
LibplaceboContext::antiringing
float antiringing
Definition: vf_libplacebo.c:216
preset
preset
Definition: vf_curves.c:47
avassert.h
AVVulkanDeviceQueueFamily::num
int num
Definition: hwcontext_vulkan.h:37
LibplaceboContext::pos_w_expr
char * pos_w_expr
Definition: vf_libplacebo.c:185
LibplaceboContext::disable_linear
int disable_linear
Definition: vf_libplacebo.c:219
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:236
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_libplacebo.c:138
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
LibplaceboContext::crop_x_expr
char * crop_x_expr
Definition: vf_libplacebo.c:182
FFFilter
Definition: filters.h:266
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:60
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:628
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1613
ref_frame
static const AVFrame * ref_frame(const struct pl_frame_mix *mix)
Definition: vf_libplacebo.c:799
output_frame
static int output_frame(AVFilterContext *ctx, int64_t pts)
Definition: vf_libplacebo.c:882
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:654
TONE_MAP_BT2446A
@ TONE_MAP_BT2446A
Definition: vf_libplacebo.c:72
LibplaceboContext::force_original_aspect_ratio
int force_original_aspect_ratio
Definition: vf_libplacebo.c:191
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:674
LibplaceboContext::force_dither
int force_dither
Definition: vf_libplacebo.c:221
LibplaceboContext::inputs
LibplaceboInput * inputs
Definition: vf_libplacebo.c:168
discard_frame
static void discard_frame(const struct pl_source_frame *src)
Definition: vf_libplacebo.c:1050
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:697
AVDictionaryEntry::key
char * key
Definition: dict.h:91
LibplaceboContext::opts
pl_options opts
Definition: vf_libplacebo.c:212
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:678
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
libplacebo_uninit
static void libplacebo_uninit(AVFilterContext *avctx)
Definition: vf_libplacebo.c:751
LibplaceboContext::frame_mixer
char * frame_mixer
Definition: vf_libplacebo.c:215
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
filters.h
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
LibplaceboContext::tonemapping
int tonemapping
Definition: vf_libplacebo.c:252
AVCOL_PRI_SMPTE428
@ AVCOL_PRI_SMPTE428
SMPTE ST 428-1 (CIE 1931 XYZ)
Definition: pixfmt.h:648
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVExpr
Definition: eval.c:158
LibplaceboContext::crop_w_expr
char * crop_w_expr
Definition: vf_libplacebo.c:183
LibplaceboContext::disable_builtin
int disable_builtin
Definition: vf_libplacebo.c:220
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
LibplaceboContext::color_trc
int color_trc
Definition: vf_libplacebo.c:200
libplacebo_process_command
static int libplacebo_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_libplacebo.c:786
VAR_IN_T
@ VAR_IN_T
Definition: vf_libplacebo.c:135
ff_vf_libplacebo
const FFFilter ff_vf_libplacebo
Definition: vf_libplacebo.c:1630
LibplaceboContext::w_expr
char * w_expr
Definition: vf_libplacebo.c:178
AVCOL_PRI_SMPTE240M
@ AVCOL_PRI_SMPTE240M
identical to above, also called "SMPTE C" even though it uses D65
Definition: pixfmt.h:645
LibplaceboInput
Definition: vf_libplacebo.c:142
color_range
color_range
Definition: vf_selectivecolor.c:43
pl_options_t::peak_detect_params
struct pl_peak_detect_params peak_detect_params
Definition: vf_libplacebo.c:56
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
LibplaceboContext::force_divisible_by
int force_divisible_by
Definition: vf_libplacebo.c:192
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
NAN
#define NAN
Definition: mathematics.h:115
av_file_unmap
void av_file_unmap(uint8_t *bufptr, size_t size)
Unmap or free the buffer bufptr created by av_file_map().
Definition: file.c:142
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:643
arg
const char * arg
Definition: jacosubdec.c:67
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:644
if
if(ret)
Definition: filter_design.txt:179
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:469
get_tonemapping_func
static const struct pl_tone_map_function * get_tonemapping_func(int tm)
Definition: vf_libplacebo.c:305
VAR_IW
@ VAR_IW
Definition: vf_libplacebo.c:120
AVVulkanDeviceContext
Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_vulkan.h:59
opts
AVDictionary * opts
Definition: movenc.c:51
VAR_PW
@ VAR_PW
Definition: vf_libplacebo.c:126
NULL
#define NULL
Definition: coverity.c:32
LibplaceboContext::dither_temporal
int dither_temporal
Definition: vf_libplacebo.c:262
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:597
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AVVulkanDeviceContext::nb_enabled_dev_extensions
int nb_enabled_dev_extensions
Definition: hwcontext_vulkan.h:113
LibplaceboContext::skip_aa
int skip_aa
Definition: vf_libplacebo.c:218
LibplaceboContext::shader_bin
void * shader_bin
Definition: vf_libplacebo.c:270
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
LibplaceboContext::cones
int cones
Definition: vf_libplacebo.c:265
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:673
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:132
LibplaceboContext::brightness
float brightness
Definition: vf_libplacebo.c:237
activate
filter_frame For filters that do not use the activate() callback
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Underlying C type is uint8_t[4].
Definition: opt.h:323
AVVulkanDeviceContext::unlock_queue
void(* unlock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index)
Similar to lock_queue(), unlocks a queue.
Definition: hwcontext_vulkan.h:178
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:277
LibplaceboContext::gpu
pl_gpu gpu
Definition: vf_libplacebo.c:160
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:638
ff_add_format
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:504
parseutils.h
VAR_OUT_W
@ VAR_OUT_W
Definition: vf_libplacebo.c:122
TONE_MAP_LINEAR
@ TONE_MAP_LINEAR
Definition: vf_libplacebo.c:78
AVFilterFormats::nb_formats
unsigned nb_formats
number of formats
Definition: formats.h:65
AVVulkanDeviceContext::nb_qf
int nb_qf
Definition: hwcontext_vulkan.h:189
ff_vk_filter_config_output
int ff_vk_filter_config_output(AVFilterLink *outlink)
Definition: vulkan_filter.c:209
AVVulkanFramesContext::usage
VkImageUsageFlagBits usage
Defines extra usage of output frames.
Definition: hwcontext_vulkan.h:227
LibplaceboContext::fillcolor
uint8_t fillcolor[4]
Definition: vf_libplacebo.c:176
double
double
Definition: af_crystalizer.c:132
AVCOL_TRC_BT2020_10
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:676
AVCOL_SPC_YCGCO
@ AVCOL_SPC_YCGCO
used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
Definition: pixfmt.h:699
VAR_OUT_H
@ VAR_OUT_H
Definition: vf_libplacebo.c:123
input_init
static int input_init(AVFilterContext *avctx, LibplaceboInput *input, int idx)
Definition: vf_libplacebo.c:625
LibplaceboContext::status_pts
int64_t status_pts
tracks status of most recently used input
Definition: vf_libplacebo.c:170
AVVulkanDeviceContext::qf
AVVulkanDeviceQueueFamily qf[64]
Queue families used.
Definition: hwcontext_vulkan.h:188
FFVulkanContext
Definition: vulkan.h:274
GAMUT_MAP_DESATURATE
@ GAMUT_MAP_DESATURATE
Definition: vf_libplacebo.c:88
ff_all_color_spaces
AVFilterFormats * ff_all_color_spaces(void)
Construct an AVFilterFormats representing all possible color spaces.
Definition: formats.c:630
AVFilterFormats::refcount
unsigned refcount
number of references to this list
Definition: formats.h:68
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1457
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:733
parse_shader
static int parse_shader(AVFilterContext *avctx, const void *shader, size_t len)
Definition: vf_libplacebo.c:495
set_gamut_mode
static void set_gamut_mode(struct pl_color_map_params *p, int gamut_mode)
Definition: vf_libplacebo.c:325
libplacebo_config_input
static int libplacebo_config_input(AVFilterLink *inlink)
Definition: vf_libplacebo.c:1285
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
VAR_CW
@ VAR_CW
Definition: vf_libplacebo.c:124
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:647
LibplaceboInput::status_pts
int64_t status_pts
Definition: vf_libplacebo.c:149
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: filters.h:207
LibplaceboContext::cone_str
float cone_str
Definition: vf_libplacebo.c:266
LibplaceboContext::reset_sar
int reset_sar
Definition: vf_libplacebo.c:193
LibplaceboContext::have_hwdevice
int have_hwdevice
Definition: vf_libplacebo.c:209
color_primaries
static const AVColorPrimariesDesc color_primaries[AVCOL_PRI_NB]
Definition: csp.c:76
init_vulkan
static int init_vulkan(AVFilterContext *avctx, const AVVulkanDeviceContext *hwctx)
Definition: vf_libplacebo.c:646
LibplaceboContext::hue
float hue
Definition: vf_libplacebo.c:240
AVCOL_TRC_SMPTE2084
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:678
AVCOL_PRI_SMPTE431
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:650
eval.h
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AVFifo
Definition: fifo.c:35
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:94
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:669
AVCOL_PRI_FILM
@ AVCOL_PRI_FILM
colour filters using Illuminant C
Definition: pixfmt.h:646
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_acrusher.c:307
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(libplacebo)
LibplaceboContext::deband_grain
float deband_grain
Definition: vf_libplacebo.c:234
LibplaceboInput::mix
struct pl_frame_mix mix
temporary storage
Definition: vf_libplacebo.c:147
AVFILTER_FLAG_HWDEVICE
#define AVFILTER_FLAG_HWDEVICE
The filter can create hardware frames using AVFilterContext.hw_device_ctx.
Definition: avfilter.h:183
LibplaceboContext::out_format_string
char * out_format_string
Definition: vf_libplacebo.c:174
LibplaceboContext::disable_fbos
int disable_fbos
Definition: vf_libplacebo.c:222
LibplaceboContext::saturation
float saturation
Definition: vf_libplacebo.c:239
LibplaceboContext::num_hooks
int num_hooks
Definition: vf_libplacebo.c:273
LibplaceboContext::status
int status
Definition: vf_libplacebo.c:171
libplacebo_options
static const AVOption libplacebo_options[]
Definition: vf_libplacebo.c:1436
scale_eval.h
sigmoid
static float sigmoid(float x)
Definition: vf_dnn_detect.c:90
frame.h
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:900
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:723
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
pl_options_alloc
#define pl_options_alloc(log)
Definition: vf_libplacebo.c:62
AVVulkanDeviceQueueFamily::idx
int idx
Definition: hwcontext_vulkan.h:35
ff_all_color_ranges
AVFilterFormats * ff_all_color_ranges(void)
Construct an AVFilterFormats representing all possible color ranges.
Definition: formats.c:646
LibplaceboContext::var_values
double var_values[VAR_VARS_NB]
Definition: vf_libplacebo.c:177
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
LibplaceboContext::normalize_sar
int normalize_sar
Definition: vf_libplacebo.c:194
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:3460
LibplaceboContext::corner_rounding
float corner_rounding
Definition: vf_libplacebo.c:190
LibplaceboContext::apply_dovi
int apply_dovi
Definition: vf_libplacebo.c:196
VAR_POS_H
@ VAR_POS_H
Definition: vf_libplacebo.c:127
av_frame_side_data_remove_by_props
void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, int props)
Remove and free all side data instances that match any of the given side data properties.
Definition: side_data.c:116
TONE_MAP_ST2094_40
@ TONE_MAP_ST2094_40
Definition: vf_libplacebo.c:69
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
LibplaceboContext::downscaler
char * downscaler
Definition: vf_libplacebo.c:214
LibplaceboContext::log
pl_log log
Definition: vf_libplacebo.c:158
LibplaceboContext::vulkan
pl_vulkan vulkan
Definition: vf_libplacebo.c:159
M_PI
#define M_PI
Definition: mathematics.h:67
AVVulkanDeviceContext::lock_queue
void(* lock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index)
Locks a queue, preventing other threads from submitting any command buffers to this queue.
Definition: hwcontext_vulkan.h:173
LibplaceboContext::pos_h_pexpr
AVExpr * pos_h_pexpr
Definition: vf_libplacebo.c:188
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:663
av_vkfmt_from_pixfmt
const VkFormat * av_vkfmt_from_pixfmt(enum AVPixelFormat p)
Returns the optimal per-plane Vulkan format for a given sw_format, one for each plane.
Definition: hwcontext_stub.c:30
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:698
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
get_log_level
static enum pl_log_level get_log_level(void)
Definition: vf_libplacebo.c:276
ff_formats_unref
void ff_formats_unref(AVFilterFormats **ref)
If *ref is non-NULL, remove *ref as a reference to the format list it currently points to,...
Definition: formats.c:717
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
LibplaceboContext::pos_x_expr
char * pos_x_expr
Definition: vf_libplacebo.c:184
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
LibplaceboContext::upscaler
char * upscaler
Definition: vf_libplacebo.c:213
pl_options_t::params
struct pl_render_params params
Definition: vf_libplacebo.c:51
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:701
pl_options_free
#define pl_options_free(ptr)
Definition: vf_libplacebo.c:63
av_gcd_q
AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def)
Return the best rational so that a and b are multiple of it.
Definition: rational.c:184
LibplaceboContext::gamma
float gamma
Definition: vf_libplacebo.c:241
algo
Definition: dct.c:59
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
VAR_OVSUB
@ VAR_OVSUB
Definition: vf_libplacebo.c:134
TONE_MAP_MOBIUS
@ TONE_MAP_MOBIUS
Definition: vf_libplacebo.c:75
LibplaceboInput::qstatus
enum pl_queue_status qstatus
Definition: vf_libplacebo.c:146
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:240
LibplaceboContext::tonemapping_lut_size
int tonemapping_lut_size
Definition: vf_libplacebo.c:255
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
LibplaceboContext::tonemapping_param
float tonemapping_param
Definition: vf_libplacebo.c:253
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
LibplaceboContext::pos_h_expr
char * pos_h_expr
Definition: vf_libplacebo.c:185
LibplaceboContext::color_primaries
int color_primaries
Definition: vf_libplacebo.c:199
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
var_names
static const char *const var_names[]
Definition: vf_libplacebo.c:95
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
LibplaceboContext::dithering
int dithering
Definition: vf_libplacebo.c:260
LibplaceboContext::scene_high
float scene_high
Definition: vf_libplacebo.c:247
STATIC
#define STATIC
Definition: vf_libplacebo.c:1433
drain_input_pts
static void drain_input_pts(LibplaceboInput *in, int64_t until)
Definition: vf_libplacebo.c:1111
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:644
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:750
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
LibplaceboContext::skip_spatial_check
int skip_spatial_check
Definition: vf_libplacebo.c:226
AV_SIDE_DATA_PROP_COLOR_DEPENDENT
@ AV_SIDE_DATA_PROP_COLOR_DEPENDENT
Side data depends on the video color space.
Definition: frame.h:310
LibplaceboInput::queue
pl_queue queue
Definition: vf_libplacebo.c:145
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
pl_options_t::dither_params
struct pl_dither_params dither_params
Definition: vf_libplacebo.c:58
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:641
ret
ret
Definition: filter_design.txt:187
pl_options_t::deinterlace_params
struct pl_deinterlace_params deinterlace_params
Definition: vf_libplacebo.c:52
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:204
pixfmt
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:367
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:75
TONE_MAP_AUTO
@ TONE_MAP_AUTO
Definition: vf_libplacebo.c:67
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
LibplaceboContext::scene_low
float scene_low
Definition: vf_libplacebo.c:246
VAR_OH
@ VAR_OH
Definition: vf_libplacebo.c:123
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
VAR_CH
@ VAR_CH
Definition: vf_libplacebo.c:125
LibplaceboContext::linear_rr
pl_renderer linear_rr
Definition: vf_libplacebo.c:164
unlock_queue
static void unlock_queue(AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index)
Definition: hwcontext_vulkan.c:1792
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
VAR_T
@ VAR_T
Definition: vf_libplacebo.c:135
TONE_MAP_HABLE
@ TONE_MAP_HABLE
Definition: vf_libplacebo.c:76
LibplaceboContext::peakdetect
int peakdetect
Definition: vf_libplacebo.c:244
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:3373
LibplaceboContext::deband_radius
float deband_radius
Definition: vf_libplacebo.c:233
LibplaceboInput::idx
int idx
Definition: vf_libplacebo.c:143
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:682
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
LibplaceboContext::contrast_recovery
float contrast_recovery
Definition: vf_libplacebo.c:256
VAR_IN_W
@ VAR_IN_W
Definition: vf_libplacebo.c:120
update_crops
static void update_crops(AVFilterContext *ctx, LibplaceboInput *in, struct pl_frame *target, double target_pts)
Definition: vf_libplacebo.c:808
libplacebo_outputs
static const AVFilterPad libplacebo_outputs[]
Definition: vf_libplacebo.c:1622
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
GAMUT_MAP_ABSOLUTE
@ GAMUT_MAP_ABSOLUTE
Definition: vf_libplacebo.c:87
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
VAR_HSUB
@ VAR_HSUB
Definition: vf_libplacebo.c:131
LibplaceboContext::inverse_tonemapping
int inverse_tonemapping
Definition: vf_libplacebo.c:254
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
LibplaceboContext::rotation
int rotation
Definition: vf_libplacebo.c:201
AVCOL_TRC_SMPTE170M
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:668
file.h
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
OFFSET
#define OFFSET(x)
Definition: vf_libplacebo.c:1432
VAR_SAR
@ VAR_SAR
Definition: vf_libplacebo.c:129
LibplaceboContext::fps
AVRational fps
parsed FPS, or 0/0 for "none"
Definition: vf_libplacebo.c:181
input_uninit
static void input_uninit(LibplaceboInput *input)
Definition: vf_libplacebo.c:639
AVFilterContext
An instance of a filter.
Definition: avfilter.h:269
GAMUT_MAP_PERCEPTUAL
@ GAMUT_MAP_PERCEPTUAL
Definition: vf_libplacebo.c:84
desc
const char * desc
Definition: libsvtav1.c:79
AVVulkanDeviceContext::enabled_dev_extensions
const char *const * enabled_dev_extensions
Enabled device extensions.
Definition: hwcontext_vulkan.h:112
ff_vk_filter_config_input
int ff_vk_filter_config_input(AVFilterLink *inlink)
Definition: vulkan_filter.c:176
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
libplacebo_query_format
static int libplacebo_query_format(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: vf_libplacebo.c:1200
mem.h
VAR_IDX
@ VAR_IDX
Definition: vf_libplacebo.c:119
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:126
LibplaceboInput::out_pts
AVFifo * out_pts
timestamps of wanted output frames
Definition: vf_libplacebo.c:148
LibplaceboContext::crop_w_pexpr
AVExpr * crop_w_pexpr
Definition: vf_libplacebo.c:187
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
LibplaceboContext::pad_crop_ratio
float pad_crop_ratio
Definition: vf_libplacebo.c:189
AVVulkanDeviceContext::act_dev
VkDevice act_dev
Active device.
Definition: hwcontext_vulkan.h:84
AVCOL_PRI_SMPTE432
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:651
AVDictionaryEntry
Definition: dict.h:90
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
VAR_POS_W
@ VAR_POS_W
Definition: vf_libplacebo.c:126
max_q
static AVRational max_q(AVRational a, AVRational b)
Definition: vf_libplacebo.c:1307
LibplaceboContext::smoothing
float smoothing
Definition: vf_libplacebo.c:245
GAMUT_MAP_RELATIVE
@ GAMUT_MAP_RELATIVE
Definition: vf_libplacebo.c:85
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
pl_options_t::color_map_params
struct pl_color_map_params color_map_params
Definition: vf_libplacebo.c:57
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
DYNAMIC
#define DYNAMIC
Definition: vf_libplacebo.c:1434
GAMUT_MAP_SATURATION
@ GAMUT_MAP_SATURATION
Definition: vf_libplacebo.c:86
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVVulkanDeviceQueueFamily
Definition: hwcontext_vulkan.h:33
VAR_N
@ VAR_N
Definition: vf_libplacebo.c:137
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
LibplaceboContext::shader_path
char * shader_path
Definition: vf_libplacebo.c:269
VAR_A
@ VAR_A
Definition: vf_libplacebo.c:128
LibplaceboContext::crop_x_pexpr
AVExpr * crop_x_pexpr
Definition: vf_libplacebo.c:187
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AVVulkanDeviceContext::device_features
VkPhysicalDeviceFeatures2 device_features
This structure should be set to the set of features that present and enabled during device creation.
Definition: hwcontext_vulkan.h:92
LibplaceboContext::color_range
int color_range
Definition: vf_libplacebo.c:198
AVDictionaryEntry::value
char * value
Definition: dict.h:92
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
LibplaceboContext::dither_lut_size
int dither_lut_size
Definition: vf_libplacebo.c:261
LibplaceboContext::pos_x_pexpr
AVExpr * pos_x_pexpr
Definition: vf_libplacebo.c:188
libplacebo_init
static int libplacebo_init(AVFilterContext *avctx)
Definition: vf_libplacebo.c:514
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:692
LibplaceboContext::h_expr
char * h_expr
Definition: vf_libplacebo.c:179
VAR_DAR
@ VAR_DAR
Definition: vf_libplacebo.c:130
pl_options_t::cone_params
struct pl_cone_params cone_params
Definition: vf_libplacebo.c:59
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:706
AVVulkanDeviceQueueFamily::flags
VkQueueFlagBits flags
Definition: hwcontext_vulkan.h:41
LibplaceboContext::hooks
const struct pl_hook * hooks[2]
Definition: vf_libplacebo.c:272
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
ff_scale_adjust_dimensions
int ff_scale_adjust_dimensions(AVFilterLink *inlink, int *ret_w, int *ret_h, int force_original_aspect_ratio, int force_divisible_by, double w_adj)
Transform evaluated width and height obtained from ff_scale_eval_dimensions into actual target width ...
Definition: scale_eval.c:113
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
LibplaceboContext::pos_y_pexpr
AVExpr * pos_y_pexpr
Definition: vf_libplacebo.c:188
src
#define src
Definition: vp8dsp.c:248
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:63
log_cb
static void log_cb(cmsContext ctx, cmsUInt32Number error, const char *str)
Definition: fflcms2.c:24
pl_options_t
Definition: vf_libplacebo.c:49
LibplaceboContext::send_fields
int send_fields
Definition: vf_libplacebo.c:227
Generated on Sun Aug 3 2025 19:22:57 for FFmpeg by   doxygen 1.8.17