FFmpeg
vf_spp.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (c) 2013 Clément Bœsch <u pkh me>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (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
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21 
22 /**
23  * @file
24  * Simple post processing filter
25  *
26  * This implementation is based on an algorithm described in
27  * "Aria Nosratinia Embedded Post-Processing for
28  * Enhancement of Compressed Images (1999)"
29  *
30  * Originally written by Michael Niedermayer for the MPlayer project, and
31  * ported by Clément Bœsch for FFmpeg.
32  */
33 
34 #include "libavutil/avassert.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/mem_internal.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/pixdesc.h"
39 #include "internal.h"
40 #include "qp_table.h"
41 #include "vf_spp.h"
42 
43 enum mode {
47 };
48 
49 #if FF_API_CHILD_CLASS_NEXT
50 static const AVClass *child_class_next(const AVClass *prev)
51 {
52  return prev ? NULL : avcodec_dct_get_class();
53 }
54 #endif
55 
56 static const AVClass *child_class_iterate(void **iter)
57 {
58  const AVClass *c = *iter ? NULL : avcodec_dct_get_class();
59  *iter = (void*)(uintptr_t)c;
60  return c;
61 }
62 
63 static void *child_next(void *obj, void *prev)
64 {
65  SPPContext *s = obj;
66  return prev ? NULL : s->dct;
67 }
68 
69 #define OFFSET(x) offsetof(SPPContext, x)
70 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
71 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
72 static const AVOption spp_options[] = {
73  { "quality", "set quality", OFFSET(log2_count), AV_OPT_TYPE_INT, {.i64 = 3}, 0, MAX_LEVEL, TFLAGS },
74  { "qp", "force a constant quantizer parameter", OFFSET(qp), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 63, FLAGS },
75  { "mode", "set thresholding mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_HARD}, 0, NB_MODES - 1, FLAGS, "mode" },
76  { "hard", "hard thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_HARD}, INT_MIN, INT_MAX, FLAGS, "mode" },
77  { "soft", "soft thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_SOFT}, INT_MIN, INT_MAX, FLAGS, "mode" },
78  { "use_bframe_qp", "use B-frames' QP", OFFSET(use_bframe_qp), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
79  { NULL }
80 };
81 
82 static const AVClass spp_class = {
83  .class_name = "spp",
84  .item_name = av_default_item_name,
85  .option = spp_options,
86  .version = LIBAVUTIL_VERSION_INT,
87  .category = AV_CLASS_CATEGORY_FILTER,
88 #if FF_API_CHILD_CLASS_NEXT
89  .child_class_next = child_class_next,
90 #endif
91  .child_class_iterate = child_class_iterate,
93 };
94 
95 // XXX: share between filters?
96 DECLARE_ALIGNED(8, static const uint8_t, ldither)[8][8] = {
97  { 0, 48, 12, 60, 3, 51, 15, 63 },
98  { 32, 16, 44, 28, 35, 19, 47, 31 },
99  { 8, 56, 4, 52, 11, 59, 7, 55 },
100  { 40, 24, 36, 20, 43, 27, 39, 23 },
101  { 2, 50, 14, 62, 1, 49, 13, 61 },
102  { 34, 18, 46, 30, 33, 17, 45, 29 },
103  { 10, 58, 6, 54, 9, 57, 5, 53 },
104  { 42, 26, 38, 22, 41, 25, 37, 21 },
105 };
106 
107 static const uint8_t offset[127][2] = {
108  {0,0},
109  {0,0}, {4,4}, // quality = 1
110  {0,0}, {2,2}, {6,4}, {4,6}, // quality = 2
111  {0,0}, {5,1}, {2,2}, {7,3}, {4,4}, {1,5}, {6,6}, {3,7}, // quality = 3
112 
113  {0,0}, {4,0}, {1,1}, {5,1}, {3,2}, {7,2}, {2,3}, {6,3}, // quality = 4
114  {0,4}, {4,4}, {1,5}, {5,5}, {3,6}, {7,6}, {2,7}, {6,7},
115 
116  {0,0}, {0,2}, {0,4}, {0,6}, {1,1}, {1,3}, {1,5}, {1,7}, // quality = 5
117  {2,0}, {2,2}, {2,4}, {2,6}, {3,1}, {3,3}, {3,5}, {3,7},
118  {4,0}, {4,2}, {4,4}, {4,6}, {5,1}, {5,3}, {5,5}, {5,7},
119  {6,0}, {6,2}, {6,4}, {6,6}, {7,1}, {7,3}, {7,5}, {7,7},
120 
121  {0,0}, {4,4}, {0,4}, {4,0}, {2,2}, {6,6}, {2,6}, {6,2}, // quality = 6
122  {0,2}, {4,6}, {0,6}, {4,2}, {2,0}, {6,4}, {2,4}, {6,0},
123  {1,1}, {5,5}, {1,5}, {5,1}, {3,3}, {7,7}, {3,7}, {7,3},
124  {1,3}, {5,7}, {1,7}, {5,3}, {3,1}, {7,5}, {3,5}, {7,1},
125  {0,1}, {4,5}, {0,5}, {4,1}, {2,3}, {6,7}, {2,7}, {6,3},
126  {0,3}, {4,7}, {0,7}, {4,3}, {2,1}, {6,5}, {2,5}, {6,1},
127  {1,0}, {5,4}, {1,4}, {5,0}, {3,2}, {7,6}, {3,6}, {7,2},
128  {1,2}, {5,6}, {1,6}, {5,2}, {3,0}, {7,4}, {3,4}, {7,0},
129 };
130 
131 static void hardthresh_c(int16_t dst[64], const int16_t src[64],
132  int qp, const uint8_t *permutation)
133 {
134  int i;
135  int bias = 0; // FIXME
136 
137  unsigned threshold1 = qp * ((1<<4) - bias) - 1;
138  unsigned threshold2 = threshold1 << 1;
139 
140  memset(dst, 0, 64 * sizeof(dst[0]));
141  dst[0] = (src[0] + 4) >> 3;
142 
143  for (i = 1; i < 64; i++) {
144  int level = src[i];
145  if (((unsigned)(level + threshold1)) > threshold2) {
146  const int j = permutation[i];
147  dst[j] = (level + 4) >> 3;
148  }
149  }
150 }
151 
152 static void softthresh_c(int16_t dst[64], const int16_t src[64],
153  int qp, const uint8_t *permutation)
154 {
155  int i;
156  int bias = 0; //FIXME
157 
158  unsigned threshold1 = qp * ((1<<4) - bias) - 1;
159  unsigned threshold2 = threshold1 << 1;
160 
161  memset(dst, 0, 64 * sizeof(dst[0]));
162  dst[0] = (src[0] + 4) >> 3;
163 
164  for (i = 1; i < 64; i++) {
165  int level = src[i];
166  if (((unsigned)(level + threshold1)) > threshold2) {
167  const int j = permutation[i];
168  if (level > 0) dst[j] = (level - threshold1 + 4) >> 3;
169  else dst[j] = (level + threshold1 + 4) >> 3;
170  }
171  }
172 }
173 
174 static void store_slice_c(uint8_t *dst, const int16_t *src,
175  int dst_linesize, int src_linesize,
176  int width, int height, int log2_scale,
177  const uint8_t dither[8][8])
178 {
179  int y, x;
180 
181 #define STORE(pos) do { \
182  temp = ((src[x + y*src_linesize + pos] << log2_scale) + d[pos]) >> 6; \
183  if (temp & 0x100) \
184  temp = ~(temp >> 31); \
185  dst[x + y*dst_linesize + pos] = temp; \
186 } while (0)
187 
188  for (y = 0; y < height; y++) {
189  const uint8_t *d = dither[y];
190  for (x = 0; x < width; x += 8) {
191  int temp;
192  STORE(0);
193  STORE(1);
194  STORE(2);
195  STORE(3);
196  STORE(4);
197  STORE(5);
198  STORE(6);
199  STORE(7);
200  }
201  }
202 }
203 
204 static void store_slice16_c(uint16_t *dst, const int16_t *src,
205  int dst_linesize, int src_linesize,
206  int width, int height, int log2_scale,
207  const uint8_t dither[8][8], int depth)
208 {
209  int y, x;
210  unsigned int mask = -1<<depth;
211 
212 #define STORE16(pos) do { \
213  temp = ((src[x + y*src_linesize + pos] << log2_scale) + (d[pos]>>1)) >> 5; \
214  if (temp & mask ) \
215  temp = ~(temp >> 31); \
216  dst[x + y*dst_linesize + pos] = temp; \
217 } while (0)
218 
219  for (y = 0; y < height; y++) {
220  const uint8_t *d = dither[y];
221  for (x = 0; x < width; x += 8) {
222  int temp;
223  STORE16(0);
224  STORE16(1);
225  STORE16(2);
226  STORE16(3);
227  STORE16(4);
228  STORE16(5);
229  STORE16(6);
230  STORE16(7);
231  }
232  }
233 }
234 
235 static inline void add_block(uint16_t *dst, int linesize, const int16_t block[64])
236 {
237  int y;
238 
239  for (y = 0; y < 8; y++) {
240  dst[0 + y*linesize] += block[0 + y*8];
241  dst[1 + y*linesize] += block[1 + y*8];
242  dst[2 + y*linesize] += block[2 + y*8];
243  dst[3 + y*linesize] += block[3 + y*8];
244  dst[4 + y*linesize] += block[4 + y*8];
245  dst[5 + y*linesize] += block[5 + y*8];
246  dst[6 + y*linesize] += block[6 + y*8];
247  dst[7 + y*linesize] += block[7 + y*8];
248  }
249 }
250 
251 static void filter(SPPContext *p, uint8_t *dst, uint8_t *src,
252  int dst_linesize, int src_linesize, int width, int height,
253  const uint8_t *qp_table, int qp_stride, int is_luma, int depth)
254 {
255  int x, y, i;
256  const int count = 1 << p->log2_count;
257  const int linesize = is_luma ? p->temp_linesize : FFALIGN(width+16, 16);
258  DECLARE_ALIGNED(16, uint64_t, block_align)[32];
259  int16_t *block = (int16_t *)block_align;
260  int16_t *block2 = (int16_t *)(block_align + 16);
261  uint16_t *psrc16 = (uint16_t*)p->src;
262  const int sample_bytes = (depth+7) / 8;
263 
264  for (y = 0; y < height; y++) {
265  int index = 8 + 8*linesize + y*linesize;
266  memcpy(p->src + index*sample_bytes, src + y*src_linesize, width*sample_bytes);
267  if (sample_bytes == 1) {
268  for (x = 0; x < 8; x++) {
269  p->src[index - x - 1] = p->src[index + x ];
270  p->src[index + width + x ] = p->src[index + width - x - 1];
271  }
272  } else {
273  for (x = 0; x < 8; x++) {
274  psrc16[index - x - 1] = psrc16[index + x ];
275  psrc16[index + width + x ] = psrc16[index + width - x - 1];
276  }
277  }
278  }
279  for (y = 0; y < 8; y++) {
280  memcpy(p->src + ( 7-y)*linesize * sample_bytes, p->src + ( y+8)*linesize * sample_bytes, linesize * sample_bytes);
281  memcpy(p->src + (height+8+y)*linesize * sample_bytes, p->src + (height-y+7)*linesize * sample_bytes, linesize * sample_bytes);
282  }
283 
284  for (y = 0; y < height + 8; y += 8) {
285  memset(p->temp + (8 + y) * linesize, 0, 8 * linesize * sizeof(*p->temp));
286  for (x = 0; x < width + 8; x += 8) {
287  int qp;
288 
289  if (p->qp) {
290  qp = p->qp;
291  } else{
292  const int qps = 3 + is_luma;
293  qp = qp_table[(FFMIN(x, width - 1) >> qps) + (FFMIN(y, height - 1) >> qps) * qp_stride];
294  qp = FFMAX(1, ff_norm_qscale(qp, p->qscale_type));
295  }
296  for (i = 0; i < count; i++) {
297  const int x1 = x + offset[i + count - 1][0];
298  const int y1 = y + offset[i + count - 1][1];
299  const int index = x1 + y1*linesize;
300  p->dct->get_pixels_unaligned(block, p->src + sample_bytes*index, sample_bytes*linesize);
301  p->dct->fdct(block);
302  p->requantize(block2, block, qp, p->dct->idct_permutation);
303  p->dct->idct(block2);
304  add_block(p->temp + index, linesize, block2);
305  }
306  }
307  if (y) {
308  if (sample_bytes == 1) {
309  p->store_slice(dst + (y - 8) * dst_linesize, p->temp + 8 + y*linesize,
310  dst_linesize, linesize, width,
311  FFMIN(8, height + 8 - y), MAX_LEVEL - p->log2_count,
312  ldither);
313  } else {
314  store_slice16_c((uint16_t*)(dst + (y - 8) * dst_linesize), p->temp + 8 + y*linesize,
315  dst_linesize/2, linesize, width,
316  FFMIN(8, height + 8 - y), MAX_LEVEL - p->log2_count,
317  ldither, depth);
318  }
319  }
320  }
321 }
322 
324 {
325  static const enum AVPixelFormat pix_fmts[] = {
340  };
341 
342  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
343  if (!fmts_list)
344  return AVERROR(ENOMEM);
345  return ff_set_common_formats(ctx, fmts_list);
346 }
347 
349 {
350  SPPContext *s = inlink->dst->priv;
351  const int h = FFALIGN(inlink->h + 16, 16);
353  const int bps = desc->comp[0].depth;
354 
355  av_opt_set_int(s->dct, "bits_per_sample", bps, 0);
356  avcodec_dct_init(s->dct);
357 
358  if (ARCH_X86)
359  ff_spp_init_x86(s);
360 
361  s->hsub = desc->log2_chroma_w;
362  s->vsub = desc->log2_chroma_h;
363  s->temp_linesize = FFALIGN(inlink->w + 16, 16);
364  s->temp = av_malloc_array(s->temp_linesize, h * sizeof(*s->temp));
365  s->src = av_malloc_array(s->temp_linesize, h * sizeof(*s->src) * 2);
366 
367  if (!s->temp || !s->src)
368  return AVERROR(ENOMEM);
369  return 0;
370 }
371 
373 {
374  AVFilterContext *ctx = inlink->dst;
375  SPPContext *s = ctx->priv;
376  AVFilterLink *outlink = ctx->outputs[0];
377  AVFrame *out = in;
378  int qp_stride = 0;
379  int8_t *qp_table = NULL;
381  const int depth = desc->comp[0].depth;
382  int ret = 0;
383 
384  /* if we are not in a constant user quantizer mode and we don't want to use
385  * the quantizers from the B-frames (B-frames often have a higher QP), we
386  * need to save the qp table from the last non B-frame; this is what the
387  * following code block does */
388  if (!s->qp && (s->use_bframe_qp || in->pict_type != AV_PICTURE_TYPE_B)) {
389  ret = ff_qp_table_extract(in, &qp_table, &qp_stride, NULL, &s->qscale_type);
390  if (ret < 0) {
391  av_frame_free(&in);
392  return ret;
393  }
394 
395  if (!s->use_bframe_qp && in->pict_type != AV_PICTURE_TYPE_B) {
397  s->non_b_qp_table = qp_table;
398  s->non_b_qp_stride = qp_stride;
399  }
400  }
401 
402  if (s->log2_count && !ctx->is_disabled) {
403  if (!s->use_bframe_qp && s->non_b_qp_table) {
404  qp_table = s->non_b_qp_table;
405  qp_stride = s->non_b_qp_stride;
406  }
407 
408  if (qp_table || s->qp) {
409  const int cw = AV_CEIL_RSHIFT(inlink->w, s->hsub);
410  const int ch = AV_CEIL_RSHIFT(inlink->h, s->vsub);
411 
412  /* get a new frame if in-place is not possible or if the dimensions
413  * are not multiple of 8 */
414  if (!av_frame_is_writable(in) || (inlink->w & 7) || (inlink->h & 7)) {
415  const int aligned_w = FFALIGN(inlink->w, 8);
416  const int aligned_h = FFALIGN(inlink->h, 8);
417 
418  out = ff_get_video_buffer(outlink, aligned_w, aligned_h);
419  if (!out) {
420  av_frame_free(&in);
421  ret = AVERROR(ENOMEM);
422  goto finish;
423  }
424  av_frame_copy_props(out, in);
425  out->width = in->width;
426  out->height = in->height;
427  }
428 
429  filter(s, out->data[0], in->data[0], out->linesize[0], in->linesize[0], inlink->w, inlink->h, qp_table, qp_stride, 1, depth);
430 
431  if (out->data[2]) {
432  filter(s, out->data[1], in->data[1], out->linesize[1], in->linesize[1], cw, ch, qp_table, qp_stride, 0, depth);
433  filter(s, out->data[2], in->data[2], out->linesize[2], in->linesize[2], cw, ch, qp_table, qp_stride, 0, depth);
434  }
435  emms_c();
436  }
437  }
438 
439  if (in != out) {
440  if (in->data[3])
441  av_image_copy_plane(out->data[3], out->linesize[3],
442  in ->data[3], in ->linesize[3],
443  inlink->w, inlink->h);
444  av_frame_free(&in);
445  }
446  ret = ff_filter_frame(outlink, out);
447 finish:
448  if (qp_table != s->non_b_qp_table)
449  av_freep(&qp_table);
450  return ret;
451 }
452 
453 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
454  char *res, int res_len, int flags)
455 {
456  SPPContext *s = ctx->priv;
457 
458  if (!strcmp(cmd, "level") || !strcmp(cmd, "quality")) {
459  if (!strcmp(args, "max"))
460  s->log2_count = MAX_LEVEL;
461  else
462  s->log2_count = av_clip(strtol(args, NULL, 10), 0, MAX_LEVEL);
463  return 0;
464  }
465  return AVERROR(ENOSYS);
466 }
467 
469 {
470  SPPContext *s = ctx->priv;
471  int ret;
472 
473  s->dct = avcodec_dct_alloc();
474  if (!s->dct)
475  return AVERROR(ENOMEM);
476 
477  if (opts) {
478  AVDictionaryEntry *e = NULL;
479 
480  while ((e = av_dict_get(*opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
481  if ((ret = av_opt_set(s->dct, e->key, e->value, 0)) < 0)
482  return ret;
483  }
484  av_dict_free(opts);
485  }
486 
488  switch (s->mode) {
489  case MODE_HARD: s->requantize = hardthresh_c; break;
490  case MODE_SOFT: s->requantize = softthresh_c; break;
491  }
492  return 0;
493 }
494 
496 {
497  SPPContext *s = ctx->priv;
498 
499  av_freep(&s->temp);
500  av_freep(&s->src);
501  av_freep(&s->dct);
503 }
504 
505 static const AVFilterPad spp_inputs[] = {
506  {
507  .name = "default",
508  .type = AVMEDIA_TYPE_VIDEO,
509  .config_props = config_input,
510  .filter_frame = filter_frame,
511  },
512  { NULL }
513 };
514 
515 static const AVFilterPad spp_outputs[] = {
516  {
517  .name = "default",
518  .type = AVMEDIA_TYPE_VIDEO,
519  },
520  { NULL }
521 };
522 
524  .name = "spp",
525  .description = NULL_IF_CONFIG_SMALL("Apply a simple post processing filter."),
526  .priv_size = sizeof(SPPContext),
527  .init_dict = init_dict,
528  .uninit = uninit,
530  .inputs = spp_inputs,
531  .outputs = spp_outputs,
533  .priv_class = &spp_class,
535 };
#define STORE16(pos)
void(* store_slice)(uint8_t *dst, const int16_t *src, int dst_stride, int src_stride, int width, int height, int log2_scale, const uint8_t dither[8][8])
Definition: vf_spp.h:46
#define NULL
Definition: coverity.c:32
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int use_bframe_qp
Definition: vf_spp.h:43
AVOption.
Definition: opt.h:248
av_cold void ff_spp_init_x86(SPPContext *s)
Definition: vf_spp.c:221
static int query_formats(AVFilterContext *ctx)
Definition: vf_spp.c:323
const char * desc
Definition: libsvtav1.c:79
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
int hsub
Definition: vf_spp.h:44
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
else temp
Definition: vf_mcdeint.c:256
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_spp.c:372
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_spp.c:453
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
static const uint8_t ldither[8][8]
Definition: vf_spp.c:96
static void softthresh_c(int16_t dst[64], const int16_t src[64], int qp, const uint8_t *permutation)
Definition: vf_spp.c:152
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:388
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:287
const char * name
Pad name.
Definition: internal.h:60
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_spp.c:495
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
int log2_count
Definition: vf_spp.h:33
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
void(* get_pixels_unaligned)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size)
Definition: avdct.h:71
static void store_slice16_c(uint16_t *dst, const int16_t *src, int dst_linesize, int src_linesize, int width, int height, int log2_scale, const uint8_t dither[8][8], int depth)
Definition: vf_spp.c:204
AVOptions.
#define OFFSET(x)
Definition: vf_spp.c:69
int non_b_qp_stride
Definition: vf_spp.h:42
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
#define height
#define av_clip
Definition: common.h:122
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:40
static void finish(void)
Definition: movenc.c:345
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:100
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
static void add_block(uint16_t *dst, int linesize, const int16_t block[64])
Definition: vf_spp.c:235
static const AVClass * child_class_iterate(void **iter)
Definition: vf_spp.c:56
#define FFALIGN(x, a)
Definition: macros.h:48
#define MAX_LEVEL
Definition: rl.h:36
A filter pad used for either input or output.
Definition: internal.h:54
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:113
#define src
Definition: vp8dsp.c:255
int width
Definition: frame.h:372
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:588
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int ff_qp_table_extract(AVFrame *frame, int8_t **table, int *table_w, int *table_h, int *qscale_type)
Extract a libpostproc-compatible QP table - an 8-bit QP value per 16x16 macroblock, stored in raster order - from AVVideoEncParams side data.
Definition: qp_table.c:30
static const uint16_t mask[17]
Definition: lzw.c:38
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59
void * priv
private data for use by the filter
Definition: avfilter.h:356
int temp_linesize
Definition: vf_spp.h:37
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:586
simple assert() macros that are a bit more flexible than ISO C assert().
#define TFLAGS
Definition: vf_spp.c:71
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
GLsizei count
Definition: opengl_enc.c:108
int avcodec_dct_init(AVDCT *dsp)
Definition: avdct.c:88
#define FFMAX(a, b)
Definition: common.h:103
static const AVClass spp_class
Definition: vf_spp.c:82
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int8_t * non_b_qp_table
Definition: vf_spp.h:41
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
AVDictionary * opts
Definition: movenc.c:50
AVDCT * avcodec_dct_alloc(void)
Allocates a AVDCT context.
Definition: avdct.c:75
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: avdct.h:48
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
#define FFMIN(a, b)
Definition: common.h:105
static void hardthresh_c(int16_t dst[64], const int16_t src[64], int qp, const uint8_t *permutation)
Definition: vf_spp.c:131
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
#define width
static int config_input(AVFilterLink *inlink)
Definition: vf_spp.c:348
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
int qscale_type
Definition: vf_spp.h:36
static av_cold int init_dict(AVFilterContext *ctx, AVDictionary **opts)
Definition: vf_spp.c:468
AVDCT * dct
Definition: vf_spp.h:40
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
const AVClass * avcodec_dct_get_class(void)
Definition: avdct.c:70
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
static const AVFilterPad spp_outputs[]
Definition: vf_spp.c:515
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void(* idct)(int16_t *block)
Definition: avdct.h:32
#define STORE(pos)
int vsub
Definition: vf_spp.h:44
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 inputs
uint16_t * temp
Definition: vf_spp.h:39
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
int qp
Definition: vf_spp.h:34
Filter definition.
Definition: avfilter.h:145
int index
Definition: gxfenc.c:89
void(* fdct)(int16_t *block)
Definition: avdct.h:50
#define FLAGS
Definition: vf_spp.c:70
const char * name
Filter name.
Definition: avfilter.h:149
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:134
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:353
static const AVFilterPad spp_inputs[]
Definition: vf_spp.c:505
static int ff_norm_qscale(int qscale, int type)
Normalize the qscale factor FIXME the H264 qscale is a log based scale, mpeg1/2 is not...
Definition: internal.h:351
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
void(* requantize)(int16_t dst[64], const int16_t src[64], int qp, const uint8_t *permutation)
Definition: vf_spp.h:51
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t level
Definition: svq3.c:206
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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
static void * child_next(void *obj, void *prev)
Definition: vf_spp.c:63
int mode
Definition: vf_spp.h:35
Bi-dir predicted.
Definition: avutil.h:276
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
char * key
Definition: dict.h:86
unsigned bps
Definition: movenc.c:1598
AVFilter ff_vf_spp
Definition: vf_spp.c:523
static void store_slice_c(uint8_t *dst, const int16_t *src, int dst_linesize, int src_linesize, int width, int height, int log2_scale, const uint8_t dither[8][8])
Definition: vf_spp.c:174
char * value
Definition: dict.h:87
A list of supported formats for one end of a filter link.
Definition: formats.h:65
An instance of a filter.
Definition: avfilter.h:341
int height
Definition: frame.h:372
FILE * out
Definition: movenc.c:54
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define av_malloc_array(a, b)
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:373
internal API functions
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
static const AVOption spp_options[]
Definition: vf_spp.c:72
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
static void filter(SPPContext *p, uint8_t *dst, uint8_t *src, int dst_linesize, int src_linesize, int width, int height, const uint8_t *qp_table, int qp_stride, int is_luma, int depth)
Definition: vf_spp.c:251
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
int i
Definition: input.c:407
uint8_t * src
Definition: vf_spp.h:38
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58