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/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "internal.h"
39 #include "vf_spp.h"
40 
41 enum mode {
45 };
46 
47 #if FF_API_CHILD_CLASS_NEXT
48 static const AVClass *child_class_next(const AVClass *prev)
49 {
50  return prev ? NULL : avcodec_dct_get_class();
51 }
52 #endif
53 
54 static const AVClass *child_class_iterate(void **iter)
55 {
56  const AVClass *c = *iter ? NULL : avcodec_dct_get_class();
57  *iter = (void*)(uintptr_t)c;
58  return c;
59 }
60 
61 static void *child_next(void *obj, void *prev)
62 {
63  SPPContext *s = obj;
64  return prev ? NULL : s->dct;
65 }
66 
67 #define OFFSET(x) offsetof(SPPContext, x)
68 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
69 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
70 static const AVOption spp_options[] = {
71  { "quality", "set quality", OFFSET(log2_count), AV_OPT_TYPE_INT, {.i64 = 3}, 0, MAX_LEVEL, TFLAGS },
72  { "qp", "force a constant quantizer parameter", OFFSET(qp), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 63, FLAGS },
73  { "mode", "set thresholding mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_HARD}, 0, NB_MODES - 1, FLAGS, "mode" },
74  { "hard", "hard thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_HARD}, INT_MIN, INT_MAX, FLAGS, "mode" },
75  { "soft", "soft thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_SOFT}, INT_MIN, INT_MAX, FLAGS, "mode" },
76  { "use_bframe_qp", "use B-frames' QP", OFFSET(use_bframe_qp), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS },
77  { NULL }
78 };
79 
80 static const AVClass spp_class = {
81  .class_name = "spp",
82  .item_name = av_default_item_name,
83  .option = spp_options,
84  .version = LIBAVUTIL_VERSION_INT,
85  .category = AV_CLASS_CATEGORY_FILTER,
86 #if FF_API_CHILD_CLASS_NEXT
87  .child_class_next = child_class_next,
88 #endif
89  .child_class_iterate = child_class_iterate,
91 };
92 
93 // XXX: share between filters?
94 DECLARE_ALIGNED(8, static const uint8_t, ldither)[8][8] = {
95  { 0, 48, 12, 60, 3, 51, 15, 63 },
96  { 32, 16, 44, 28, 35, 19, 47, 31 },
97  { 8, 56, 4, 52, 11, 59, 7, 55 },
98  { 40, 24, 36, 20, 43, 27, 39, 23 },
99  { 2, 50, 14, 62, 1, 49, 13, 61 },
100  { 34, 18, 46, 30, 33, 17, 45, 29 },
101  { 10, 58, 6, 54, 9, 57, 5, 53 },
102  { 42, 26, 38, 22, 41, 25, 37, 21 },
103 };
104 
105 static const uint8_t offset[127][2] = {
106  {0,0},
107  {0,0}, {4,4}, // quality = 1
108  {0,0}, {2,2}, {6,4}, {4,6}, // quality = 2
109  {0,0}, {5,1}, {2,2}, {7,3}, {4,4}, {1,5}, {6,6}, {3,7}, // quality = 3
110 
111  {0,0}, {4,0}, {1,1}, {5,1}, {3,2}, {7,2}, {2,3}, {6,3}, // quality = 4
112  {0,4}, {4,4}, {1,5}, {5,5}, {3,6}, {7,6}, {2,7}, {6,7},
113 
114  {0,0}, {0,2}, {0,4}, {0,6}, {1,1}, {1,3}, {1,5}, {1,7}, // quality = 5
115  {2,0}, {2,2}, {2,4}, {2,6}, {3,1}, {3,3}, {3,5}, {3,7},
116  {4,0}, {4,2}, {4,4}, {4,6}, {5,1}, {5,3}, {5,5}, {5,7},
117  {6,0}, {6,2}, {6,4}, {6,6}, {7,1}, {7,3}, {7,5}, {7,7},
118 
119  {0,0}, {4,4}, {0,4}, {4,0}, {2,2}, {6,6}, {2,6}, {6,2}, // quality = 6
120  {0,2}, {4,6}, {0,6}, {4,2}, {2,0}, {6,4}, {2,4}, {6,0},
121  {1,1}, {5,5}, {1,5}, {5,1}, {3,3}, {7,7}, {3,7}, {7,3},
122  {1,3}, {5,7}, {1,7}, {5,3}, {3,1}, {7,5}, {3,5}, {7,1},
123  {0,1}, {4,5}, {0,5}, {4,1}, {2,3}, {6,7}, {2,7}, {6,3},
124  {0,3}, {4,7}, {0,7}, {4,3}, {2,1}, {6,5}, {2,5}, {6,1},
125  {1,0}, {5,4}, {1,4}, {5,0}, {3,2}, {7,6}, {3,6}, {7,2},
126  {1,2}, {5,6}, {1,6}, {5,2}, {3,0}, {7,4}, {3,4}, {7,0},
127 };
128 
129 static void hardthresh_c(int16_t dst[64], const int16_t src[64],
130  int qp, const uint8_t *permutation)
131 {
132  int i;
133  int bias = 0; // FIXME
134 
135  unsigned threshold1 = qp * ((1<<4) - bias) - 1;
136  unsigned threshold2 = threshold1 << 1;
137 
138  memset(dst, 0, 64 * sizeof(dst[0]));
139  dst[0] = (src[0] + 4) >> 3;
140 
141  for (i = 1; i < 64; i++) {
142  int level = src[i];
143  if (((unsigned)(level + threshold1)) > threshold2) {
144  const int j = permutation[i];
145  dst[j] = (level + 4) >> 3;
146  }
147  }
148 }
149 
150 static void softthresh_c(int16_t dst[64], const int16_t src[64],
151  int qp, const uint8_t *permutation)
152 {
153  int i;
154  int bias = 0; //FIXME
155 
156  unsigned threshold1 = qp * ((1<<4) - bias) - 1;
157  unsigned threshold2 = threshold1 << 1;
158 
159  memset(dst, 0, 64 * sizeof(dst[0]));
160  dst[0] = (src[0] + 4) >> 3;
161 
162  for (i = 1; i < 64; i++) {
163  int level = src[i];
164  if (((unsigned)(level + threshold1)) > threshold2) {
165  const int j = permutation[i];
166  if (level > 0) dst[j] = (level - threshold1 + 4) >> 3;
167  else dst[j] = (level + threshold1 + 4) >> 3;
168  }
169  }
170 }
171 
172 static void store_slice_c(uint8_t *dst, const int16_t *src,
173  int dst_linesize, int src_linesize,
174  int width, int height, int log2_scale,
175  const uint8_t dither[8][8])
176 {
177  int y, x;
178 
179 #define STORE(pos) do { \
180  temp = ((src[x + y*src_linesize + pos] << log2_scale) + d[pos]) >> 6; \
181  if (temp & 0x100) \
182  temp = ~(temp >> 31); \
183  dst[x + y*dst_linesize + pos] = temp; \
184 } while (0)
185 
186  for (y = 0; y < height; y++) {
187  const uint8_t *d = dither[y];
188  for (x = 0; x < width; x += 8) {
189  int temp;
190  STORE(0);
191  STORE(1);
192  STORE(2);
193  STORE(3);
194  STORE(4);
195  STORE(5);
196  STORE(6);
197  STORE(7);
198  }
199  }
200 }
201 
202 static void store_slice16_c(uint16_t *dst, const int16_t *src,
203  int dst_linesize, int src_linesize,
204  int width, int height, int log2_scale,
205  const uint8_t dither[8][8], int depth)
206 {
207  int y, x;
208  unsigned int mask = -1<<depth;
209 
210 #define STORE16(pos) do { \
211  temp = ((src[x + y*src_linesize + pos] << log2_scale) + (d[pos]>>1)) >> 5; \
212  if (temp & mask ) \
213  temp = ~(temp >> 31); \
214  dst[x + y*dst_linesize + pos] = temp; \
215 } while (0)
216 
217  for (y = 0; y < height; y++) {
218  const uint8_t *d = dither[y];
219  for (x = 0; x < width; x += 8) {
220  int temp;
221  STORE16(0);
222  STORE16(1);
223  STORE16(2);
224  STORE16(3);
225  STORE16(4);
226  STORE16(5);
227  STORE16(6);
228  STORE16(7);
229  }
230  }
231 }
232 
233 static inline void add_block(uint16_t *dst, int linesize, const int16_t block[64])
234 {
235  int y;
236 
237  for (y = 0; y < 8; y++) {
238  dst[0 + y*linesize] += block[0 + y*8];
239  dst[1 + y*linesize] += block[1 + y*8];
240  dst[2 + y*linesize] += block[2 + y*8];
241  dst[3 + y*linesize] += block[3 + y*8];
242  dst[4 + y*linesize] += block[4 + y*8];
243  dst[5 + y*linesize] += block[5 + y*8];
244  dst[6 + y*linesize] += block[6 + y*8];
245  dst[7 + y*linesize] += block[7 + y*8];
246  }
247 }
248 
249 static void filter(SPPContext *p, uint8_t *dst, uint8_t *src,
250  int dst_linesize, int src_linesize, int width, int height,
251  const uint8_t *qp_table, int qp_stride, int is_luma, int depth)
252 {
253  int x, y, i;
254  const int count = 1 << p->log2_count;
255  const int linesize = is_luma ? p->temp_linesize : FFALIGN(width+16, 16);
256  DECLARE_ALIGNED(16, uint64_t, block_align)[32];
257  int16_t *block = (int16_t *)block_align;
258  int16_t *block2 = (int16_t *)(block_align + 16);
259  uint16_t *psrc16 = (uint16_t*)p->src;
260  const int sample_bytes = (depth+7) / 8;
261 
262  for (y = 0; y < height; y++) {
263  int index = 8 + 8*linesize + y*linesize;
264  memcpy(p->src + index*sample_bytes, src + y*src_linesize, width*sample_bytes);
265  if (sample_bytes == 1) {
266  for (x = 0; x < 8; x++) {
267  p->src[index - x - 1] = p->src[index + x ];
268  p->src[index + width + x ] = p->src[index + width - x - 1];
269  }
270  } else {
271  for (x = 0; x < 8; x++) {
272  psrc16[index - x - 1] = psrc16[index + x ];
273  psrc16[index + width + x ] = psrc16[index + width - x - 1];
274  }
275  }
276  }
277  for (y = 0; y < 8; y++) {
278  memcpy(p->src + ( 7-y)*linesize * sample_bytes, p->src + ( y+8)*linesize * sample_bytes, linesize * sample_bytes);
279  memcpy(p->src + (height+8+y)*linesize * sample_bytes, p->src + (height-y+7)*linesize * sample_bytes, linesize * sample_bytes);
280  }
281 
282  for (y = 0; y < height + 8; y += 8) {
283  memset(p->temp + (8 + y) * linesize, 0, 8 * linesize * sizeof(*p->temp));
284  for (x = 0; x < width + 8; x += 8) {
285  int qp;
286 
287  if (p->qp) {
288  qp = p->qp;
289  } else{
290  const int qps = 3 + is_luma;
291  qp = qp_table[(FFMIN(x, width - 1) >> qps) + (FFMIN(y, height - 1) >> qps) * qp_stride];
292  qp = FFMAX(1, ff_norm_qscale(qp, p->qscale_type));
293  }
294  for (i = 0; i < count; i++) {
295  const int x1 = x + offset[i + count - 1][0];
296  const int y1 = y + offset[i + count - 1][1];
297  const int index = x1 + y1*linesize;
298  p->dct->get_pixels_unaligned(block, p->src + sample_bytes*index, sample_bytes*linesize);
299  p->dct->fdct(block);
300  p->requantize(block2, block, qp, p->dct->idct_permutation);
301  p->dct->idct(block2);
302  add_block(p->temp + index, linesize, block2);
303  }
304  }
305  if (y) {
306  if (sample_bytes == 1) {
307  p->store_slice(dst + (y - 8) * dst_linesize, p->temp + 8 + y*linesize,
308  dst_linesize, linesize, width,
309  FFMIN(8, height + 8 - y), MAX_LEVEL - p->log2_count,
310  ldither);
311  } else {
312  store_slice16_c((uint16_t*)(dst + (y - 8) * dst_linesize), p->temp + 8 + y*linesize,
313  dst_linesize/2, linesize, width,
314  FFMIN(8, height + 8 - y), MAX_LEVEL - p->log2_count,
315  ldither, depth);
316  }
317  }
318  }
319 }
320 
322 {
323  static const enum AVPixelFormat pix_fmts[] = {
338  };
339 
340  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
341  if (!fmts_list)
342  return AVERROR(ENOMEM);
343  return ff_set_common_formats(ctx, fmts_list);
344 }
345 
347 {
348  SPPContext *s = inlink->dst->priv;
349  const int h = FFALIGN(inlink->h + 16, 16);
351  const int bps = desc->comp[0].depth;
352 
353  av_opt_set_int(s->dct, "bits_per_sample", bps, 0);
354  avcodec_dct_init(s->dct);
355 
356  if (ARCH_X86)
357  ff_spp_init_x86(s);
358 
359  s->hsub = desc->log2_chroma_w;
360  s->vsub = desc->log2_chroma_h;
361  s->temp_linesize = FFALIGN(inlink->w + 16, 16);
362  s->temp = av_malloc_array(s->temp_linesize, h * sizeof(*s->temp));
363  s->src = av_malloc_array(s->temp_linesize, h * sizeof(*s->src) * 2);
364 
365  if (!s->temp || !s->src)
366  return AVERROR(ENOMEM);
367  return 0;
368 }
369 
371 {
372  AVFilterContext *ctx = inlink->dst;
373  SPPContext *s = ctx->priv;
374  AVFilterLink *outlink = ctx->outputs[0];
375  AVFrame *out = in;
376  int qp_stride = 0;
377  const int8_t *qp_table = NULL;
379  const int depth = desc->comp[0].depth;
380 
381  /* if we are not in a constant user quantizer mode and we don't want to use
382  * the quantizers from the B-frames (B-frames often have a higher QP), we
383  * need to save the qp table from the last non B-frame; this is what the
384  * following code block does */
385  if (!s->qp) {
386  qp_table = av_frame_get_qp_table(in, &qp_stride, &s->qscale_type);
387 
388  if (qp_table && !s->use_bframe_qp && in->pict_type != AV_PICTURE_TYPE_B) {
389  int w, h;
390 
391  /* if the qp stride is not set, it means the QP are only defined on
392  * a line basis */
393  if (!qp_stride) {
394  w = AV_CEIL_RSHIFT(inlink->w, 4);
395  h = 1;
396  } else {
397  w = qp_stride;
398  h = AV_CEIL_RSHIFT(inlink->h, 4);
399  }
400 
401  if (w * h > s->non_b_qp_alloc_size) {
402  int ret = av_reallocp_array(&s->non_b_qp_table, w, h);
403  if (ret < 0) {
404  s->non_b_qp_alloc_size = 0;
405  return ret;
406  }
407  s->non_b_qp_alloc_size = w * h;
408  }
409 
410  av_assert0(w * h <= s->non_b_qp_alloc_size);
411  memcpy(s->non_b_qp_table, qp_table, w * h);
412  }
413  }
414 
415  if (s->log2_count && !ctx->is_disabled) {
416  if (!s->use_bframe_qp && s->non_b_qp_table)
417  qp_table = s->non_b_qp_table;
418 
419  if (qp_table || s->qp) {
420  const int cw = AV_CEIL_RSHIFT(inlink->w, s->hsub);
421  const int ch = AV_CEIL_RSHIFT(inlink->h, s->vsub);
422 
423  /* get a new frame if in-place is not possible or if the dimensions
424  * are not multiple of 8 */
425  if (!av_frame_is_writable(in) || (inlink->w & 7) || (inlink->h & 7)) {
426  const int aligned_w = FFALIGN(inlink->w, 8);
427  const int aligned_h = FFALIGN(inlink->h, 8);
428 
429  out = ff_get_video_buffer(outlink, aligned_w, aligned_h);
430  if (!out) {
431  av_frame_free(&in);
432  return AVERROR(ENOMEM);
433  }
434  av_frame_copy_props(out, in);
435  out->width = in->width;
436  out->height = in->height;
437  }
438 
439  filter(s, out->data[0], in->data[0], out->linesize[0], in->linesize[0], inlink->w, inlink->h, qp_table, qp_stride, 1, depth);
440 
441  if (out->data[2]) {
442  filter(s, out->data[1], in->data[1], out->linesize[1], in->linesize[1], cw, ch, qp_table, qp_stride, 0, depth);
443  filter(s, out->data[2], in->data[2], out->linesize[2], in->linesize[2], cw, ch, qp_table, qp_stride, 0, depth);
444  }
445  emms_c();
446  }
447  }
448 
449  if (in != out) {
450  if (in->data[3])
451  av_image_copy_plane(out->data[3], out->linesize[3],
452  in ->data[3], in ->linesize[3],
453  inlink->w, inlink->h);
454  av_frame_free(&in);
455  }
456  return ff_filter_frame(outlink, out);
457 }
458 
459 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
460  char *res, int res_len, int flags)
461 {
462  SPPContext *s = ctx->priv;
463 
464  if (!strcmp(cmd, "level") || !strcmp(cmd, "quality")) {
465  if (!strcmp(args, "max"))
466  s->log2_count = MAX_LEVEL;
467  else
468  s->log2_count = av_clip(strtol(args, NULL, 10), 0, MAX_LEVEL);
469  return 0;
470  }
471  return AVERROR(ENOSYS);
472 }
473 
475 {
476  SPPContext *s = ctx->priv;
477  int ret;
478 
479  s->dct = avcodec_dct_alloc();
480  if (!s->dct)
481  return AVERROR(ENOMEM);
482 
483  if (opts) {
484  AVDictionaryEntry *e = NULL;
485 
486  while ((e = av_dict_get(*opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
487  if ((ret = av_opt_set(s->dct, e->key, e->value, 0)) < 0)
488  return ret;
489  }
490  av_dict_free(opts);
491  }
492 
494  switch (s->mode) {
495  case MODE_HARD: s->requantize = hardthresh_c; break;
496  case MODE_SOFT: s->requantize = softthresh_c; break;
497  }
498  return 0;
499 }
500 
502 {
503  SPPContext *s = ctx->priv;
504 
505  av_freep(&s->temp);
506  av_freep(&s->src);
507  av_freep(&s->dct);
509 }
510 
511 static const AVFilterPad spp_inputs[] = {
512  {
513  .name = "default",
514  .type = AVMEDIA_TYPE_VIDEO,
515  .config_props = config_input,
516  .filter_frame = filter_frame,
517  },
518  { NULL }
519 };
520 
521 static const AVFilterPad spp_outputs[] = {
522  {
523  .name = "default",
524  .type = AVMEDIA_TYPE_VIDEO,
525  },
526  { NULL }
527 };
528 
530  .name = "spp",
531  .description = NULL_IF_CONFIG_SMALL("Apply a simple post processing filter."),
532  .priv_size = sizeof(SPPContext),
533  .init_dict = init_dict,
534  .uninit = uninit,
536  .inputs = spp_inputs,
537  .outputs = spp_outputs,
539  .priv_class = &spp_class,
541 };
#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:308
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:321
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
const char * desc
Definition: nvenc.c:87
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_spp.c:370
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:459
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:94
static void softthresh_c(int16_t dst[64], const int16_t src[64], int qp, const uint8_t *permutation)
Definition: vf_spp.c:150
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
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:283
const char * name
Pad name.
Definition: internal.h:60
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_spp.c:501
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
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:202
AVOptions.
#define OFFSET(x)
Definition: vf_spp.c:67
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:112
#define height
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
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:233
static const AVClass * child_class_iterate(void **iter)
Definition: vf_spp.c:54
int non_b_qp_alloc_size
Definition: vf_spp.h:42
#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:254
int width
Definition: frame.h:366
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:600
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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:153
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
void * priv
private data for use by the filter
Definition: avfilter.h:353
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:69
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
static const uint8_t offset[127][2]
Definition: vf_spp.c:105
GLsizei count
Definition: opengl_enc.c:108
int avcodec_dct_init(AVDCT *dsp)
Definition: avdct.c:88
#define FFMAX(a, b)
Definition: common.h:94
static const AVClass spp_class
Definition: vf_spp.c:80
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
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:391
#define FFMIN(a, b)
Definition: common.h:96
static void hardthresh_c(int16_t dst[64], const int16_t src[64], int qp, const uint8_t *permutation)
Definition: vf_spp.c:129
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
uint8_t w
Definition: llviddspenc.c:38
static int config_input(AVFilterLink *inlink)
Definition: vf_spp.c:346
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:474
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:595
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
static const AVFilterPad spp_outputs[]
Definition: vf_spp.c:521
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:144
int index
Definition: gxfenc.c:89
void(* fdct)(int16_t *block)
Definition: avdct.h:50
#define FLAGS
Definition: vf_spp.c:68
const char * name
Filter name.
Definition: avfilter.h:148
#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:133
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static const AVFilterPad spp_inputs[]
Definition: vf_spp.c:511
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:381
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
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:560
#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:322
uint8_t level
Definition: svq3.c:209
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:61
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:1533
AVFilter ff_vf_spp
Definition: vf_spp.c:529
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:172
char * value
Definition: dict.h:87
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
int height
Definition: frame.h:366
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:338
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
int8_t * av_frame_get_qp_table(AVFrame *f, int *stride, int *type)
Definition: frame.c:91
static const AVOption spp_options[]
Definition: vf_spp.c:70
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:249
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:659
int i
Definition: input.c:406
uint8_t * src
Definition: vf_spp.h:38
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58