FFmpeg
vf_xbr.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * Copyright (c) 2011, 2012 Hyllian/Jararaca <sergiogdb@gmail.com>
5  * Copyright (c) 2014 Arwa Arif <arwaarif1994@gmail.com>
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  * XBR Filter is used for depixelization of image.
25  * This is based on Hyllian's xBR shader.
26  *
27  * @see https://forums.libretro.com/t/xbr-algorithm-tutorial/123
28  * @see https://github.com/yoyofr/iFBA/blob/master/fba_src/src/intf/video/scalers/xbr.cpp
29  */
30 
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 
34 #include "filters.h"
35 #include "video.h"
36 
37 #define LB_MASK 0x00FEFEFE
38 #define RED_BLUE_MASK 0x00FF00FF
39 #define GREEN_MASK 0x0000FF00
40 
41 #ifdef PI
42 #undef PI
43 #endif
44 
45 typedef int (*xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
46 
47 typedef struct XBRContext {
48  const AVClass *class;
49  int n;
50  xbrfunc_t func;
51  uint32_t rgbtoyuv[1<<24];
52 } XBRContext;
53 
54 typedef struct ThreadData {
55  AVFrame *in, *out;
56  const uint32_t *rgbtoyuv;
57 } ThreadData;
58 
59 #define OFFSET(x) offsetof(XBRContext, x)
60 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
61 static const AVOption xbr_options[] = {
62  { "n", "set scale factor", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 3}, 2, 4, .flags = FLAGS },
63  { NULL }
64 };
65 
66 AVFILTER_DEFINE_CLASS(xbr);
67 
68 static uint32_t pixel_diff(uint32_t x, uint32_t y, const uint32_t *r2y)
69 {
70 #define YMASK 0xff0000
71 #define UMASK 0x00ff00
72 #define VMASK 0x0000ff
73 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
74 
75  uint32_t yuv1 = r2y[x & 0xffffff];
76  uint32_t yuv2 = r2y[y & 0xffffff];
77 
78  return (ABSDIFF(yuv1 & YMASK, yuv2 & YMASK) >> 16) +
79  (ABSDIFF(yuv1 & UMASK, yuv2 & UMASK) >> 8) +
80  ABSDIFF(yuv1 & VMASK, yuv2 & VMASK);
81 }
82 
83 #define ALPHA_BLEND_128_W(a, b) ((((a) & LB_MASK) >> 1) + (((b) & LB_MASK) >> 1))
84 #define ALPHA_BLEND_BASE(a, b, m, s) ( (RED_BLUE_MASK & (((a) & RED_BLUE_MASK) + (((((b) & RED_BLUE_MASK) - ((a) & RED_BLUE_MASK)) * (m)) >> (s)))) \
85  | (GREEN_MASK & (((a) & GREEN_MASK) + (((((b) & GREEN_MASK) - ((a) & GREEN_MASK)) * (m)) >> (s)))))
86 #define ALPHA_BLEND_32_W(a, b) ALPHA_BLEND_BASE(a, b, 1, 3)
87 #define ALPHA_BLEND_64_W(a, b) ALPHA_BLEND_BASE(a, b, 1, 2)
88 #define ALPHA_BLEND_192_W(a, b) ALPHA_BLEND_BASE(a, b, 3, 2)
89 #define ALPHA_BLEND_224_W(a, b) ALPHA_BLEND_BASE(a, b, 7, 3)
90 
91 #define df(A, B) pixel_diff(A, B, r2y)
92 #define eq(A, B) (df(A, B) < 155)
93 
94 #define FILT2(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, \
95  N0, N1, N2, N3) do { \
96  if (PE != PH && PE != PF) { \
97  const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2); \
98  const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2); \
99  if (e <= i) { \
100  const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH; \
101  if (e < i && (!eq(PF,PB) && !eq(PH,PD) || eq(PE,PI) \
102  && (!eq(PF,I4) && !eq(PH,I5)) \
103  || eq(PE,PG) || eq(PE,PC))) { \
104  const unsigned ke = df(PF,PG); \
105  const unsigned ki = df(PH,PC); \
106  const int left = ke<<1 <= ki && PE != PG && PD != PG; \
107  const int up = ke >= ki<<1 && PE != PC && PB != PC; \
108  if (left && up) { \
109  E[N3] = ALPHA_BLEND_224_W(E[N3], px); \
110  E[N2] = ALPHA_BLEND_64_W( E[N2], px); \
111  E[N1] = E[N2]; \
112  } else if (left) { \
113  E[N3] = ALPHA_BLEND_192_W(E[N3], px); \
114  E[N2] = ALPHA_BLEND_64_W( E[N2], px); \
115  } else if (up) { \
116  E[N3] = ALPHA_BLEND_192_W(E[N3], px); \
117  E[N1] = ALPHA_BLEND_64_W( E[N1], px); \
118  } else { /* diagonal */ \
119  E[N3] = ALPHA_BLEND_128_W(E[N3], px); \
120  } \
121  } else { \
122  E[N3] = ALPHA_BLEND_128_W(E[N3], px); \
123  } \
124  } \
125  } \
126 } while (0)
127 
128 #define FILT3(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, \
129  N0, N1, N2, N3, N4, N5, N6, N7, N8) do { \
130  if (PE != PH && PE != PF) { \
131  const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2); \
132  const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2); \
133  if (e <= i) { \
134  const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH; \
135  if (e < i && (!eq(PF,PB) && !eq(PF,PC) || !eq(PH,PD) && !eq(PH,PG) || eq(PE,PI) \
136  && (!eq(PF,F4) && !eq(PF,I4) || !eq(PH,H5) && !eq(PH,I5)) \
137  || eq(PE,PG) || eq(PE,PC))) { \
138  const unsigned ke = df(PF,PG); \
139  const unsigned ki = df(PH,PC); \
140  const int left = ke<<1 <= ki && PE != PG && PD != PG; \
141  const int up = ke >= ki<<1 && PE != PC && PB != PC; \
142  if (left && up) { \
143  E[N7] = ALPHA_BLEND_192_W(E[N7], px); \
144  E[N6] = ALPHA_BLEND_64_W( E[N6], px); \
145  E[N5] = E[N7]; \
146  E[N2] = E[N6]; \
147  E[N8] = px; \
148  } else if (left) { \
149  E[N7] = ALPHA_BLEND_192_W(E[N7], px); \
150  E[N5] = ALPHA_BLEND_64_W( E[N5], px); \
151  E[N6] = ALPHA_BLEND_64_W( E[N6], px); \
152  E[N8] = px; \
153  } else if (up) { \
154  E[N5] = ALPHA_BLEND_192_W(E[N5], px); \
155  E[N7] = ALPHA_BLEND_64_W( E[N7], px); \
156  E[N2] = ALPHA_BLEND_64_W( E[N2], px); \
157  E[N8] = px; \
158  } else { /* diagonal */ \
159  E[N8] = ALPHA_BLEND_224_W(E[N8], px); \
160  E[N5] = ALPHA_BLEND_32_W( E[N5], px); \
161  E[N7] = ALPHA_BLEND_32_W( E[N7], px); \
162  } \
163  } else { \
164  E[N8] = ALPHA_BLEND_128_W(E[N8], px); \
165  } \
166  } \
167  } \
168 } while (0)
169 
170 #define FILT4(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, \
171  N15, N14, N11, N3, N7, N10, N13, N12, N9, N6, N2, N1, N5, N8, N4, N0) do { \
172  if (PE != PH && PE != PF) { \
173  const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2); \
174  const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2); \
175  if (e <= i) { \
176  const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH; \
177  if (e < i && (!eq(PF,PB) && !eq(PH,PD) || eq(PE,PI) \
178  && (!eq(PF,I4) && !eq(PH,I5)) \
179  || eq(PE,PG) || eq(PE,PC))) { \
180  const unsigned ke = df(PF,PG); \
181  const unsigned ki = df(PH,PC); \
182  const int left = ke<<1 <= ki && PE != PG && PD != PG; \
183  const int up = ke >= ki<<1 && PE != PC && PB != PC; \
184  if (left && up) { \
185  E[N13] = ALPHA_BLEND_192_W(E[N13], px); \
186  E[N12] = ALPHA_BLEND_64_W( E[N12], px); \
187  E[N15] = E[N14] = E[N11] = px; \
188  E[N10] = E[N3] = E[N12]; \
189  E[N7] = E[N13]; \
190  } else if (left) { \
191  E[N11] = ALPHA_BLEND_192_W(E[N11], px); \
192  E[N13] = ALPHA_BLEND_192_W(E[N13], px); \
193  E[N10] = ALPHA_BLEND_64_W( E[N10], px); \
194  E[N12] = ALPHA_BLEND_64_W( E[N12], px); \
195  E[N14] = px; \
196  E[N15] = px; \
197  } else if (up) { \
198  E[N14] = ALPHA_BLEND_192_W(E[N14], px); \
199  E[N7 ] = ALPHA_BLEND_192_W(E[N7 ], px); \
200  E[N10] = ALPHA_BLEND_64_W( E[N10], px); \
201  E[N3 ] = ALPHA_BLEND_64_W( E[N3 ], px); \
202  E[N11] = px; \
203  E[N15] = px; \
204  } else { /* diagonal */ \
205  E[N11] = ALPHA_BLEND_128_W(E[N11], px); \
206  E[N14] = ALPHA_BLEND_128_W(E[N14], px); \
207  E[N15] = px; \
208  } \
209  } else { \
210  E[N15] = ALPHA_BLEND_128_W(E[N15], px); \
211  } \
212  } \
213  } \
214 } while (0)
215 
216 static av_always_inline void xbr_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)
217 {
218  int x, y;
219  const AVFrame *input = td->in;
220  AVFrame *output = td->out;
221  const uint32_t *r2y = td->rgbtoyuv;
222  const int slice_start = (input->height * jobnr ) / nb_jobs;
223  const int slice_end = (input->height * (jobnr+1)) / nb_jobs;
224  const int nl = output->linesize[0] >> 2;
225  const int nl1 = nl + nl;
226  const int nl2 = nl1 + nl;
227 
228  for (y = slice_start; y < slice_end; y++) {
229 
230  uint32_t *E = (uint32_t *)(output->data[0] + y * output->linesize[0] * n);
231  const uint32_t *sa2 = (uint32_t *)(input->data[0] + y * input->linesize[0] - 8); /* center */
232  const uint32_t *sa1 = sa2 - (input->linesize[0]>>2); /* up x1 */
233  const uint32_t *sa0 = sa1 - (input->linesize[0]>>2); /* up x2 */
234  const uint32_t *sa3 = sa2 + (input->linesize[0]>>2); /* down x1 */
235  const uint32_t *sa4 = sa3 + (input->linesize[0]>>2); /* down x2 */
236 
237  if (y <= 1) {
238  sa0 = sa1;
239  if (y == 0) {
240  sa0 = sa1 = sa2;
241  }
242  }
243 
244  if (y >= input->height - 2) {
245  sa4 = sa3;
246  if (y == input->height - 1) {
247  sa4 = sa3 = sa2;
248  }
249  }
250 
251  for (x = 0; x < input->width; x++) {
252  const uint32_t B1 = sa0[2];
253  const uint32_t PB = sa1[2];
254  const uint32_t PE = sa2[2];
255  const uint32_t PH = sa3[2];
256  const uint32_t H5 = sa4[2];
257 
258  const int pprev = 2 - (x > 0);
259  const uint32_t A1 = sa0[pprev];
260  const uint32_t PA = sa1[pprev];
261  const uint32_t PD = sa2[pprev];
262  const uint32_t PG = sa3[pprev];
263  const uint32_t G5 = sa4[pprev];
264 
265  const int pprev2 = pprev - (x > 1);
266  const uint32_t A0 = sa1[pprev2];
267  const uint32_t D0 = sa2[pprev2];
268  const uint32_t G0 = sa3[pprev2];
269 
270  const int pnext = 3 - (x == input->width - 1);
271  const uint32_t C1 = sa0[pnext];
272  const uint32_t PC = sa1[pnext];
273  const uint32_t PF = sa2[pnext];
274  const uint32_t PI = sa3[pnext];
275  const uint32_t I5 = sa4[pnext];
276 
277  const int pnext2 = pnext + 1 - (x >= input->width - 2);
278  const uint32_t C4 = sa1[pnext2];
279  const uint32_t F4 = sa2[pnext2];
280  const uint32_t I4 = sa3[pnext2];
281 
282  if (n == 2) {
283  E[0] = E[1] = // 0, 1
284  E[nl] = E[nl + 1] = PE; // 2, 3
285 
286  FILT2(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, 0, 1, nl, nl+1);
287  FILT2(PE, PC, PF, PB, PI, PA, PH, PD, PG, I4, A1, I5, H5, A0, D0, B1, C1, F4, C4, G5, G0, nl, 0, nl+1, 1);
288  FILT2(PE, PA, PB, PD, PC, PG, PF, PH, PI, C1, G0, C4, F4, G5, H5, D0, A0, B1, A1, I4, I5, nl+1, nl, 1, 0);
289  FILT2(PE, PG, PD, PH, PA, PI, PB, PF, PC, A0, I5, A1, B1, I4, F4, H5, G5, D0, G0, C1, C4, 1, nl+1, 0, nl);
290  } else if (n == 3) {
291  E[0] = E[1] = E[2] = // 0, 1, 2
292  E[nl] = E[nl+1] = E[nl+2] = // 3, 4, 5
293  E[nl1] = E[nl1+1] = E[nl1+2] = PE; // 6, 7, 8
294 
295  FILT3(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, 0, 1, 2, nl, nl+1, nl+2, nl1, nl1+1, nl1+2);
296  FILT3(PE, PC, PF, PB, PI, PA, PH, PD, PG, I4, A1, I5, H5, A0, D0, B1, C1, F4, C4, G5, G0, nl1, nl, 0, nl1+1, nl+1, 1, nl1+2, nl+2, 2);
297  FILT3(PE, PA, PB, PD, PC, PG, PF, PH, PI, C1, G0, C4, F4, G5, H5, D0, A0, B1, A1, I4, I5, nl1+2, nl1+1, nl1, nl+2, nl+1, nl, 2, 1, 0);
298  FILT3(PE, PG, PD, PH, PA, PI, PB, PF, PC, A0, I5, A1, B1, I4, F4, H5, G5, D0, G0, C1, C4, 2, nl+2, nl1+2, 1, nl+1, nl1+1, 0, nl, nl1);
299  } else if (n == 4) {
300  E[0] = E[1] = E[2] = E[3] = // 0, 1, 2, 3
301  E[nl] = E[nl+1] = E[nl+2] = E[nl+3] = // 4, 5, 6, 7
302  E[nl1] = E[nl1+1] = E[nl1+2] = E[nl1+3] = // 8, 9, 10, 11
303  E[nl2] = E[nl2+1] = E[nl2+2] = E[nl2+3] = PE; // 12, 13, 14, 15
304 
305  FILT4(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, nl2+3, nl2+2, nl1+3, 3, nl+3, nl1+2, nl2+1, nl2, nl1+1, nl+2, 2, 1, nl+1, nl1, nl, 0);
306  FILT4(PE, PC, PF, PB, PI, PA, PH, PD, PG, I4, A1, I5, H5, A0, D0, B1, C1, F4, C4, G5, G0, 3, nl+3, 2, 0, 1, nl+2, nl1+3, nl2+3, nl1+2, nl+1, nl, nl1, nl1+1, nl2+2, nl2+1, nl2);
307  FILT4(PE, PA, PB, PD, PC, PG, PF, PH, PI, C1, G0, C4, F4, G5, H5, D0, A0, B1, A1, I4, I5, 0, 1, nl, nl2, nl1, nl+1, 2, 3, nl+2, nl1+1, nl2+1, nl2+2, nl1+2, nl+3, nl1+3, nl2+3);
308  FILT4(PE, PG, PD, PH, PA, PI, PB, PF, PC, A0, I5, A1, B1, I4, F4, H5, G5, D0, G0, C1, C4, nl2, nl1, nl2+1, nl2+3, nl2+2, nl1+1, nl, 0, nl+1, nl1+2, nl1+3, nl+3, nl+2, 1, 2, 3);
309  }
310 
311  sa0 += 1;
312  sa1 += 1;
313  sa2 += 1;
314  sa3 += 1;
315  sa4 += 1;
316 
317  E += n;
318  }
319  }
320 }
321 
322 #define XBR_FUNC(size) \
323 static int xbr##size##x(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
324 { \
325  xbr_filter(arg, jobnr, nb_jobs, size); \
326  return 0; \
327 }
328 
329 XBR_FUNC(2)
330 XBR_FUNC(3)
331 XBR_FUNC(4)
332 
333 
334 static int config_output(AVFilterLink *outlink)
335 {
336  AVFilterContext *ctx = outlink->src;
337  XBRContext *s = ctx->priv;
338  AVFilterLink *inlink = ctx->inputs[0];
339 
340  outlink->w = inlink->w * s->n;
341  outlink->h = inlink->h * s->n;
342  return 0;
343 }
344 
345 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
346 {
347  AVFilterContext *ctx = inlink->dst;
348  AVFilterLink *outlink = ctx->outputs[0];
349  XBRContext *s = ctx->priv;
350  ThreadData td;
351 
352  AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
353  if (!out) {
354  av_frame_free(&in);
355  return AVERROR(ENOMEM);
356  }
357 
358  av_frame_copy_props(out, in);
359 
360  td.in = in;
361  td.out = out;
362  td.rgbtoyuv = s->rgbtoyuv;
363  ff_filter_execute(ctx, s->func, &td, NULL,
364  FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));
365 
366  out->width = outlink->w;
367  out->height = outlink->h;
368 
369  av_frame_free(&in);
370  return ff_filter_frame(outlink, out);
371 }
372 
373 static av_cold int init(AVFilterContext *ctx)
374 {
375  XBRContext *s = ctx->priv;
376  static const xbrfunc_t xbrfuncs[] = {xbr2x, xbr3x, xbr4x};
377 
378  uint32_t c;
379  int bg, rg, g;
380 
381  for (bg = -255; bg < 256; bg++) {
382  for (rg = -255; rg < 256; rg++) {
383  const uint32_t u = (uint32_t)((-169*rg + 500*bg)/1000) + 128;
384  const uint32_t v = (uint32_t)(( 500*rg - 81*bg)/1000) + 128;
385  int startg = FFMAX3(-bg, -rg, 0);
386  int endg = FFMIN3(255-bg, 255-rg, 255);
387  uint32_t y = (uint32_t)(( 299*rg + 1000*startg + 114*bg)/1000);
388  c = bg + rg * (1 << 16) + 0x010101 * startg;
389  for (g = startg; g <= endg; g++) {
390  s->rgbtoyuv[c] = ((y++) << 16) + (u << 8) + v;
391  c+= 0x010101;
392  }
393  }
394  }
395 
396  s->func = xbrfuncs[s->n - 2];
397  return 0;
398 }
399 
400 static const AVFilterPad xbr_inputs[] = {
401  {
402  .name = "default",
403  .type = AVMEDIA_TYPE_VIDEO,
404  .filter_frame = filter_frame,
405  },
406 };
407 
408 static const AVFilterPad xbr_outputs[] = {
409  {
410  .name = "default",
411  .type = AVMEDIA_TYPE_VIDEO,
412  .config_props = config_output,
413  },
414 };
415 
416 const AVFilter ff_vf_xbr = {
417  .name = "xbr",
418  .description = NULL_IF_CONFIG_SMALL("Scale the input using xBR algorithm."),
419  FILTER_INPUTS(xbr_inputs),
420  FILTER_OUTPUTS(xbr_outputs),
421  FILTER_SINGLE_PIXFMT(AV_PIX_FMT_0RGB32),
422  .priv_size = sizeof(XBRContext),
423  .priv_class = &xbr_class,
424  .init = init,
425  .flags = AVFILTER_FLAG_SLICE_THREADS,
426 };
ff_vf_xbr
const AVFilter ff_vf_xbr
Definition: vf_xbr.c:416
VMASK
#define VMASK
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
out
FILE * out
Definition: movenc.c:55
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
xbr_outputs
static const AVFilterPad xbr_outputs[]
Definition: vf_xbr.c:408
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
test::height
int height
Definition: vc1dsp.c:40
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
C4
#define C4
Definition: mpegaudiodec_template.c:319
AVOption
AVOption.
Definition: opt.h:429
xbr_inputs
static const AVFilterPad xbr_inputs[]
Definition: vf_xbr.c:400
PD
#define PD(a, b)
Pack two delta values (a,b) into one 16-bit word according with endianness of the host machine.
Definition: indeo3data.h:290
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:526
video.h
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:155
ABSDIFF
#define ABSDIFF(a, b)
B1
@ B1
Definition: mvs.c:527
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
Definition: mpeg12dec.c:1719
xbr_options
static const AVOption xbr_options[]
Definition: vf_xbr.c:61
C1
#define C1
Definition: mpegaudiodsp_template.c:238
XBRContext::n
int n
Definition: vf_xbr.c:49
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
xbrfunc_t
int(* xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_xbr.c:45
XBRContext::rgbtoyuv
uint32_t rgbtoyuv[1<< 24]
Definition: vf_xbr.c:51
XBRContext::func
xbrfunc_t func
Definition: vf_xbr.c:50
av_cold
#define av_cold
Definition: attributes.h:90
YMASK
#define YMASK
s
#define s(width, name)
Definition: cbs_vp9.c:198
g
const char * g
Definition: vf_curves.c:128
FLAGS
#define FLAGS
Definition: vf_xbr.c:60
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
E
#define E
Definition: avdct.c:33
arg
const char * arg
Definition: jacosubdec.c:67
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:713
PF
#define PF(suf)
xbr_filter
static av_always_inline void xbr_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)
Definition: vf_xbr.c:216
c
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
XBRContext
Definition: vf_xbr.c:47
test::width
int width
Definition: vc1dsp.c:39
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
A1
@ A1
Definition: mvs.c:524
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_xbr.c:334
A0
@ A0
Definition: mvs.c:523
ThreadData::rgbtoyuv
const uint32_t * rgbtoyuv
Definition: vf_hqx.c:47
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
UMASK
#define UMASK
FFMIN3
#define FFMIN3(a, b, c)
Definition: macros.h:50
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:841
ThreadData
Used for passing data between threads.
Definition: dsddec.c:71
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
XBR_FUNC
#define XBR_FUNC(size)
Definition: vf_xbr.c:322
slice_start
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
Definition: dec.c:738
AVFilter
Filter definition.
Definition: avfilter.h:201
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:479
FILT4
#define FILT4(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, N15, N14, N11, N3, N7, N10, N13, N12, N9, N6, N2, N1, N5, N8, N4, N0)
Definition: vf_xbr.c:170
ff_filter_execute
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:1667
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_xbr.c:345
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:152
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
pixel_diff
static uint32_t pixel_diff(uint32_t x, uint32_t y, const uint32_t *r2y)
Definition: vf_xbr.c:68
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_xbr.c:373
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
OFFSET
#define OFFSET(x)
Definition: vf_xbr.c:59
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(xbr)
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: filters.h:252
FILT2
#define FILT2(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, N0, N1, N2, N3)
Definition: vf_xbr.c:94
FILT3
#define FILT3(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, N0, N1, N2, N3, N4, N5, N6, N7, N8)
Definition: vf_xbr.c:128
Generated on Tue Nov 5 2024 19:22:30 for FFmpeg by   doxygen 1.8.17