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/imgutils.h"
30 
31 #include "aom_film_grain.h"
32 #include "get_bits.h"
33 
34 // Common/shared helpers (not dependent on BIT_DEPTH)
35 static inline int get_random_number(const int bits, unsigned *const state) {
36  const int r = *state;
37  unsigned bit = ((r >> 0) ^ (r >> 1) ^ (r >> 3) ^ (r >> 12)) & 1;
38  *state = (r >> 1) | (bit << 15);
39 
40  return (*state >> (16 - bits)) & ((1 << bits) - 1);
41 }
42 
43 static inline int round2(const int x, const uint64_t shift) {
44  return (x + ((1 << shift) >> 1)) >> shift;
45 }
46 
47 enum {
48  GRAIN_WIDTH = 82,
49  GRAIN_HEIGHT = 73,
50  SUB_GRAIN_WIDTH = 44,
51  SUB_GRAIN_HEIGHT = 38,
52  FG_BLOCK_SIZE = 32,
53 };
54 
55 static const int16_t gaussian_sequence[2048];
56 
57 #define BIT_DEPTH 16
58 #include "aom_film_grain_template.c"
59 #undef BIT_DEPTH
60 
61 #define BIT_DEPTH 8
62 #include "aom_film_grain_template.c"
63 #undef BIT_DEPTH
64 
65 
66 int ff_aom_apply_film_grain(AVFrame *out, const AVFrame *in,
67  const AVFilmGrainParams *params)
68 {
69  const AVFilmGrainAOMParams *const data = &params->codec.aom;
70  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(out->format);
71  const int subx = desc->log2_chroma_w, suby = desc->log2_chroma_h;
72  const int pxstep = desc->comp[0].step;
73 
74  av_assert0(out->format == in->format);
75  av_assert0(params->type == AV_FILM_GRAIN_PARAMS_AV1);
76 
77  // Copy over the non-modified planes
78  if (!params->codec.aom.num_y_points) {
79  av_image_copy_plane(out->data[0], out->linesize[0],
80  in->data[0], in->linesize[0],
81  out->width * pxstep, out->height);
82  }
83  for (int uv = 0; uv < 2; uv++) {
84  if (!data->num_uv_points[uv]) {
85  av_image_copy_plane(out->data[1+uv], out->linesize[1+uv],
86  in->data[1+uv], in->linesize[1+uv],
87  AV_CEIL_RSHIFT(out->width, subx) * pxstep,
88  AV_CEIL_RSHIFT(out->height, suby));
89  }
90  }
91 
92  switch (in->format) {
93  case AV_PIX_FMT_GRAY8:
94  case AV_PIX_FMT_YUV420P:
95  case AV_PIX_FMT_YUV422P:
96  case AV_PIX_FMT_YUV444P:
97  case AV_PIX_FMT_YUVJ420P:
98  case AV_PIX_FMT_YUVJ422P:
99  case AV_PIX_FMT_YUVJ444P:
100  return apply_film_grain_8(out, in, params);
101  case AV_PIX_FMT_GRAY9:
102  case AV_PIX_FMT_YUV420P9:
103  case AV_PIX_FMT_YUV422P9:
104  case AV_PIX_FMT_YUV444P9:
105  return apply_film_grain_16(out, in, params, 9);
106  case AV_PIX_FMT_GRAY10:
107  case AV_PIX_FMT_YUV420P10:
108  case AV_PIX_FMT_YUV422P10:
109  case AV_PIX_FMT_YUV444P10:
110  return apply_film_grain_16(out, in, params, 10);
111  case AV_PIX_FMT_GRAY12:
112  case AV_PIX_FMT_YUV420P12:
113  case AV_PIX_FMT_YUV422P12:
114  case AV_PIX_FMT_YUV444P12:
115  return apply_film_grain_16(out, in, params, 12);
116  }
117 
118  /* The AV1 spec only defines film grain synthesis for these formats */
119  return AVERROR_INVALIDDATA;
120 }
121 
122 int ff_aom_parse_film_grain_sets(AVFilmGrainAFGS1Params *s,
123  const uint8_t *payload, int payload_size)
124 {
125  GetBitContext gbc, *gb = &gbc;
126  AVFilmGrainAOMParams *aom;
127  AVFilmGrainParams *fgp, *ref = NULL;
128  int ret, num_sets, n, i, uv, num_y_coeffs, update_grain, luma_only;
129 
130  ret = init_get_bits8(gb, payload, payload_size);
131  if (ret < 0)
132  return ret;
133 
134  s->enable = get_bits1(gb);
135  if (!s->enable)
136  return 0;
137 
138  skip_bits(gb, 4); // reserved
139  num_sets = get_bits(gb, 3) + 1;
140  for (n = 0; n < num_sets; n++) {
141  int payload_4byte, payload_size, set_idx, apply_units_log2, vsc_flag;
142  int predict_scaling, predict_y_scaling, predict_uv_scaling[2];
143  int payload_bits, start_position;
144 
145  start_position = get_bits_count(gb);
146  payload_4byte = get_bits1(gb);
147  payload_size = get_bits(gb, payload_4byte ? 2 : 8);
148  set_idx = get_bits(gb, 3);
149  fgp = &s->sets[set_idx];
150  aom = &fgp->codec.aom;
151 
152  fgp->type = get_bits1(gb) ? AV_FILM_GRAIN_PARAMS_AV1 : AV_FILM_GRAIN_PARAMS_NONE;
153  if (!fgp->type)
154  continue;
155 
156  fgp->seed = get_bits(gb, 16);
157  update_grain = get_bits1(gb);
158  if (!update_grain)
159  continue;
160 
161  apply_units_log2 = get_bits(gb, 4);
162  fgp->width = get_bits(gb, 12) << apply_units_log2;
163  fgp->height = get_bits(gb, 12) << apply_units_log2;
164  luma_only = get_bits1(gb);
165  if (luma_only) {
166  fgp->subsampling_x = fgp->subsampling_y = 0;
167  } else {
168  fgp->subsampling_x = get_bits1(gb);
169  fgp->subsampling_y = get_bits1(gb);
170  }
171 
172  fgp->bit_depth_luma = fgp->bit_depth_chroma = 0;
173  fgp->color_primaries = AVCOL_PRI_UNSPECIFIED;
174  fgp->color_trc = AVCOL_TRC_UNSPECIFIED;
175  fgp->color_space = AVCOL_SPC_UNSPECIFIED;
176  fgp->color_range = AVCOL_RANGE_UNSPECIFIED;
177 
178  vsc_flag = get_bits1(gb); // video_signal_characteristics_flag
179  if (vsc_flag) {
180  int cicp_flag;
181  fgp->bit_depth_luma = get_bits(gb, 3) + 8;
182  if (!luma_only)
183  fgp->bit_depth_chroma = fgp->bit_depth_luma;
184  cicp_flag = get_bits1(gb);
185  if (cicp_flag) {
186  fgp->color_primaries = get_bits(gb, 8);
187  fgp->color_trc = get_bits(gb, 8);
188  fgp->color_space = get_bits(gb, 8);
189  fgp->color_range = get_bits1(gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
190  if (fgp->color_primaries > AVCOL_PRI_NB ||
191  fgp->color_primaries == AVCOL_PRI_RESERVED ||
192  fgp->color_primaries == AVCOL_PRI_RESERVED0 ||
193  fgp->color_trc > AVCOL_TRC_NB ||
194  fgp->color_trc == AVCOL_TRC_RESERVED ||
195  fgp->color_trc == AVCOL_TRC_RESERVED0 ||
196  fgp->color_space > AVCOL_SPC_NB ||
197  fgp->color_space == AVCOL_SPC_RESERVED)
198  goto error;
199  }
200  }
201 
202  predict_scaling = get_bits1(gb);
203  if (predict_scaling && (!ref || ref == fgp))
204  goto error; // prediction must be from valid, different set
205 
206  predict_y_scaling = predict_scaling ? get_bits1(gb) : 0;
207  if (predict_y_scaling) {
208  int y_scale, y_offset, bits_res;
209  y_scale = get_bits(gb, 9) - 256;
210  y_offset = get_bits(gb, 9) - 256;
211  bits_res = get_bits(gb, 3);
212  if (bits_res) {
213  int res[14], pred, granularity;
214  aom->num_y_points = ref->codec.aom.num_y_points;
215  for (i = 0; i < aom->num_y_points; i++)
216  res[i] = get_bits(gb, bits_res);
217  granularity = get_bits(gb, 3);
218  for (i = 0; i < aom->num_y_points; i++) {
219  pred = ref->codec.aom.y_points[i][1];
220  pred = ((pred * y_scale + 8) >> 4) + y_offset;
221  pred += (res[i] - (1 << (bits_res - 1))) * granularity;
222  aom->y_points[i][0] = ref->codec.aom.y_points[i][0];
223  aom->y_points[i][1] = av_clip_uint8(pred);
224  }
225  }
226  } else {
227  aom->num_y_points = get_bits(gb, 4);
228  if (aom->num_y_points > 14) {
229  goto error;
230  } else if (aom->num_y_points) {
231  int bits_inc, bits_scaling;
232  int y_value = 0;
233  bits_inc = get_bits(gb, 3) + 1;
234  bits_scaling = get_bits(gb, 2) + 5;
235  for (i = 0; i < aom->num_y_points; i++) {
236  y_value += get_bits(gb, bits_inc);
237  if (y_value > UINT8_MAX)
238  goto error;
239  aom->y_points[i][0] = y_value;
240  aom->y_points[i][1] = get_bits(gb, bits_scaling);
241  }
242  }
243  }
244 
245  if (luma_only) {
246  aom->chroma_scaling_from_luma = 0;
247  aom->num_uv_points[0] = aom->num_uv_points[1] = 0;
248  } else {
249  aom->chroma_scaling_from_luma = get_bits1(gb);
250  if (aom->chroma_scaling_from_luma) {
251  aom->num_uv_points[0] = aom->num_uv_points[1] = 0;
252  } else {
253  for (uv = 0; uv < 2; uv++) {
254  predict_uv_scaling[uv] = predict_scaling ? get_bits1(gb) : 0;
255  if (predict_uv_scaling[uv]) {
256  int uv_scale, uv_offset, bits_res;
257  uv_scale = get_bits(gb, 9) - 256;
258  uv_offset = get_bits(gb, 9) - 256;
259  bits_res = get_bits(gb, 3);
260  aom->uv_mult[uv] = ref->codec.aom.uv_mult[uv];
261  aom->uv_mult_luma[uv] = ref->codec.aom.uv_mult_luma[uv];
262  aom->uv_offset[uv] = ref->codec.aom.uv_offset[uv];
263  if (bits_res) {
264  int res[10], pred, granularity;
265  aom->num_uv_points[uv] = ref->codec.aom.num_uv_points[uv];
266  for (i = 0; i < aom->num_uv_points[uv]; i++)
267  res[i] = get_bits(gb, bits_res);
268  granularity = get_bits(gb, 3);
269  for (i = 0; i < aom->num_uv_points[uv]; i++) {
270  pred = ref->codec.aom.uv_points[uv][i][1];
271  pred = ((pred * uv_scale + 8) >> 4) + uv_offset;
272  pred += (res[i] - (1 << (bits_res - 1))) * granularity;
273  aom->uv_points[uv][i][0] = ref->codec.aom.uv_points[uv][i][0];
274  aom->uv_points[uv][i][1] = av_clip_uint8(pred);
275  }
276  }
277  } else {
278  int bits_inc, bits_scaling, uv_offset;
279  int uv_value = 0;
280  aom->num_uv_points[uv] = get_bits(gb, 4);
281  if (aom->num_uv_points[uv] > 10)
282  goto error;
283  bits_inc = get_bits(gb, 3) + 1;
284  bits_scaling = get_bits(gb, 2) + 5;
285  uv_offset = get_bits(gb, 8);
286  for (i = 0; i < aom->num_uv_points[uv]; i++) {
287  uv_value += get_bits(gb, bits_inc);
288  if (uv_value > UINT8_MAX)
289  goto error;
290  aom->uv_points[uv][i][0] = uv_value;
291  aom->uv_points[uv][i][1] = get_bits(gb, bits_scaling) + uv_offset;
292  }
293  }
294  }
295  }
296  }
297 
298  aom->scaling_shift = get_bits(gb, 2) + 8;
299  aom->ar_coeff_lag = get_bits(gb, 2);
300  num_y_coeffs = 2 * aom->ar_coeff_lag * (aom->ar_coeff_lag + 1);
301  if (aom->num_y_points) {
302  int ar_bits = get_bits(gb, 2) + 5;
303  for (i = 0; i < num_y_coeffs; i++)
304  aom->ar_coeffs_y[i] = get_bits(gb, ar_bits) - (1 << (ar_bits - 1));
305  }
306  for (uv = 0; uv < 2; uv++) {
307  if (aom->chroma_scaling_from_luma || aom->num_uv_points[uv]) {
308  int ar_bits = get_bits(gb, 2) + 5;
309  for (i = 0; i < num_y_coeffs + !!aom->num_y_points; i++)
310  aom->ar_coeffs_uv[uv][i] = get_bits(gb, ar_bits) - (1 << (ar_bits - 1));
311  }
312  }
313  aom->ar_coeff_shift = get_bits(gb, 2) + 6;
314  aom->grain_scale_shift = get_bits(gb, 2);
315  for (uv = 0; uv < 2; uv++) {
316  if (aom->num_uv_points[uv] && !predict_uv_scaling[uv]) {
317  aom->uv_mult[uv] = get_bits(gb, 8) - 128;
318  aom->uv_mult_luma[uv] = get_bits(gb, 8) - 128;
319  aom->uv_offset[uv] = get_bits(gb, 9) - 256;
320  }
321  }
322  aom->overlap_flag = get_bits1(gb);
323  aom->limit_output_range = get_bits1(gb);
324 
325  // use first set as reference only if it was fully transmitted
326  if (n == 0)
327  ref = fgp;
328 
329  payload_bits = get_bits_count(gb) - start_position;
330  if (payload_bits > payload_size * 8)
331  goto error;
332  skip_bits(gb, payload_size * 8 - payload_bits);
333  }
334  return 0;
335 
336 error:
337  memset(s, 0, sizeof(*s));
338  return AVERROR_INVALIDDATA;
339 }
340 
341 int ff_aom_attach_film_grain_sets(const AVFilmGrainAFGS1Params *s, AVFrame *frame)
342 {
343  AVFilmGrainParams *fgp;
344  if (!s->enable)
345  return 0;
346 
347  for (int i = 0; i < FF_ARRAY_ELEMS(s->sets); i++) {
348  if (s->sets[i].type != AV_FILM_GRAIN_PARAMS_AV1)
349  continue;
350  fgp = av_film_grain_params_create_side_data(frame);
351  if (!fgp)
352  return AVERROR(ENOMEM);
353  memcpy(fgp, &s->sets[i], sizeof(*fgp));
354  }
355 
356  return 0;
357 }
358 
359 // Taken from the AV1 spec. Range is [-2048, 2047], mean is 0 and stddev is 512
360 static const int16_t gaussian_sequence[2048] = {
361  56, 568, -180, 172, 124, -84, 172, -64, -900, 24, 820,
362  224, 1248, 996, 272, -8, -916, -388, -732, -104, -188, 800,
363  112, -652, -320, -376, 140, -252, 492, -168, 44, -788, 588,
364  -584, 500, -228, 12, 680, 272, -476, 972, -100, 652, 368,
365  432, -196, -720, -192, 1000, -332, 652, -136, -552, -604, -4,
366  192, -220, -136, 1000, -52, 372, -96, -624, 124, -24, 396,
367  540, -12, -104, 640, 464, 244, -208, -84, 368, -528, -740,
368  248, -968, -848, 608, 376, -60, -292, -40, -156, 252, -292,
369  248, 224, -280, 400, -244, 244, -60, 76, -80, 212, 532,
370  340, 128, -36, 824, -352, -60, -264, -96, -612, 416, -704,
371  220, -204, 640, -160, 1220, -408, 900, 336, 20, -336, -96,
372  -792, 304, 48, -28, -1232, -1172, -448, 104, -292, -520, 244,
373  60, -948, 0, -708, 268, 108, 356, -548, 488, -344, -136,
374  488, -196, -224, 656, -236, -1128, 60, 4, 140, 276, -676,
375  -376, 168, -108, 464, 8, 564, 64, 240, 308, -300, -400,
376  -456, -136, 56, 120, -408, -116, 436, 504, -232, 328, 844,
377  -164, -84, 784, -168, 232, -224, 348, -376, 128, 568, 96,
378  -1244, -288, 276, 848, 832, -360, 656, 464, -384, -332, -356,
379  728, -388, 160, -192, 468, 296, 224, 140, -776, -100, 280,
380  4, 196, 44, -36, -648, 932, 16, 1428, 28, 528, 808,
381  772, 20, 268, 88, -332, -284, 124, -384, -448, 208, -228,
382  -1044, -328, 660, 380, -148, -300, 588, 240, 540, 28, 136,
383  -88, -436, 256, 296, -1000, 1400, 0, -48, 1056, -136, 264,
384  -528, -1108, 632, -484, -592, -344, 796, 124, -668, -768, 388,
385  1296, -232, -188, -200, -288, -4, 308, 100, -168, 256, -500,
386  204, -508, 648, -136, 372, -272, -120, -1004, -552, -548, -384,
387  548, -296, 428, -108, -8, -912, -324, -224, -88, -112, -220,
388  -100, 996, -796, 548, 360, -216, 180, 428, -200, -212, 148,
389  96, 148, 284, 216, -412, -320, 120, -300, -384, -604, -572,
390  -332, -8, -180, -176, 696, 116, -88, 628, 76, 44, -516,
391  240, -208, -40, 100, -592, 344, -308, -452, -228, 20, 916,
392  -1752, -136, -340, -804, 140, 40, 512, 340, 248, 184, -492,
393  896, -156, 932, -628, 328, -688, -448, -616, -752, -100, 560,
394  -1020, 180, -800, -64, 76, 576, 1068, 396, 660, 552, -108,
395  -28, 320, -628, 312, -92, -92, -472, 268, 16, 560, 516,
396  -672, -52, 492, -100, 260, 384, 284, 292, 304, -148, 88,
397  -152, 1012, 1064, -228, 164, -376, -684, 592, -392, 156, 196,
398  -524, -64, -884, 160, -176, 636, 648, 404, -396, -436, 864,
399  424, -728, 988, -604, 904, -592, 296, -224, 536, -176, -920,
400  436, -48, 1176, -884, 416, -776, -824, -884, 524, -548, -564,
401  -68, -164, -96, 692, 364, -692, -1012, -68, 260, -480, 876,
402  -1116, 452, -332, -352, 892, -1088, 1220, -676, 12, -292, 244,
403  496, 372, -32, 280, 200, 112, -440, -96, 24, -644, -184,
404  56, -432, 224, -980, 272, -260, 144, -436, 420, 356, 364,
405  -528, 76, 172, -744, -368, 404, -752, -416, 684, -688, 72,
406  540, 416, 92, 444, 480, -72, -1416, 164, -1172, -68, 24,
407  424, 264, 1040, 128, -912, -524, -356, 64, 876, -12, 4,
408  -88, 532, 272, -524, 320, 276, -508, 940, 24, -400, -120,
409  756, 60, 236, -412, 100, 376, -484, 400, -100, -740, -108,
410  -260, 328, -268, 224, -200, -416, 184, -604, -564, -20, 296,
411  60, 892, -888, 60, 164, 68, -760, 216, -296, 904, -336,
412  -28, 404, -356, -568, -208, -1480, -512, 296, 328, -360, -164,
413  -1560, -776, 1156, -428, 164, -504, -112, 120, -216, -148, -264,
414  308, 32, 64, -72, 72, 116, 176, -64, -272, 460, -536,
415  -784, -280, 348, 108, -752, -132, 524, -540, -776, 116, -296,
416  -1196, -288, -560, 1040, -472, 116, -848, -1116, 116, 636, 696,
417  284, -176, 1016, 204, -864, -648, -248, 356, 972, -584, -204,
418  264, 880, 528, -24, -184, 116, 448, -144, 828, 524, 212,
419  -212, 52, 12, 200, 268, -488, -404, -880, 824, -672, -40,
420  908, -248, 500, 716, -576, 492, -576, 16, 720, -108, 384,
421  124, 344, 280, 576, -500, 252, 104, -308, 196, -188, -8,
422  1268, 296, 1032, -1196, 436, 316, 372, -432, -200, -660, 704,
423  -224, 596, -132, 268, 32, -452, 884, 104, -1008, 424, -1348,
424  -280, 4, -1168, 368, 476, 696, 300, -8, 24, 180, -592,
425  -196, 388, 304, 500, 724, -160, 244, -84, 272, -256, -420,
426  320, 208, -144, -156, 156, 364, 452, 28, 540, 316, 220,
427  -644, -248, 464, 72, 360, 32, -388, 496, -680, -48, 208,
428  -116, -408, 60, -604, -392, 548, -840, 784, -460, 656, -544,
429  -388, -264, 908, -800, -628, -612, -568, 572, -220, 164, 288,
430  -16, -308, 308, -112, -636, -760, 280, -668, 432, 364, 240,
431  -196, 604, 340, 384, 196, 592, -44, -500, 432, -580, -132,
432  636, -76, 392, 4, -412, 540, 508, 328, -356, -36, 16,
433  -220, -64, -248, -60, 24, -192, 368, 1040, 92, -24, -1044,
434  -32, 40, 104, 148, 192, -136, -520, 56, -816, -224, 732,
435  392, 356, 212, -80, -424, -1008, -324, 588, -1496, 576, 460,
436  -816, -848, 56, -580, -92, -1372, -112, -496, 200, 364, 52,
437  -140, 48, -48, -60, 84, 72, 40, 132, -356, -268, -104,
438  -284, -404, 732, -520, 164, -304, -540, 120, 328, -76, -460,
439  756, 388, 588, 236, -436, -72, -176, -404, -316, -148, 716,
440  -604, 404, -72, -88, -888, -68, 944, 88, -220, -344, 960,
441  472, 460, -232, 704, 120, 832, -228, 692, -508, 132, -476,
442  844, -748, -364, -44, 1116, -1104, -1056, 76, 428, 552, -692,
443  60, 356, 96, -384, -188, -612, -576, 736, 508, 892, 352,
444  -1132, 504, -24, -352, 324, 332, -600, -312, 292, 508, -144,
445  -8, 484, 48, 284, -260, -240, 256, -100, -292, -204, -44,
446  472, -204, 908, -188, -1000, -256, 92, 1164, -392, 564, 356,
447  652, -28, -884, 256, 484, -192, 760, -176, 376, -524, -452,
448  -436, 860, -736, 212, 124, 504, -476, 468, 76, -472, 552,
449  -692, -944, -620, 740, -240, 400, 132, 20, 192, -196, 264,
450  -668, -1012, -60, 296, -316, -828, 76, -156, 284, -768, -448,
451  -832, 148, 248, 652, 616, 1236, 288, -328, -400, -124, 588,
452  220, 520, -696, 1032, 768, -740, -92, -272, 296, 448, -464,
453  412, -200, 392, 440, -200, 264, -152, -260, 320, 1032, 216,
454  320, -8, -64, 156, -1016, 1084, 1172, 536, 484, -432, 132,
455  372, -52, -256, 84, 116, -352, 48, 116, 304, -384, 412,
456  924, -300, 528, 628, 180, 648, 44, -980, -220, 1320, 48,
457  332, 748, 524, -268, -720, 540, -276, 564, -344, -208, -196,
458  436, 896, 88, -392, 132, 80, -964, -288, 568, 56, -48,
459  -456, 888, 8, 552, -156, -292, 948, 288, 128, -716, -292,
460  1192, -152, 876, 352, -600, -260, -812, -468, -28, -120, -32,
461  -44, 1284, 496, 192, 464, 312, -76, -516, -380, -456, -1012,
462  -48, 308, -156, 36, 492, -156, -808, 188, 1652, 68, -120,
463  -116, 316, 160, -140, 352, 808, -416, 592, 316, -480, 56,
464  528, -204, -568, 372, -232, 752, -344, 744, -4, 324, -416,
465  -600, 768, 268, -248, -88, -132, -420, -432, 80, -288, 404,
466  -316, -1216, -588, 520, -108, 92, -320, 368, -480, -216, -92,
467  1688, -300, 180, 1020, -176, 820, -68, -228, -260, 436, -904,
468  20, 40, -508, 440, -736, 312, 332, 204, 760, -372, 728,
469  96, -20, -632, -520, -560, 336, 1076, -64, -532, 776, 584,
470  192, 396, -728, -520, 276, -188, 80, -52, -612, -252, -48,
471  648, 212, -688, 228, -52, -260, 428, -412, -272, -404, 180,
472  816, -796, 48, 152, 484, -88, -216, 988, 696, 188, -528,
473  648, -116, -180, 316, 476, 12, -564, 96, 476, -252, -364,
474  -376, -392, 556, -256, -576, 260, -352, 120, -16, -136, -260,
475  -492, 72, 556, 660, 580, 616, 772, 436, 424, -32, -324,
476  -1268, 416, -324, -80, 920, 160, 228, 724, 32, -516, 64,
477  384, 68, -128, 136, 240, 248, -204, -68, 252, -932, -120,
478  -480, -628, -84, 192, 852, -404, -288, -132, 204, 100, 168,
479  -68, -196, -868, 460, 1080, 380, -80, 244, 0, 484, -888,
480  64, 184, 352, 600, 460, 164, 604, -196, 320, -64, 588,
481  -184, 228, 12, 372, 48, -848, -344, 224, 208, -200, 484,
482  128, -20, 272, -468, -840, 384, 256, -720, -520, -464, -580,
483  112, -120, 644, -356, -208, -608, -528, 704, 560, -424, 392,
484  828, 40, 84, 200, -152, 0, -144, 584, 280, -120, 80,
485  -556, -972, -196, -472, 724, 80, 168, -32, 88, 160, -688,
486  0, 160, 356, 372, -776, 740, -128, 676, -248, -480, 4,
487  -364, 96, 544, 232, -1032, 956, 236, 356, 20, -40, 300,
488  24, -676, -596, 132, 1120, -104, 532, -1096, 568, 648, 444,
489  508, 380, 188, -376, -604, 1488, 424, 24, 756, -220, -192,
490  716, 120, 920, 688, 168, 44, -460, 568, 284, 1144, 1160,
491  600, 424, 888, 656, -356, -320, 220, 316, -176, -724, -188,
492  -816, -628, -348, -228, -380, 1012, -452, -660, 736, 928, 404,
493  -696, -72, -268, -892, 128, 184, -344, -780, 360, 336, 400,
494  344, 428, 548, -112, 136, -228, -216, -820, -516, 340, 92,
495  -136, 116, -300, 376, -244, 100, -316, -520, -284, -12, 824,
496  164, -548, -180, -128, 116, -924, -828, 268, -368, -580, 620,
497  192, 160, 0, -1676, 1068, 424, -56, -360, 468, -156, 720,
498  288, -528, 556, -364, 548, -148, 504, 316, 152, -648, -620,
499  -684, -24, -376, -384, -108, -920, -1032, 768, 180, -264, -508,
500  -1268, -260, -60, 300, -240, 988, 724, -376, -576, -212, -736,
501  556, 192, 1092, -620, -880, 376, -56, -4, -216, -32, 836,
502  268, 396, 1332, 864, -600, 100, 56, -412, -92, 356, 180,
503  884, -468, -436, 292, -388, -804, -704, -840, 368, -348, 140,
504  -724, 1536, 940, 372, 112, -372, 436, -480, 1136, 296, -32,
505  -228, 132, -48, -220, 868, -1016, -60, -1044, -464, 328, 916,
506  244, 12, -736, -296, 360, 468, -376, -108, -92, 788, 368,
507  -56, 544, 400, -672, -420, 728, 16, 320, 44, -284, -380,
508  -796, 488, 132, 204, -596, -372, 88, -152, -908, -636, -572,
509  -624, -116, -692, -200, -56, 276, -88, 484, -324, 948, 864,
510  1000, -456, -184, -276, 292, -296, 156, 676, 320, 160, 908,
511  -84, -1236, -288, -116, 260, -372, -644, 732, -756, -96, 84,
512  344, -520, 348, -688, 240, -84, 216, -1044, -136, -676, -396,
513  -1500, 960, -40, 176, 168, 1516, 420, -504, -344, -364, -360,
514  1216, -940, -380, -212, 252, -660, -708, 484, -444, -152, 928,
515  -120, 1112, 476, -260, 560, -148, -344, 108, -196, 228, -288,
516  504, 560, -328, -88, 288, -1008, 460, -228, 468, -836, -196,
517  76, 388, 232, 412, -1168, -716, -644, 756, -172, -356, -504,
518  116, 432, 528, 48, 476, -168, -608, 448, 160, -532, -272,
519  28, -676, -12, 828, 980, 456, 520, 104, -104, 256, -344,
520  -4, -28, -368, -52, -524, -572, -556, -200, 768, 1124, -208,
521  -512, 176, 232, 248, -148, -888, 604, -600, -304, 804, -156,
522  -212, 488, -192, -804, -256, 368, -360, -916, -328, 228, -240,
523  -448, -472, 856, -556, -364, 572, -12, -156, -368, -340, 432,
524  252, -752, -152, 288, 268, -580, -848, -592, 108, -76, 244,
525  312, -716, 592, -80, 436, 360, 4, -248, 160, 516, 584,
526  732, 44, -468, -280, -292, -156, -588, 28, 308, 912, 24,
527  124, 156, 180, -252, 944, -924, -772, -520, -428, -624, 300,
528  -212, -1144, 32, -724, 800, -1128, -212, -1288, -848, 180, -416,
529  440, 192, -576, -792, -76, -1080, 80, -532, -352, -132, 380,
530  -820, 148, 1112, 128, 164, 456, 700, -924, 144, -668, -384,
531  648, -832, 508, 552, -52, -100, -656, 208, -568, 748, -88,
532  680, 232, 300, 192, -408, -1012, -152, -252, -268, 272, -876,
533  -664, -648, -332, -136, 16, 12, 1152, -28, 332, -536, 320,
534  -672, -460, -316, 532, -260, 228, -40, 1052, -816, 180, 88,
535  -496, -556, -672, -368, 428, 92, 356, 404, -408, 252, 196,
536  -176, -556, 792, 268, 32, 372, 40, 96, -332, 328, 120,
537  372, -900, -40, 472, -264, -592, 952, 128, 656, 112, 664,
538  -232, 420, 4, -344, -464, 556, 244, -416, -32, 252, 0,
539  -412, 188, -696, 508, -476, 324, -1096, 656, -312, 560, 264,
540  -136, 304, 160, -64, -580, 248, 336, -720, 560, -348, -288,
541  -276, -196, -500, 852, -544, -236, -1128, -992, -776, 116, 56,
542  52, 860, 884, 212, -12, 168, 1020, 512, -552, 924, -148,
543  716, 188, 164, -340, -520, -184, 880, -152, -680, -208, -1156,
544  -300, -528, -472, 364, 100, -744, -1056, -32, 540, 280, 144,
545  -676, -32, -232, -280, -224, 96, 568, -76, 172, 148, 148,
546  104, 32, -296, -32, 788, -80, 32, -16, 280, 288, 944,
547  428, -484
548 };
AVCOL_PRI_RESERVED
@ AVCOL_PRI_RESERVED
Definition: pixfmt.h:590
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:287
out
FILE * out
Definition: movenc.c:55
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
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:266
get_random_number
static int get_random_number(const int bits, unsigned *const state)
Definition: aom_film_grain.c:35
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:260
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:633
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:660
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
data
const char data[16]
Definition: mxf.c:149
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
AVFilmGrainParams::color_space
enum AVColorSpace color_space
Definition: film_grain_params.h:282
ff_aom_apply_film_grain
int ff_aom_apply_film_grain(AVFrame *out, const AVFrame *in, const AVFilmGrainParams *params)
Definition: aom_film_grain.c:66
AVFilmGrainParams::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: film_grain_params.h:281
GRAIN_WIDTH
@ GRAIN_WIDTH
Definition: aom_film_grain.c:48
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:250
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:482
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
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
state
static struct @464 state
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:56
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:644
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:108
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:500
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:505
AVFilmGrainParams::bit_depth_chroma
int bit_depth_chroma
Definition: film_grain_params.h:288
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:545
AVFilmGrainParams::width
int width
Intended display resolution.
Definition: film_grain_params.h:269
AVCOL_PRI_RESERVED0
@ AVCOL_PRI_RESERVED0
Definition: pixfmt.h:587
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
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:604
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
av_film_grain_params_create_side_data
AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)
Allocate a complete AVFilmGrainParams and add it to the frame.
Definition: film_grain_params.c:33
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:499
get_bits.h
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:589
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:483
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
AVCOL_TRC_RESERVED0
@ AVCOL_TRC_RESERVED0
Definition: pixfmt.h:612
NULL
#define NULL
Definition: coverity.c:32
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
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
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:274
gaussian_sequence
static const int16_t gaussian_sequence[2048]
Definition: aom_film_grain.c:55
SUB_GRAIN_WIDTH
@ SUB_GRAIN_WIDTH
Definition: aom_film_grain.c:50
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
ff_aom_attach_film_grain_sets
int ff_aom_attach_film_grain_sets(const AVFilmGrainAFGS1Params *s, AVFrame *frame)
Definition: aom_film_grain.c:341
FG_BLOCK_SIZE
@ FG_BLOCK_SIZE
Definition: aom_film_grain.c:52
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:43
shift
static int shift(int a, int b)
Definition: bonk.c:261
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:507
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:509
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:238
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:476
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:122
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:280
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVFilmGrainParams::subsampling_y
int subsampling_y
Definition: film_grain_params.h:274
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
SUB_GRAIN_HEIGHT
@ SUB_GRAIN_HEIGHT
Definition: aom_film_grain.c:51
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:501
AVFilmGrainParams::height
int height
Definition: film_grain_params.h:269
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:264
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:506
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:112
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:279
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:79
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
AVFilmGrainParams::codec
union AVFilmGrainParams::@434 codec
Additional fields may be added both here and in any structure included.
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:615
GRAIN_HEIGHT
@ GRAIN_HEIGHT
Definition: aom_film_grain.c:49
AVFilmGrainAFGS1Params
Definition: aom_film_grain.h:33
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:434
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:484
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:242
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 Nov 6 2024 19:21:30 for FFmpeg by   doxygen 1.8.17