FFmpeg
aom_film_grain.c
Go to the documentation of this file.
1 /*
2  * AOM film grain synthesis
3  * Copyright (c) 2023 Niklas Haas <ffmpeg@haasn.xyz>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * AOM film grain synthesis.
25  * @author Niklas Haas <ffmpeg@haasn.xyz>
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/buffer.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/mem.h"
32 
33 #include "aom_film_grain.h"
34 #include "get_bits.h"
35 
36 // Common/shared helpers (not dependent on BIT_DEPTH)
37 static inline int get_random_number(const int bits, unsigned *const state) {
38  const int r = *state;
39  unsigned bit = ((r >> 0) ^ (r >> 1) ^ (r >> 3) ^ (r >> 12)) & 1;
40  *state = (r >> 1) | (bit << 15);
41 
42  return av_zero_extend(*state >> (16 - bits), bits);
43 }
44 
45 static inline int round2(const int x, const uint64_t shift) {
46  return (x + ((1 << shift) >> 1)) >> shift;
47 }
48 
49 enum {
50  GRAIN_WIDTH = 82,
51  GRAIN_HEIGHT = 73,
52  SUB_GRAIN_WIDTH = 44,
53  SUB_GRAIN_HEIGHT = 38,
54  FG_BLOCK_SIZE = 32,
55 };
56 
57 static const int16_t gaussian_sequence[2048];
58 
59 #define BIT_DEPTH 16
60 #include "aom_film_grain_template.c"
61 #undef BIT_DEPTH
62 
63 #define BIT_DEPTH 8
64 #include "aom_film_grain_template.c"
65 #undef BIT_DEPTH
66 
67 
68 int ff_aom_apply_film_grain(AVFrame *out, const AVFrame *in,
69  const AVFilmGrainParams *params)
70 {
71  const AVFilmGrainAOMParams *const data = &params->codec.aom;
72  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(out->format);
73  const int subx = desc->log2_chroma_w, suby = desc->log2_chroma_h;
74  const int pxstep = desc->comp[0].step;
75 
76  av_assert0(out->format == in->format);
77  av_assert0(params->type == AV_FILM_GRAIN_PARAMS_AV1);
78 
79  // Copy over the non-modified planes
80  if (!params->codec.aom.num_y_points) {
81  av_image_copy_plane(out->data[0], out->linesize[0],
82  in->data[0], in->linesize[0],
83  out->width * pxstep, out->height);
84  }
85  for (int uv = 0; uv < 2; uv++) {
86  if (!data->num_uv_points[uv]) {
87  av_image_copy_plane(out->data[1+uv], out->linesize[1+uv],
88  in->data[1+uv], in->linesize[1+uv],
89  AV_CEIL_RSHIFT(out->width, subx) * pxstep,
90  AV_CEIL_RSHIFT(out->height, suby));
91  }
92  }
93 
94  switch (in->format) {
95  case AV_PIX_FMT_GRAY8:
96  case AV_PIX_FMT_YUV420P:
97  case AV_PIX_FMT_YUV422P:
98  case AV_PIX_FMT_YUV444P:
99  case AV_PIX_FMT_YUVJ420P:
100  case AV_PIX_FMT_YUVJ422P:
101  case AV_PIX_FMT_YUVJ444P:
102  return apply_film_grain_8(out, in, params);
103  case AV_PIX_FMT_GRAY9:
104  case AV_PIX_FMT_YUV420P9:
105  case AV_PIX_FMT_YUV422P9:
106  case AV_PIX_FMT_YUV444P9:
107  return apply_film_grain_16(out, in, params, 9);
108  case AV_PIX_FMT_GRAY10:
109  case AV_PIX_FMT_YUV420P10:
110  case AV_PIX_FMT_YUV422P10:
111  case AV_PIX_FMT_YUV444P10:
112  return apply_film_grain_16(out, in, params, 10);
113  case AV_PIX_FMT_GRAY12:
114  case AV_PIX_FMT_YUV420P12:
115  case AV_PIX_FMT_YUV422P12:
116  case AV_PIX_FMT_YUV444P12:
117  return apply_film_grain_16(out, in, params, 12);
118  }
119 
120  /* The AV1 spec only defines film grain synthesis for these formats */
121  return AVERROR_INVALIDDATA;
122 }
123 
124 int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params *s,
125  const uint8_t *payload, int payload_size)
126 {
127  GetBitContext gbc, *gb = &gbc;
128  AVFilmGrainAOMParams *aom;
129  AVFilmGrainParams *fgp = NULL, *ref = NULL;
130  int ret, num_sets, n, i, uv, num_y_coeffs, update_grain, luma_only;
131 
132  ret = init_get_bits8(gb, payload, payload_size);
133  if (ret < 0)
134  return ret;
135 
136  s->enable = get_bits1(gb);
137  if (!s->enable)
138  return 0;
139 
140  for (int i = 0; i < FF_ARRAY_ELEMS(s->sets); i++)
141  av_buffer_unref(&s->sets[i]);
142 
143  skip_bits(gb, 4); // reserved
144  num_sets = get_bits(gb, 3) + 1;
145  for (n = 0; n < num_sets; n++) {
146  int payload_4byte, payload_size, set_idx, apply_units_log2, vsc_flag;
147  int predict_scaling, predict_y_scaling, predict_uv_scaling[2];
148  int payload_bits, start_position;
149  size_t fgp_size;
150 
151  start_position = get_bits_count(gb);
152  payload_4byte = get_bits1(gb);
153  payload_size = get_bits(gb, payload_4byte ? 2 : 8);
154  set_idx = get_bits(gb, 3);
155 
156  fgp = av_film_grain_params_alloc(&fgp_size);
157  if (!fgp || s->sets[set_idx])
158  goto error;
159  aom = &fgp->codec.aom;
160 
161  fgp->type = get_bits1(gb) ? AV_FILM_GRAIN_PARAMS_AV1 : AV_FILM_GRAIN_PARAMS_NONE;
162  if (!fgp->type) {
163  av_freep(&fgp);
164  continue;
165  }
166 
167  fgp->seed = get_bits(gb, 16);
168  update_grain = get_bits1(gb);
169  if (!update_grain) {
170  av_freep(&fgp);
171  continue;
172  }
173 
174  apply_units_log2 = get_bits(gb, 4);
175  fgp->width = get_bits(gb, 12) << apply_units_log2;
176  fgp->height = get_bits(gb, 12) << apply_units_log2;
177  luma_only = get_bits1(gb);
178  if (luma_only) {
179  fgp->subsampling_x = fgp->subsampling_y = 0;
180  } else {
181  fgp->subsampling_x = get_bits1(gb);
182  fgp->subsampling_y = get_bits1(gb);
183  }
184 
185  fgp->bit_depth_luma = fgp->bit_depth_chroma = 0;
186  fgp->color_primaries = AVCOL_PRI_UNSPECIFIED;
187  fgp->color_trc = AVCOL_TRC_UNSPECIFIED;
188  fgp->color_space = AVCOL_SPC_UNSPECIFIED;
189  fgp->color_range = AVCOL_RANGE_UNSPECIFIED;
190 
191  vsc_flag = get_bits1(gb); // video_signal_characteristics_flag
192  if (vsc_flag) {
193  int cicp_flag;
194  fgp->bit_depth_luma = get_bits(gb, 3) + 8;
195  if (!luma_only)
196  fgp->bit_depth_chroma = fgp->bit_depth_luma;
197  cicp_flag = get_bits1(gb);
198  if (cicp_flag) {
199  fgp->color_primaries = get_bits(gb, 8);
200  fgp->color_trc = get_bits(gb, 8);
201  fgp->color_space = get_bits(gb, 8);
202  fgp->color_range = get_bits1(gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
203  if (fgp->color_primaries >= AVCOL_PRI_NB ||
204  fgp->color_primaries == AVCOL_PRI_RESERVED ||
205  fgp->color_primaries == AVCOL_PRI_RESERVED0 ||
206  fgp->color_trc >= AVCOL_TRC_NB ||
207  fgp->color_trc == AVCOL_TRC_RESERVED ||
208  fgp->color_trc == AVCOL_TRC_RESERVED0 ||
209  fgp->color_space >= AVCOL_SPC_NB ||
210  fgp->color_space == AVCOL_SPC_RESERVED)
211  goto error;
212  }
213  }
214 
215  predict_scaling = get_bits1(gb);
216  if (predict_scaling && !ref)
217  goto error; // prediction must be from valid, different set
218 
219  predict_y_scaling = predict_scaling ? get_bits1(gb) : 0;
220  if (predict_y_scaling) {
221  int y_scale, y_offset, bits_res;
222  y_scale = get_bits(gb, 9) - 256;
223  y_offset = get_bits(gb, 9) - 256;
224  bits_res = get_bits(gb, 3);
225  if (bits_res) {
226  int res[14], pred, granularity;
227  aom->num_y_points = ref->codec.aom.num_y_points;
228  for (i = 0; i < aom->num_y_points; i++)
229  res[i] = get_bits(gb, bits_res);
230  granularity = get_bits(gb, 3);
231  for (i = 0; i < aom->num_y_points; i++) {
232  pred = ref->codec.aom.y_points[i][1];
233  pred = ((pred * y_scale + 8) >> 4) + y_offset;
234  pred += (res[i] - (1 << (bits_res - 1))) * granularity;
235  aom->y_points[i][0] = ref->codec.aom.y_points[i][0];
236  aom->y_points[i][1] = av_clip_uint8(pred);
237  }
238  }
239  } else {
240  aom->num_y_points = get_bits(gb, 4);
241  if (aom->num_y_points > 14) {
242  goto error;
243  } else if (aom->num_y_points) {
244  int bits_inc, bits_scaling;
245  int y_value = 0;
246  bits_inc = get_bits(gb, 3) + 1;
247  bits_scaling = get_bits(gb, 2) + 5;
248  for (i = 0; i < aom->num_y_points; i++) {
249  y_value += get_bits(gb, bits_inc);
250  if (y_value > UINT8_MAX)
251  goto error;
252  aom->y_points[i][0] = y_value;
253  aom->y_points[i][1] = get_bits(gb, bits_scaling);
254  }
255  }
256  }
257 
258  if (luma_only) {
259  aom->chroma_scaling_from_luma = 0;
260  aom->num_uv_points[0] = aom->num_uv_points[1] = 0;
261  } else {
262  aom->chroma_scaling_from_luma = get_bits1(gb);
263  if (aom->chroma_scaling_from_luma) {
264  aom->num_uv_points[0] = aom->num_uv_points[1] = 0;
265  } else {
266  for (uv = 0; uv < 2; uv++) {
267  predict_uv_scaling[uv] = predict_scaling ? get_bits1(gb) : 0;
268  if (predict_uv_scaling[uv]) {
269  int uv_scale, uv_offset, bits_res;
270  uv_scale = get_bits(gb, 9) - 256;
271  uv_offset = get_bits(gb, 9) - 256;
272  bits_res = get_bits(gb, 3);
273  aom->uv_mult[uv] = ref->codec.aom.uv_mult[uv];
274  aom->uv_mult_luma[uv] = ref->codec.aom.uv_mult_luma[uv];
275  aom->uv_offset[uv] = ref->codec.aom.uv_offset[uv];
276  if (bits_res) {
277  int res[10], pred, granularity;
278  aom->num_uv_points[uv] = ref->codec.aom.num_uv_points[uv];
279  for (i = 0; i < aom->num_uv_points[uv]; i++)
280  res[i] = get_bits(gb, bits_res);
281  granularity = get_bits(gb, 3);
282  for (i = 0; i < aom->num_uv_points[uv]; i++) {
283  pred = ref->codec.aom.uv_points[uv][i][1];
284  pred = ((pred * uv_scale + 8) >> 4) + uv_offset;
285  pred += (res[i] - (1 << (bits_res - 1))) * granularity;
286  aom->uv_points[uv][i][0] = ref->codec.aom.uv_points[uv][i][0];
287  aom->uv_points[uv][i][1] = av_clip_uint8(pred);
288  }
289  }
290  } else {
291  int bits_inc, bits_scaling, uv_offset;
292  int uv_value = 0;
293  aom->num_uv_points[uv] = get_bits(gb, 4);
294  if (aom->num_uv_points[uv] > 10)
295  goto error;
296  bits_inc = get_bits(gb, 3) + 1;
297  bits_scaling = get_bits(gb, 2) + 5;
298  uv_offset = get_bits(gb, 8);
299  for (i = 0; i < aom->num_uv_points[uv]; i++) {
300  uv_value += get_bits(gb, bits_inc);
301  if (uv_value > UINT8_MAX)
302  goto error;
303  aom->uv_points[uv][i][0] = uv_value;
304  aom->uv_points[uv][i][1] = get_bits(gb, bits_scaling) + uv_offset;
305  }
306  }
307  }
308  }
309  }
310 
311  aom->scaling_shift = get_bits(gb, 2) + 8;
312  aom->ar_coeff_lag = get_bits(gb, 2);
313  num_y_coeffs = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
314  if (aom->num_y_points) {
315  int ar_bits = get_bits(gb, 2) + 5;
316  for (i = 0; i < num_y_coeffs; i++)
317  aom->ar_coeffs_y[i] = get_bits(gb, ar_bits) - (1 << (ar_bits - 1));
318  }
319  for (uv = 0; uv < 2; uv++) {
320  if (aom->chroma_scaling_from_luma || aom->num_uv_points[uv]) {
321  int ar_bits = get_bits(gb, 2) + 5;
322  for (i = 0; i < num_y_coeffs + !!aom->num_y_points; i++)
323  aom->ar_coeffs_uv[uv][i] = get_bits(gb, ar_bits) - (1 << (ar_bits - 1));
324  }
325  }
326  aom->ar_coeff_shift = get_bits(gb, 2) + 6;
327  aom->grain_scale_shift = get_bits(gb, 2);
328  for (uv = 0; uv < 2; uv++) {
329  if (aom->num_uv_points[uv] && !predict_uv_scaling[uv]) {
330  aom->uv_mult[uv] = get_bits(gb, 8) - 128;
331  aom->uv_mult_luma[uv] = get_bits(gb, 8) - 128;
332  aom->uv_offset[uv] = get_bits(gb, 9) - 256;
333  }
334  }
335  aom->overlap_flag = get_bits1(gb);
336  aom->limit_output_range = get_bits1(gb);
337 
338  // use first set as reference only if it was fully transmitted
339  if (n == 0)
340  ref = fgp;
341 
342  payload_bits = get_bits_count(gb) - start_position;
343  if (payload_bits > payload_size * 8)
344  goto error;
345  skip_bits(gb, payload_size * 8 - payload_bits);
346 
347  av_buffer_unref(&s->sets[set_idx]);
348  s->sets[set_idx] = av_buffer_create((uint8_t *)fgp, fgp_size, NULL, NULL, 0);
349  if (!s->sets[set_idx])
350  goto error;
351  }
352  return 0;
353 
354 error:
355  av_free(fgp);
356  ff_aom_uninit_film_grain_params(s);
357  return AVERROR_INVALIDDATA;
358 }
359 
360 int ff_aom_attach_film_grain_sets(const AVFilmGrainAFGS1Params *s, AVFrame *frame)
361 {
362  if (!s->enable)
363  return 0;
364 
365  for (int i = 0; i < FF_ARRAY_ELEMS(s->sets); i++) {
366  if (!s->sets[i])
367  continue;
368 
369  if (!av_frame_side_data_add(&frame->side_data, &frame->nb_side_data,
370  AV_FRAME_DATA_FILM_GRAIN_PARAMS,
371  (AVBufferRef**)&s->sets[i],
372  AV_FRAME_SIDE_DATA_FLAG_NEW_REF))
373  return AVERROR(ENOMEM);
374  }
375 
376  return 0;
377 }
378 
379 void ff_aom_uninit_film_grain_params(AVFilmGrainAFGS1Params *s)
380 {
381  for (int i = 0; i < FF_ARRAY_ELEMS(s->sets); i++)
382  av_buffer_unref(&s->sets[i]);
383  s->enable = 0;
384 }
385 
386 // Taken from the AV1 spec. Range is [-2048, 2047], mean is 0 and stddev is 512
387 static const int16_t gaussian_sequence[2048] = {
388  56, 568, -180, 172, 124, -84, 172, -64, -900, 24, 820,
389  224, 1248, 996, 272, -8, -916, -388, -732, -104, -188, 800,
390  112, -652, -320, -376, 140, -252, 492, -168, 44, -788, 588,
391  -584, 500, -228, 12, 680, 272, -476, 972, -100, 652, 368,
392  432, -196, -720, -192, 1000, -332, 652, -136, -552, -604, -4,
393  192, -220, -136, 1000, -52, 372, -96, -624, 124, -24, 396,
394  540, -12, -104, 640, 464, 244, -208, -84, 368, -528, -740,
395  248, -968, -848, 608, 376, -60, -292, -40, -156, 252, -292,
396  248, 224, -280, 400, -244, 244, -60, 76, -80, 212, 532,
397  340, 128, -36, 824, -352, -60, -264, -96, -612, 416, -704,
398  220, -204, 640, -160, 1220, -408, 900, 336, 20, -336, -96,
399  -792, 304, 48, -28, -1232, -1172, -448, 104, -292, -520, 244,
400  60, -948, 0, -708, 268, 108, 356, -548, 488, -344, -136,
401  488, -196, -224, 656, -236, -1128, 60, 4, 140, 276, -676,
402  -376, 168, -108, 464, 8, 564, 64, 240, 308, -300, -400,
403  -456, -136, 56, 120, -408, -116, 436, 504, -232, 328, 844,
404  -164, -84, 784, -168, 232, -224, 348, -376, 128, 568, 96,
405  -1244, -288, 276, 848, 832, -360, 656, 464, -384, -332, -356,
406  728, -388, 160, -192, 468, 296, 224, 140, -776, -100, 280,
407  4, 196, 44, -36, -648, 932, 16, 1428, 28, 528, 808,
408  772, 20, 268, 88, -332, -284, 124, -384, -448, 208, -228,
409  -1044, -328, 660, 380, -148, -300, 588, 240, 540, 28, 136,
410  -88, -436, 256, 296, -1000, 1400, 0, -48, 1056, -136, 264,
411  -528, -1108, 632, -484, -592, -344, 796, 124, -668, -768, 388,
412  1296, -232, -188, -200, -288, -4, 308, 100, -168, 256, -500,
413  204, -508, 648, -136, 372, -272, -120, -1004, -552, -548, -384,
414  548, -296, 428, -108, -8, -912, -324, -224, -88, -112, -220,
415  -100, 996, -796, 548, 360, -216, 180, 428, -200, -212, 148,
416  96, 148, 284, 216, -412, -320, 120, -300, -384, -604, -572,
417  -332, -8, -180, -176, 696, 116, -88, 628, 76, 44, -516,
418  240, -208, -40, 100, -592, 344, -308, -452, -228, 20, 916,
419  -1752, -136, -340, -804, 140, 40, 512, 340, 248, 184, -492,
420  896, -156, 932, -628, 328, -688, -448, -616, -752, -100, 560,
421  -1020, 180, -800, -64, 76, 576, 1068, 396, 660, 552, -108,
422  -28, 320, -628, 312, -92, -92, -472, 268, 16, 560, 516,
423  -672, -52, 492, -100, 260, 384, 284, 292, 304, -148, 88,
424  -152, 1012, 1064, -228, 164, -376, -684, 592, -392, 156, 196,
425  -524, -64, -884, 160, -176, 636, 648, 404, -396, -436, 864,
426  424, -728, 988, -604, 904, -592, 296, -224, 536, -176, -920,
427  436, -48, 1176, -884, 416, -776, -824, -884, 524, -548, -564,
428  -68, -164, -96, 692, 364, -692, -1012, -68, 260, -480, 876,
429  -1116, 452, -332, -352, 892, -1088, 1220, -676, 12, -292, 244,
430  496, 372, -32, 280, 200, 112, -440, -96, 24, -644, -184,
431  56, -432, 224, -980, 272, -260, 144, -436, 420, 356, 364,
432  -528, 76, 172, -744, -368, 404, -752, -416, 684, -688, 72,
433  540, 416, 92, 444, 480, -72, -1416, 164, -1172, -68, 24,
434  424, 264, 1040, 128, -912, -524, -356, 64, 876, -12, 4,
435  -88, 532, 272, -524, 320, 276, -508, 940, 24, -400, -120,
436  756, 60, 236, -412, 100, 376, -484, 400, -100, -740, -108,
437  -260, 328, -268, 224, -200, -416, 184, -604, -564, -20, 296,
438  60, 892, -888, 60, 164, 68, -760, 216, -296, 904, -336,
439  -28, 404, -356, -568, -208, -1480, -512, 296, 328, -360, -164,
440  -1560, -776, 1156, -428, 164, -504, -112, 120, -216, -148, -264,
441  308, 32, 64, -72, 72, 116, 176, -64, -272, 460, -536,
442  -784, -280, 348, 108, -752, -132, 524, -540, -776, 116, -296,
443  -1196, -288, -560, 1040, -472, 116, -848, -1116, 116, 636, 696,
444  284, -176, 1016, 204, -864, -648, -248, 356, 972, -584, -204,
445  264, 880, 528, -24, -184, 116, 448, -144, 828, 524, 212,
446  -212, 52, 12, 200, 268, -488, -404, -880, 824, -672, -40,
447  908, -248, 500, 716, -576, 492, -576, 16, 720, -108, 384,
448  124, 344, 280, 576, -500, 252, 104, -308, 196, -188, -8,
449  1268, 296, 1032, -1196, 436, 316, 372, -432, -200, -660, 704,
450  -224, 596, -132, 268, 32, -452, 884, 104, -1008, 424, -1348,
451  -280, 4, -1168, 368, 476, 696, 300, -8, 24, 180, -592,
452  -196, 388, 304, 500, 724, -160, 244, -84, 272, -256, -420,
453  320, 208, -144, -156, 156, 364, 452, 28, 540, 316, 220,
454  -644, -248, 464, 72, 360, 32, -388, 496, -680, -48, 208,
455  -116, -408, 60, -604, -392, 548, -840, 784, -460, 656, -544,
456  -388, -264, 908, -800, -628, -612, -568, 572, -220, 164, 288,
457  -16, -308, 308, -112, -636, -760, 280, -668, 432, 364, 240,
458  -196, 604, 340, 384, 196, 592, -44, -500, 432, -580, -132,
459  636, -76, 392, 4, -412, 540, 508, 328, -356, -36, 16,
460  -220, -64, -248, -60, 24, -192, 368, 1040, 92, -24, -1044,
461  -32, 40, 104, 148, 192, -136, -520, 56, -816, -224, 732,
462  392, 356, 212, -80, -424, -1008, -324, 588, -1496, 576, 460,
463  -816, -848, 56, -580, -92, -1372, -112, -496, 200, 364, 52,
464  -140, 48, -48, -60, 84, 72, 40, 132, -356, -268, -104,
465  -284, -404, 732, -520, 164, -304, -540, 120, 328, -76, -460,
466  756, 388, 588, 236, -436, -72, -176, -404, -316, -148, 716,
467  -604, 404, -72, -88, -888, -68, 944, 88, -220, -344, 960,
468  472, 460, -232, 704, 120, 832, -228, 692, -508, 132, -476,
469  844, -748, -364, -44, 1116, -1104, -1056, 76, 428, 552, -692,
470  60, 356, 96, -384, -188, -612, -576, 736, 508, 892, 352,
471  -1132, 504, -24, -352, 324, 332, -600, -312, 292, 508, -144,
472  -8, 484, 48, 284, -260, -240, 256, -100, -292, -204, -44,
473  472, -204, 908, -188, -1000, -256, 92, 1164, -392, 564, 356,
474  652, -28, -884, 256, 484, -192, 760, -176, 376, -524, -452,
475  -436, 860, -736, 212, 124, 504, -476, 468, 76, -472, 552,
476  -692, -944, -620, 740, -240, 400, 132, 20, 192, -196, 264,
477  -668, -1012, -60, 296, -316, -828, 76, -156, 284, -768, -448,
478  -832, 148, 248, 652, 616, 1236, 288, -328, -400, -124, 588,
479  220, 520, -696, 1032, 768, -740, -92, -272, 296, 448, -464,
480  412, -200, 392, 440, -200, 264, -152, -260, 320, 1032, 216,
481  320, -8, -64, 156, -1016, 1084, 1172, 536, 484, -432, 132,
482  372, -52, -256, 84, 116, -352, 48, 116, 304, -384, 412,
483  924, -300, 528, 628, 180, 648, 44, -980, -220, 1320, 48,
484  332, 748, 524, -268, -720, 540, -276, 564, -344, -208, -196,
485  436, 896, 88, -392, 132, 80, -964, -288, 568, 56, -48,
486  -456, 888, 8, 552, -156, -292, 948, 288, 128, -716, -292,
487  1192, -152, 876, 352, -600, -260, -812, -468, -28, -120, -32,
488  -44, 1284, 496, 192, 464, 312, -76, -516, -380, -456, -1012,
489  -48, 308, -156, 36, 492, -156, -808, 188, 1652, 68, -120,
490  -116, 316, 160, -140, 352, 808, -416, 592, 316, -480, 56,
491  528, -204, -568, 372, -232, 752, -344, 744, -4, 324, -416,
492  -600, 768, 268, -248, -88, -132, -420, -432, 80, -288, 404,
493  -316, -1216, -588, 520, -108, 92, -320, 368, -480, -216, -92,
494  1688, -300, 180, 1020, -176, 820, -68, -228, -260, 436, -904,
495  20, 40, -508, 440, -736, 312, 332, 204, 760, -372, 728,
496  96, -20, -632, -520, -560, 336, 1076, -64, -532, 776, 584,
497  192, 396, -728, -520, 276, -188, 80, -52, -612, -252, -48,
498  648, 212, -688, 228, -52, -260, 428, -412, -272, -404, 180,
499  816, -796, 48, 152, 484, -88, -216, 988, 696, 188, -528,
500  648, -116, -180, 316, 476, 12, -564, 96, 476, -252, -364,
501  -376, -392, 556, -256, -576, 260, -352, 120, -16, -136, -260,
502  -492, 72, 556, 660, 580, 616, 772, 436, 424, -32, -324,
503  -1268, 416, -324, -80, 920, 160, 228, 724, 32, -516, 64,
504  384, 68, -128, 136, 240, 248, -204, -68, 252, -932, -120,
505  -480, -628, -84, 192, 852, -404, -288, -132, 204, 100, 168,
506  -68, -196, -868, 460, 1080, 380, -80, 244, 0, 484, -888,
507  64, 184, 352, 600, 460, 164, 604, -196, 320, -64, 588,
508  -184, 228, 12, 372, 48, -848, -344, 224, 208, -200, 484,
509  128, -20, 272, -468, -840, 384, 256, -720, -520, -464, -580,
510  112, -120, 644, -356, -208, -608, -528, 704, 560, -424, 392,
511  828, 40, 84, 200, -152, 0, -144, 584, 280, -120, 80,
512  -556, -972, -196, -472, 724, 80, 168, -32, 88, 160, -688,
513  0, 160, 356, 372, -776, 740, -128, 676, -248, -480, 4,
514  -364, 96, 544, 232, -1032, 956, 236, 356, 20, -40, 300,
515  24, -676, -596, 132, 1120, -104, 532, -1096, 568, 648, 444,
516  508, 380, 188, -376, -604, 1488, 424, 24, 756, -220, -192,
517  716, 120, 920, 688, 168, 44, -460, 568, 284, 1144, 1160,
518  600, 424, 888, 656, -356, -320, 220, 316, -176, -724, -188,
519  -816, -628, -348, -228, -380, 1012, -452, -660, 736, 928, 404,
520  -696, -72, -268, -892, 128, 184, -344, -780, 360, 336, 400,
521  344, 428, 548, -112, 136, -228, -216, -820, -516, 340, 92,
522  -136, 116, -300, 376, -244, 100, -316, -520, -284, -12, 824,
523  164, -548, -180, -128, 116, -924, -828, 268, -368, -580, 620,
524  192, 160, 0, -1676, 1068, 424, -56, -360, 468, -156, 720,
525  288, -528, 556, -364, 548, -148, 504, 316, 152, -648, -620,
526  -684, -24, -376, -384, -108, -920, -1032, 768, 180, -264, -508,
527  -1268, -260, -60, 300, -240, 988, 724, -376, -576, -212, -736,
528  556, 192, 1092, -620, -880, 376, -56, -4, -216, -32, 836,
529  268, 396, 1332, 864, -600, 100, 56, -412, -92, 356, 180,
530  884, -468, -436, 292, -388, -804, -704, -840, 368, -348, 140,
531  -724, 1536, 940, 372, 112, -372, 436, -480, 1136, 296, -32,
532  -228, 132, -48, -220, 868, -1016, -60, -1044, -464, 328, 916,
533  244, 12, -736, -296, 360, 468, -376, -108, -92, 788, 368,
534  -56, 544, 400, -672, -420, 728, 16, 320, 44, -284, -380,
535  -796, 488, 132, 204, -596, -372, 88, -152, -908, -636, -572,
536  -624, -116, -692, -200, -56, 276, -88, 484, -324, 948, 864,
537  1000, -456, -184, -276, 292, -296, 156, 676, 320, 160, 908,
538  -84, -1236, -288, -116, 260, -372, -644, 732, -756, -96, 84,
539  344, -520, 348, -688, 240, -84, 216, -1044, -136, -676, -396,
540  -1500, 960, -40, 176, 168, 1516, 420, -504, -344, -364, -360,
541  1216, -940, -380, -212, 252, -660, -708, 484, -444, -152, 928,
542  -120, 1112, 476, -260, 560, -148, -344, 108, -196, 228, -288,
543  504, 560, -328, -88, 288, -1008, 460, -228, 468, -836, -196,
544  76, 388, 232, 412, -1168, -716, -644, 756, -172, -356, -504,
545  116, 432, 528, 48, 476, -168, -608, 448, 160, -532, -272,
546  28, -676, -12, 828, 980, 456, 520, 104, -104, 256, -344,
547  -4, -28, -368, -52, -524, -572, -556, -200, 768, 1124, -208,
548  -512, 176, 232, 248, -148, -888, 604, -600, -304, 804, -156,
549  -212, 488, -192, -804, -256, 368, -360, -916, -328, 228, -240,
550  -448, -472, 856, -556, -364, 572, -12, -156, -368, -340, 432,
551  252, -752, -152, 288, 268, -580, -848, -592, 108, -76, 244,
552  312, -716, 592, -80, 436, 360, 4, -248, 160, 516, 584,
553  732, 44, -468, -280, -292, -156, -588, 28, 308, 912, 24,
554  124, 156, 180, -252, 944, -924, -772, -520, -428, -624, 300,
555  -212, -1144, 32, -724, 800, -1128, -212, -1288, -848, 180, -416,
556  440, 192, -576, -792, -76, -1080, 80, -532, -352, -132, 380,
557  -820, 148, 1112, 128, 164, 456, 700, -924, 144, -668, -384,
558  648, -832, 508, 552, -52, -100, -656, 208, -568, 748, -88,
559  680, 232, 300, 192, -408, -1012, -152, -252, -268, 272, -876,
560  -664, -648, -332, -136, 16, 12, 1152, -28, 332, -536, 320,
561  -672, -460, -316, 532, -260, 228, -40, 1052, -816, 180, 88,
562  -496, -556, -672, -368, 428, 92, 356, 404, -408, 252, 196,
563  -176, -556, 792, 268, 32, 372, 40, 96, -332, 328, 120,
564  372, -900, -40, 472, -264, -592, 952, 128, 656, 112, 664,
565  -232, 420, 4, -344, -464, 556, 244, -416, -32, 252, 0,
566  -412, 188, -696, 508, -476, 324, -1096, 656, -312, 560, 264,
567  -136, 304, 160, -64, -580, 248, 336, -720, 560, -348, -288,
568  -276, -196, -500, 852, -544, -236, -1128, -992, -776, 116, 56,
569  52, 860, 884, 212, -12, 168, 1020, 512, -552, 924, -148,
570  716, 188, 164, -340, -520, -184, 880, -152, -680, -208, -1156,
571  -300, -528, -472, 364, 100, -744, -1056, -32, 540, 280, 144,
572  -676, -32, -232, -280, -224, 96, 568, -76, 172, 148, 148,
573  104, 32, -296, -32, 788, -80, 32, -16, 280, 288, 944,
574  428, -484
575 };
AVCOL_PRI_RESERVED
@ AVCOL_PRI_RESERVED
Definition: pixfmt.h:640
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
aom_film_grain_template.c
r
const char * r
Definition: vf_curves.c:127
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
AVFilmGrainParams::bit_depth_luma
int bit_depth_luma
Intended bit depth, or 0 for unknown/unspecified.
Definition: film_grain_params.h:238
out
static FILE * out
Definition: movenc.c:55
av_film_grain_params_alloc
AVFilmGrainParams * av_film_grain_params_alloc(size_t *size)
This file is part of FFmpeg.
Definition: film_grain_params.c:23
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:254
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
get_random_number
static int get_random_number(const int bits, unsigned *const state)
Definition: aom_film_grain.c:37
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:247
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:434
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:688
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:720
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
data
const char data[16]
Definition: mxf.c:149
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
AVFilmGrainParams::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:233
ff_aom_apply_film_grain
int ff_aom_apply_film_grain(AVFrame *out, const AVFrame *in, const AVFilmGrainParams *params)
Definition: aom_film_grain.c:68
AVFilmGrainParams::codec
union AVFilmGrainParams::@524 codec
Additional fields may be added both here and in any structure included.
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:232
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:213
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:518
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:455
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:704
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
GetBitContext
Definition: get_bits.h:109
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
AVFilmGrainAOMParams
This structure describes how to handle film grain synthesis for AOM codecs.
Definition: film_grain_params.h:44
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
AVFilmGrainParams::bit_depth_chroma
int bit_depth_chroma
Definition: film_grain_params.h:239
avassert.h
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
AVFilmGrainParams::width
int width
Intended display resolution.
Definition: film_grain_params.h:220
AVCOL_PRI_RESERVED0
@ AVCOL_PRI_RESERVED0
Definition: pixfmt.h:637
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
SUB_GRAIN_HEIGHT
@ SUB_GRAIN_HEIGHT
Definition: aom_film_grain.c:53
AV_FRAME_SIDE_DATA_FLAG_NEW_REF
#define AV_FRAME_SIDE_DATA_FLAG_NEW_REF
Create a new reference to the passed in buffer instead of taking ownership of it.
Definition: frame.h:1065
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:654
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
get_bits.h
ff_aom_uninit_film_grain_params
void ff_aom_uninit_film_grain_params(AVFilmGrainAFGS1Params *s)
Definition: aom_film_grain.c:379
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:519
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
AVCOL_TRC_RESERVED0
@ AVCOL_TRC_RESERVED0
Definition: pixfmt.h:667
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
SUB_GRAIN_WIDTH
@ SUB_GRAIN_WIDTH
Definition: aom_film_grain.c:52
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
FG_BLOCK_SIZE
@ FG_BLOCK_SIZE
Definition: aom_film_grain.c:54
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
aom_film_grain.h
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVFilmGrainParams::subsampling_x
int subsampling_x
Intended subsampling ratio, or 0 for luma-only streams.
Definition: film_grain_params.h:225
gaussian_sequence
static const int16_t gaussian_sequence[2048]
Definition: aom_film_grain.c:57
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:743
ff_aom_attach_film_grain_sets
int ff_aom_attach_film_grain_sets(const AVFilmGrainAFGS1Params *s, AVFrame *frame)
Definition: aom_film_grain.c:360
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVFilmGrainAOMParams::num_uv_points
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
Definition: film_grain_params.h:62
round2
static int round2(const int x, const uint64_t shift)
Definition: aom_film_grain.c:45
GRAIN_WIDTH
@ GRAIN_WIDTH
Definition: aom_film_grain.c:50
shift
static int shift(int a, int b)
Definition: bonk.c:261
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:201
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:521
buffer.h
state
static struct @583 state
av_zero_extend
#define av_zero_extend
Definition: common.h:151
ff_aom_parse_film_grain_sets
int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params *s, const uint8_t *payload, int payload_size)
Definition: aom_film_grain.c:124
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
AVFilmGrainParams::color_primaries
enum AVColorPrimaries color_primaries
Definition: film_grain_params.h:231
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:225
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
AVFilmGrainParams::height
int height
Definition: film_grain_params.h:220
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
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
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
AVFilmGrainAOMParams::uv_offset
int uv_offset[2]
Offset used for component scaling function.
Definition: film_grain_params.h:112
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilmGrainParams::color_range
enum AVColorRange color_range
Intended video signal characteristics.
Definition: film_grain_params.h:230
AVFilmGrainAOMParams::overlap_flag
int overlap_flag
Signals whether to overlap film grain blocks.
Definition: film_grain_params.h:117
desc
const char * desc
Definition: libsvtav1.c:82
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
GRAIN_HEIGHT
@ GRAIN_HEIGHT
Definition: aom_film_grain.c:51
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCOL_TRC_RESERVED
@ AVCOL_TRC_RESERVED
Definition: pixfmt.h:670
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVFilmGrainAFGS1Params
Definition: aom_film_grain.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:479
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:520
AVFilmGrainAOMParams::chroma_scaling_from_luma
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
Definition: film_grain_params.h:56
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:205
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: side_data.c:224
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86
Generated on Wed Apr 22 2026 19:22:11 for FFmpeg by   doxygen 1.8.17