b06e91f8986cdf09a0fa079ca10b538166e64d39
[ffmpeg.git] / libavfilter / vf_xbr.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * Copyright (C) 2011, 2012 Hyllian/Jararaca - sergiogdb@gmail.com
5  *
6  * Copyright (c) 2014 Arwa Arif <arwaarif1994@gmail.com>
7  *
8  * FFmpeg is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21  */
22
23 /**
24  * @file
25  * XBR Filter is used for depixelization of image.
26  * This is based on Hyllian's xBR shader.
27  *
28  * @see http://www.libretro.com/forums/viewtopic.php?f=6&t=134
29  * @see https://github.com/yoyofr/iFBA/blob/master/fba_src/src/intf/video/scalers/xbr.cpp
30  *
31  * @todo add threading and FATE test
32  */
33
34 #include "libavutil/opt.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/pixdesc.h"
37 #include "internal.h"
38
39 #define RGB_MASK      0x00FFFFFF
40 #define LB_MASK       0x00FEFEFE
41 #define RED_BLUE_MASK 0x00FF00FF
42 #define GREEN_MASK    0x0000FF00
43
44 typedef struct {
45     const AVClass *class;
46     int n;
47     uint32_t rgbtoyuv[1<<24];
48 } XBRContext;
49
50 #define OFFSET(x) offsetof(XBRContext, x)
51 static const AVOption xbr_options[] = {
52     { "n", "set scale factor", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 3}, 2, 4, },
53     { NULL }
54 };
55
56 AVFILTER_DEFINE_CLASS(xbr);
57
58 static uint32_t df(uint32_t x, uint32_t y, const uint32_t *r2y)
59 {
60 #define YMASK 0xff0000
61 #define UMASK 0x00ff00
62 #define VMASK 0x0000ff
63
64     uint32_t yuv1 = r2y[x & 0xffffff];
65     uint32_t yuv2 = r2y[y & 0xffffff];
66
67     return (abs((yuv1 & YMASK) - (yuv2 & YMASK)) >> 16) +
68            (abs((yuv1 & UMASK) - (yuv2 & UMASK)) >>  8) +
69            abs((yuv1 & VMASK) - (yuv2 & VMASK));
70 }
71
72 #define ALPHA_BLEND_128_W(dst, src) dst = ((src & LB_MASK) >> 1) + ((dst & LB_MASK) >> 1)
73
74 #define ALPHA_BLEND_32_W(dst, src) \
75     dst = ((RED_BLUE_MASK & ((dst & RED_BLUE_MASK) + ((((src & RED_BLUE_MASK) - \
76           (dst & RED_BLUE_MASK))) >>3))) | (GREEN_MASK & ((dst & GREEN_MASK) + \
77           ((((src & GREEN_MASK) - (dst & GREEN_MASK))) >>3))))
78
79 #define ALPHA_BLEND_64_W(dst, src) \
80     dst = ((RED_BLUE_MASK & ((dst & RED_BLUE_MASK) + ((((src & RED_BLUE_MASK) - \
81           (dst & RED_BLUE_MASK))) >>2))) | (GREEN_MASK & ((dst & GREEN_MASK) + \
82           ((((src & GREEN_MASK) - (dst & GREEN_MASK))) >>2))))
83
84 #define ALPHA_BLEND_192_W(dst, src) \
85     dst = ((RED_BLUE_MASK & ((dst & RED_BLUE_MASK) + ((((src & RED_BLUE_MASK) - \
86           (dst & RED_BLUE_MASK)) * 3) >>2))) | (GREEN_MASK & ((dst & GREEN_MASK) + \
87           ((((src & GREEN_MASK) - (dst & GREEN_MASK)) * 3) >>2))))
88
89 #define ALPHA_BLEND_224_W(dst, src) \
90     dst = ((RED_BLUE_MASK & ((dst & RED_BLUE_MASK) + ((((src & RED_BLUE_MASK) - \
91           (dst & RED_BLUE_MASK)) * 7) >>3))) | (GREEN_MASK & ((dst & GREEN_MASK) + \
92           ((((src & GREEN_MASK) - (dst & GREEN_MASK)) * 7) >>3))))
93
94 #define LEFT_UP_2_2X(N3, N2, N1, PIXEL)\
95     ALPHA_BLEND_224_W(E[N3], PIXEL); \
96     ALPHA_BLEND_64_W( E[N2], PIXEL); \
97     E[N1] = E[N2]; \
98
99 #define LEFT_2_2X(N3, N2, PIXEL)\
100     ALPHA_BLEND_192_W(E[N3], PIXEL); \
101     ALPHA_BLEND_64_W( E[N2], PIXEL); \
102
103 #define UP_2_2X(N3, N1, PIXEL)\
104     ALPHA_BLEND_192_W(E[N3], PIXEL); \
105     ALPHA_BLEND_64_W( E[N1], PIXEL); \
106
107 #define DIA_2X(N3, PIXEL)\
108     ALPHA_BLEND_128_W(E[N3], PIXEL); \
109
110 #define eq(A, B, r2y)\
111     (df(A, B, r2y) < 155)\
112
113 #define FILTRO(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,r2y) \
114      ex   = (PE!=PH && PE!=PF); \
115      if ( ex )\
116      {\
117           e = (df(PE,PC,r2y)+df(PE,PG,r2y)+df(PI,H5,r2y)+df(PI,F4,r2y))+(df(PH,PF,r2y)<<2); \
118           i = (df(PH,PD,r2y)+df(PH,I5,r2y)+df(PF,I4,r2y)+df(PF,PB,r2y))+(df(PE,PI,r2y)<<2); \
119           if ((e<i)  && ( !eq(PF,PB,r2y) && !eq(PH,PD,r2y) || eq(PE,PI,r2y) && (!eq(PF,I4,r2y) && !eq(PH,I5,r2y)) || eq(PE,PG,r2y) || eq(PE,PC,r2y)) )\
120           {\
121               ke=df(PF,PG,r2y); ki=df(PH,PC,r2y); \
122               ex2 = (PE!=PC && PB!=PC); ex3 = (PE!=PG && PD!=PG); px = (df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH; \
123               if ( ((ke<<1)<=ki) && ex3 && (ke>=(ki<<1)) && ex2 ) \
124               {\
125                      LEFT_UP_2_2X(N3, N2, N1, px)\
126               }\
127               else if ( ((ke<<1)<=ki) && ex3 ) \
128               {\
129                      LEFT_2_2X(N3, N2, px);\
130               }\
131               else if ( (ke>=(ki<<1)) && ex2 ) \
132               {\
133                      UP_2_2X(N3, N1, px);\
134               }\
135               else \
136               {\
137                      DIA_2X(N3, px);\
138               }\
139           }\
140           else if (e<=i)\
141           {\
142                ALPHA_BLEND_128_W( E[N3], ((df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH)); \
143           }\
144      }\
145
146 static void xbr2x(AVFrame * input, AVFrame * output, const uint32_t * r2y)
147 {
148     unsigned int e, i,px;
149     unsigned int ex, ex2, ex3;
150     unsigned int ke, ki;
151     int x,y;
152
153     int next_line = output->linesize[0]>>2;
154
155     for (y = 0; y < input->height; y++) {
156
157         uint32_t pprev;
158         uint32_t pprev2;
159
160         uint32_t * E = (uint32_t *)(output->data[0] + y * output->linesize[0] * 2);
161
162         /* middle. Offset of -8 is given */
163         uint32_t * sa2 = (uint32_t *)(input->data[0] + y * input->linesize[0] - 8);
164         /* up one */
165         uint32_t * sa1 = sa2 - (input->linesize[0]>>2);
166         /* up two */
167         uint32_t * sa0 = sa1 - (input->linesize[0]>>2);
168         /* down one */
169         uint32_t * sa3 = sa2 + (input->linesize[0]>>2);
170         /* down two */
171         uint32_t * sa4 = sa3 + (input->linesize[0]>>2);
172
173         if (y <= 1) {
174             sa0 = sa1;
175             if (y == 0) {
176                 sa0 = sa1 = sa2;
177             }
178         }
179
180         if (y >= input->height - 2) {
181             sa4 = sa3;
182             if (y == input->height - 1) {
183                 sa4 = sa3 = sa2;
184             }
185         }
186
187         pprev = pprev2 = 2;
188
189         for (x = 0; x < input->width; x++) {
190             uint32_t B1 = sa0[2];
191             uint32_t PB = sa1[2];
192             uint32_t PE = sa2[2];
193             uint32_t PH = sa3[2];
194             uint32_t H5 = sa4[2];
195
196             uint32_t A1 = sa0[pprev];
197             uint32_t PA = sa1[pprev];
198             uint32_t PD = sa2[pprev];
199             uint32_t PG = sa3[pprev];
200             uint32_t G5 = sa4[pprev];
201
202             uint32_t A0 = sa1[pprev2];
203             uint32_t D0 = sa2[pprev2];
204             uint32_t G0 = sa3[pprev2];
205
206             uint32_t C1 = 0;
207             uint32_t PC = 0;
208             uint32_t PF = 0;
209             uint32_t PI = 0;
210             uint32_t I5 = 0;
211
212             uint32_t C4 = 0;
213             uint32_t F4 = 0;
214             uint32_t I4 = 0;
215
216             if (x >= input->width - 2) {
217                 if (x == input->width - 1) {
218                     C1 = sa0[2];
219                     PC = sa1[2];
220                     PF = sa2[2];
221                     PI = sa3[2];
222                     I5 = sa4[2];
223
224                     C4 = sa1[2];
225                     F4 = sa2[2];
226                     I4 = sa3[2];
227                 } else {
228                     C1 = sa0[3];
229                     PC = sa1[3];
230                     PF = sa2[3];
231                     PI = sa3[3];
232                     I5 = sa4[3];
233
234                     C4 = sa1[3];
235                     F4 = sa2[3];
236                     I4 = sa3[3];
237                 }
238             } else {
239                 C1 = sa0[3];
240                 PC = sa1[3];
241                 PF = sa2[3];
242                 PI = sa3[3];
243                 I5 = sa4[3];
244
245                 C4 = sa1[4];
246                 F4 = sa2[4];
247                 I4 = sa3[4];
248             }
249
250             E[0] = E[1] = E[next_line] = E[next_line + 1] = PE; // 0, 1, 2, 3
251
252             FILTRO(PE, PI, PH, PF, PG, PC, PD, PB, PA, G5, C4, G0, D0, C1, B1, F4, I4, H5, I5, A0, A1, 0, 1, next_line, next_line+1,r2y);
253             FILTRO(PE, PC, PF, PB, PI, PA, PH, PD, PG, I4, A1, I5, H5, A0, D0, B1, C1, F4, C4, G5, G0, next_line, 0, next_line+1, 1,r2y);
254             FILTRO(PE, PA, PB, PD, PC, PG, PF, PH, PI, C1, G0, C4, F4, G5, H5, D0, A0, B1, A1, I4, I5, next_line+1, next_line, 1, 0,r2y);
255             FILTRO(PE, PG, PD, PH, PA, PI, PB, PF, PC, A0, I5, A1, B1, I4, F4, H5, G5, D0, G0, C1, C4, 1, next_line+1, 0, next_line,r2y);
256
257             sa0 += 1;
258             sa1 += 1;
259             sa2 += 1;
260             sa3 += 1;
261             sa4 += 1;
262
263             E += 2;
264
265             if (pprev2){
266                 pprev2--;
267                 pprev = 1;
268             }
269         }
270     }
271 }
272 #undef FILTRO
273
274 #define LEFT_UP_2_3X(N7, N5, N6, N2, N8, PIXEL)\
275     ALPHA_BLEND_192_W(E[N7], PIXEL); \
276     ALPHA_BLEND_64_W( E[N6], PIXEL); \
277     E[N5] = E[N7]; \
278     E[N2] = E[N6]; \
279     E[N8] =  PIXEL;\
280
281 #define LEFT_2_3X(N7, N5, N6, N8, PIXEL)\
282     ALPHA_BLEND_192_W(E[N7], PIXEL); \
283     ALPHA_BLEND_64_W( E[N5], PIXEL); \
284     ALPHA_BLEND_64_W( E[N6], PIXEL); \
285     E[N8] =  PIXEL;\
286
287 #define UP_2_3X(N5, N7, N2, N8, PIXEL)\
288     ALPHA_BLEND_192_W(E[N5], PIXEL); \
289     ALPHA_BLEND_64_W( E[N7], PIXEL); \
290     ALPHA_BLEND_64_W( E[N2], PIXEL); \
291     E[N8] =  PIXEL;\
292
293 #define DIA_3X(N8, N5, N7, PIXEL)\
294     ALPHA_BLEND_224_W(E[N8], PIXEL); \
295     ALPHA_BLEND_32_W(E[N5], PIXEL); \
296     ALPHA_BLEND_32_W(E[N7], PIXEL); \
297
298 #define FILTRO(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,r2y) \
299      ex   = (PE!=PH && PE!=PF); \
300      if ( ex )\
301      {\
302           e = (df(PE,PC,r2y)+df(PE,PG,r2y)+df(PI,H5,r2y)+df(PI,F4,r2y))+(df(PH,PF,r2y)<<2); \
303           i = (df(PH,PD,r2y)+df(PH,I5,r2y)+df(PF,I4,r2y)+df(PF,PB,r2y))+(df(PE,PI,r2y)<<2); \
304           if ((e<i)  && ( !eq(PF,PB,r2y) && !eq(PF,PC,r2y) || !eq(PH,PD,r2y) && !eq(PH,PG,r2y) || eq(PE,PI,r2y) && (!eq(PF,F4,r2y) && !eq(PF,I4,r2y) || !eq(PH,H5,r2y) && !eq(PH,I5,r2y)) || eq(PE,PG,r2y) || eq(PE,PC,r2y)) )\
305           {\
306               ke=df(PF,PG,r2y); ki=df(PH,PC,r2y); \
307               ex2 = (PE!=PC && PB!=PC); ex3 = (PE!=PG && PD!=PG); px = (df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH; \
308               if ( ((ke<<1)<=ki) && ex3 && (ke>=(ki<<1)) && ex2 ) \
309               {\
310                      LEFT_UP_2_3X(N7, N5, N6, N2, N8, px)\
311               }\
312               else if ( ((ke<<1)<=ki) && ex3 ) \
313               {\
314                      LEFT_2_3X(N7, N5, N6, N8, px);\
315               }\
316               else if ( (ke>=(ki<<1)) && ex2 ) \
317               {\
318                      UP_2_3X(N5, N7, N2, N8, px);\
319               }\
320               else \
321               {\
322                      DIA_3X(N8, N5, N7, px);\
323               }\
324           }\
325           else if (e<=i)\
326           {\
327                ALPHA_BLEND_128_W( E[N8], ((df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH)); \
328           }\
329      }\
330
331 static void xbr3x(AVFrame * input, AVFrame * output, const uint32_t * r2y)
332 {
333     const int nl = output->linesize[0]>>2;
334     const int nl1 = nl + nl;
335
336     unsigned int e, i,px;
337     unsigned int ex, ex2, ex3;
338     unsigned int ke, ki;
339
340     uint32_t pprev;
341     uint32_t pprev2;
342
343     int x,y;
344
345     for (y = 0; y < input->height; y++) {
346
347         uint32_t * E = (uint32_t *)(output->data[0] + y * output->linesize[0] * 3);
348
349         /* middle. Offset of -8 is given */
350         uint32_t * sa2 = (uint32_t *)(input->data[0] + y * input->linesize[0] - 8);
351         /* up one */
352         uint32_t * sa1 = sa2 - (input->linesize[0]>>2);
353         /* up two */
354         uint32_t * sa0 = sa1 - (input->linesize[0]>>2);
355         /* down one */
356         uint32_t * sa3 = sa2 + (input->linesize[0]>>2);
357         /* down two */
358         uint32_t * sa4 = sa3 + (input->linesize[0]>>2);
359
360         if (y <= 1){
361             sa0 = sa1;
362             if (y == 0){
363                 sa0 = sa1 = sa2;
364             }
365         }
366
367         if (y >= input->height - 2){
368             sa4 = sa3;
369             if (y == input->height - 1){
370                 sa4 = sa3 = sa2;
371             }
372         }
373
374         pprev = pprev2 = 2;
375
376         for (x = 0; x < input->width; x++){
377             uint32_t B1 = sa0[2];
378             uint32_t PB = sa1[2];
379             uint32_t PE = sa2[2];
380             uint32_t PH = sa3[2];
381             uint32_t H5 = sa4[2];
382
383             uint32_t A1 = sa0[pprev];
384             uint32_t PA = sa1[pprev];
385             uint32_t PD = sa2[pprev];
386             uint32_t PG = sa3[pprev];
387             uint32_t G5 = sa4[pprev];
388
389             uint32_t A0 = sa1[pprev2];
390             uint32_t D0 = sa2[pprev2];
391             uint32_t G0 = sa3[pprev2];
392
393             uint32_t C1 = 0;
394             uint32_t PC = 0;
395             uint32_t PF = 0;
396             uint32_t PI = 0;
397             uint32_t I5 = 0;
398
399             uint32_t C4 = 0;
400             uint32_t F4 = 0;
401             uint32_t I4 = 0;
402
403             if (x >= input->width - 2){
404                 if (x == input->width - 1){
405                     C1 = sa0[2];
406                     PC = sa1[2];
407                     PF = sa2[2];
408                     PI = sa3[2];
409                     I5 = sa4[2];
410
411                     C4 = sa1[2];
412                     F4 = sa2[2];
413                     I4 = sa3[2];
414                 } else {
415                     C1 = sa0[3];
416                     PC = sa1[3];
417                     PF = sa2[3];
418                     PI = sa3[3];
419                     I5 = sa4[3];
420
421                     C4 = sa1[3];
422                     F4 = sa2[3];
423                     I4 = sa3[3];
424                 }
425             } else {
426                 C1 = sa0[3];
427                 PC = sa1[3];
428                 PF = sa2[3];
429                 PI = sa3[3];
430                 I5 = sa4[3];
431
432                 C4 = sa1[4];
433                 F4 = sa2[4];
434                 I4 = sa3[4];
435             }
436
437             E[0]   = E[1]     = E[2]     = PE;
438             E[nl]  = E[nl+1]  = E[nl+2]  = PE; // 3, 4, 5
439             E[nl1] = E[nl1+1] = E[nl1+2] = PE; // 6, 7, 8
440
441             FILTRO(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,r2y);
442             FILTRO(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,r2y);
443             FILTRO(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,r2y);
444             FILTRO(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,r2y);
445
446             sa0 += 1;
447             sa1 += 1;
448             sa2 += 1;
449             sa3 += 1;
450             sa4 += 1;
451
452             E += 3;
453
454             if (pprev2){
455                 pprev2--;
456                 pprev = 1;
457             }
458         }
459     }
460 }
461 #undef FILTRO
462
463 #define LEFT_UP_2(N15, N14, N11, N13, N12, N10, N7, N3, PIXEL)\
464     ALPHA_BLEND_192_W(E[N13], PIXEL); \
465     ALPHA_BLEND_64_W( E[N12], PIXEL); \
466     E[N15] = E[N14] = E[N11] = PIXEL; \
467     E[N10] = E[N3] = E[N12]; \
468     E[N7]  = E[N13]; \
469
470 #define LEFT_2(N15, N14, N11, N13, N12, N10, PIXEL)\
471     ALPHA_BLEND_192_W(E[N11], PIXEL); \
472     ALPHA_BLEND_192_W(E[N13], PIXEL); \
473     ALPHA_BLEND_64_W( E[N10], PIXEL); \
474     ALPHA_BLEND_64_W( E[N12], PIXEL); \
475     E[N14] = PIXEL; \
476     E[N15] = PIXEL; \
477
478 #define UP_2(N15, N14, N11, N3, N7, N10, PIXEL)\
479     ALPHA_BLEND_192_W(E[N14], PIXEL); \
480     ALPHA_BLEND_192_W(E[N7 ], PIXEL); \
481     ALPHA_BLEND_64_W( E[N10], PIXEL); \
482     ALPHA_BLEND_64_W( E[N3 ], PIXEL); \
483     E[N11] = PIXEL; \
484     E[N15] = PIXEL; \
485
486 #define DIA(N15, N14, N11, PIXEL)\
487     ALPHA_BLEND_128_W(E[N11], PIXEL); \
488     ALPHA_BLEND_128_W(E[N14], PIXEL); \
489     E[N15] = PIXEL; \
490
491 #define FILTRO(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,r2y) \
492      ex   = (PE!=PH && PE!=PF); \
493      if ( ex )\
494      {\
495           e = (df(PE,PC,r2y)+df(PE,PG,r2y)+df(PI,H5,r2y)+df(PI,F4,r2y))+(df(PH,PF,r2y)<<2); \
496           i = (df(PH,PD,r2y)+df(PH,I5,r2y)+df(PF,I4,r2y)+df(PF,PB,r2y))+(df(PE,PI,r2y)<<2); \
497           if ((e<i)  && ( !eq(PF,PB,r2y) && !eq(PH,PD,r2y) || eq(PE,PI,r2y) && (!eq(PF,I4,r2y) && !eq(PH,I5,r2y)) || eq(PE,PG,r2y) || eq(PE,PC,r2y)) )\
498           {\
499               ke=df(PF,PG,r2y); ki=df(PH,PC,r2y); \
500               ex2 = (PE!=PC && PB!=PC); ex3 = (PE!=PG && PD!=PG); px = (df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH; \
501               if ( ((ke<<1)<=ki) && ex3 && (ke>=(ki<<1)) && ex2 ) \
502               {\
503                      LEFT_UP_2(N15, N14, N11, N13, N12, N10, N7, N3, px)\
504               }\
505               else if ( ((ke<<1)<=ki) && ex3 ) \
506               {\
507                      LEFT_2(N15, N14, N11, N13, N12, N10, px)\
508               }\
509               else if ( (ke>=(ki<<1)) && ex2 ) \
510               {\
511                      UP_2(N15, N14, N11, N3, N7, N10, px)\
512               }\
513               else \
514               {\
515                      DIA(N15, N14, N11, px)\
516               }\
517           }\
518           else if (e<=i)\
519           {\
520                ALPHA_BLEND_128_W( E[N15], ((df(PE,PF,r2y) <= df(PE,PH,r2y)) ? PF : PH)); \
521           }\
522      }\
523
524 static void xbr4x(AVFrame * input, AVFrame * output, const uint32_t * r2y)
525 {
526
527     const int nl = output->linesize[0]>>2;
528     const int nl1 = nl + nl;
529     const int nl2 = nl1 + nl;
530
531     unsigned int e, i, px;
532     unsigned int ex, ex2, ex3;
533     unsigned int ke, ki;
534
535     uint32_t pprev;
536     uint32_t pprev2;
537
538     int x,y;
539
540     for (y = 0; y < input->height; y++){
541
542         uint32_t * E = (uint32_t *)(output->data[0] + y * output->linesize[0] * 4);
543
544         /* middle. Offset of -8 is given */
545         uint32_t * sa2 = (uint32_t *)(input->data[0] + y * input->linesize[0] - 8);
546         /* up one */
547         uint32_t * sa1 = sa2 - (input->linesize[0]>>2);
548         /* up two */
549         uint32_t * sa0 = sa1 - (input->linesize[0]>>2);
550         /* down one */
551         uint32_t * sa3 = sa2 + (input->linesize[0]>>2);
552         /* down two */
553         uint32_t * sa4 = sa3 + (input->linesize[0]>>2);
554
555         if (y <= 1){
556             sa0 = sa1;
557             if (y == 0){
558                 sa0 = sa1 = sa2;
559             }
560         }
561
562         if (y >= input->height - 2){
563             sa4 = sa3;
564             if (y == input->height - 1){
565                 sa4 = sa3 = sa2;
566             }
567         }
568
569         pprev = pprev2 = 2;
570
571         for (x = 0; x < input->width; x++){
572             uint32_t B1 = sa0[2];
573             uint32_t PB = sa1[2];
574             uint32_t PE = sa2[2];
575             uint32_t PH = sa3[2];
576             uint32_t H5 = sa4[2];
577
578             uint32_t A1 = sa0[pprev];
579             uint32_t PA = sa1[pprev];
580             uint32_t PD = sa2[pprev];
581             uint32_t PG = sa3[pprev];
582             uint32_t G5 = sa4[pprev];
583
584             uint32_t A0 = sa1[pprev2];
585             uint32_t D0 = sa2[pprev2];
586             uint32_t G0 = sa3[pprev2];
587
588             uint32_t C1 = 0;
589             uint32_t PC = 0;
590             uint32_t PF = 0;
591             uint32_t PI = 0;
592             uint32_t I5 = 0;
593
594             uint32_t C4 = 0;
595             uint32_t F4 = 0;
596             uint32_t I4 = 0;
597
598             if (x >= input->width - 2){
599                 if (x == input->width - 1){
600                     C1 = sa0[2];
601                     PC = sa1[2];
602                     PF = sa2[2];
603                     PI = sa3[2];
604                     I5 = sa4[2];
605
606                     C4 = sa1[2];
607                     F4 = sa2[2];
608                     I4 = sa3[2];
609                 } else {
610                     C1 = sa0[3];
611                     PC = sa1[3];
612                     PF = sa2[3];
613                     PI = sa3[3];
614                     I5 = sa4[3];
615
616                     C4 = sa1[3];
617                     F4 = sa2[3];
618                     I4 = sa3[3];
619                 }
620             } else {
621                 C1 = sa0[3];
622                 PC = sa1[3];
623                 PF = sa2[3];
624                 PI = sa3[3];
625                 I5 = sa4[3];
626
627                 C4 = sa1[4];
628                 F4 = sa2[4];
629                 I4 = sa3[4];
630             }
631
632             E[0]   = E[1]     = E[2]     = E[3]     = PE;
633             E[nl]  = E[nl+1]  = E[nl+2]  = E[nl+3]  = PE; //  4,  5,  6,  7
634             E[nl1] = E[nl1+1] = E[nl1+2] = E[nl1+3] = PE; //  8,  9, 10, 11
635             E[nl2] = E[nl2+1] = E[nl2+2] = E[nl2+3] = PE; // 12, 13, 14, 15
636
637             FILTRO(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,r2y);
638             FILTRO(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,r2y);
639             FILTRO(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,r2y);
640             FILTRO(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,r2y);
641
642             sa0 += 1;
643             sa1 += 1;
644             sa2 += 1;
645             sa3 += 1;
646             sa4 += 1;
647
648             E += 4;
649
650             if (pprev2){
651                 pprev2--;
652                 pprev = 1;
653             }
654         }
655     }
656 }
657 #undef FILTRO
658
659 static int config_output(AVFilterLink *outlink)
660 {
661     AVFilterContext *ctx = outlink->src;
662     XBRContext *xbr = ctx->priv;
663     AVFilterLink *inlink = ctx->inputs[0];
664
665     outlink->w = inlink->w * xbr->n;
666     outlink->h = inlink->h * xbr->n;
667     return 0;
668 }
669
670 static int query_formats(AVFilterContext *ctx)
671 {
672     static const enum AVPixelFormat pix_fmts[] = {
673         AV_PIX_FMT_0RGB32, AV_PIX_FMT_NONE,
674     };
675
676     ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
677     return 0;
678 }
679
680 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
681 {
682     AVFilterContext *ctx = inlink->dst;
683     AVFilterLink *outlink = ctx->outputs[0];
684     XBRContext *xbr = ctx->priv;
685     const uint32_t *r2y = xbr->rgbtoyuv;
686
687     AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
688     if (!out) {
689         av_frame_free(&in);
690         return AVERROR(ENOMEM);
691     }
692
693     av_frame_copy_props(out, in);
694     if(xbr->n == 4)
695         xbr4x(in,out,r2y);
696     else if(xbr->n == 3)
697         xbr3x(in,out,r2y);
698     else
699         xbr2x(in,out,r2y);
700
701     out->width  = outlink->w;
702     out->height = outlink->h;
703
704     av_frame_free(&in);
705     return ff_filter_frame(outlink, out);
706 }
707
708 static int init(AVFilterContext *ctx)
709 {
710     XBRContext *xbr = ctx->priv;
711     uint32_t c;
712     int bg, rg, g;
713
714     for (bg=-255; bg<256; bg++) {
715         for (rg=-255; rg<256; rg++) {
716             const uint32_t u = (uint32_t)((-169*rg + 500*bg)/1000) + 128;
717             const uint32_t v = (uint32_t)(( 500*rg -  81*bg)/1000) + 128;
718             int startg = FFMAX3(-bg, -rg, 0);
719             int endg = FFMIN3(255-bg, 255-rg, 255);
720             uint32_t y = (uint32_t)(( 299*rg + 1000*startg + 114*bg)/1000);
721             c = bg + (rg<<16) + 0x010101 * startg;
722             for (g = startg; g <= endg; g++) {
723                 xbr->rgbtoyuv[c] = ((y++) << 16) + (u << 8) + v;
724                 c+= 0x010101;
725             }
726         }
727     }
728
729     return 0;
730 }
731
732 static const AVFilterPad xbr_inputs[] = {
733     {
734         .name         = "default",
735         .type         = AVMEDIA_TYPE_VIDEO,
736         .filter_frame = filter_frame,
737     },
738     { NULL }
739 };
740
741 static const AVFilterPad xbr_outputs[] = {
742     {
743         .name         = "default",
744         .type         = AVMEDIA_TYPE_VIDEO,
745         .config_props = config_output,
746     },
747     { NULL }
748 };
749
750 AVFilter ff_vf_xbr = {
751     .name          = "xbr",
752     .description   = NULL_IF_CONFIG_SMALL("Scale the input using xBR algorithm."),
753     .inputs        = xbr_inputs,
754     .outputs       = xbr_outputs,
755     .query_formats = query_formats,
756     .priv_size     = sizeof(XBRContext),
757     .priv_class    = &xbr_class,
758     .init          = init,
759 };