doxygen/3.4/vf__xbr_8c_source.html

 /*

  * This file is part of FFmpeg.

  *

  * Copyright (c) 2011, 2012 Hyllian/Jararaca <sergiogdb@gmail.com>

  * Copyright (c) 2014 Arwa Arif <arwaarif1994@gmail.com>

  *

  * FFmpeg is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public

  * License as published by the Free Software Foundation; either

  * version 2.1 of the License, or (at your option) any later version.

  *

  * FFmpeg is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  * Lesser General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General Public

  * License along with FFmpeg; if not, write to the Free Software

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  */


 /**

  * @file

  * XBR Filter is used for depixelization of image.

  * This is based on Hyllian's xBR shader.

  *

  * @see http://www.libretro.com/forums/viewtopic.php?f=6&t=134

  * @see https://github.com/yoyofr/iFBA/blob/master/fba_src/src/intf/video/scalers/xbr.cpp

  */


 #include "libavutil/opt.h"

 #include "libavutil/avassert.h"

 #include "libavutil/pixdesc.h"

 #include "internal.h"


 #define LB_MASK       0x00FEFEFE

 #define RED_BLUE_MASK 0x00FF00FF

 #define GREEN_MASK    0x0000FF00


 #ifdef PI

 #undef PI

 #endif


 typedef int (*xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);


 typedef struct XBRContext {

     const AVClass *class;

     int n;

     xbrfunc_t func;

     uint32_t rgbtoyuv[1<<24];

 } XBRContext;


 typedef struct ThreadData {

     AVFrame *in, *out;

     const uint32_t *rgbtoyuv;

 } ThreadData;


 #define OFFSET(x) offsetof(XBRContext, x)

 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

 static const AVOption xbr_options[] = {

     { "n", "set scale factor", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 3}, 2, 4, .flags = FLAGS },

     { NULL }

 };


 AVFILTER_DEFINE_CLASS(xbr);


 static uint32_t pixel_diff(uint32_t x, uint32_t y, const uint32_t *r2y)

 {

 #define YMASK 0xff0000

 #define UMASK 0x00ff00

 #define VMASK 0x0000ff

 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))


     uint32_t yuv1 = r2y[x & 0xffffff];

     uint32_t yuv2 = r2y[y & 0xffffff];


     return (ABSDIFF(yuv1 & YMASK, yuv2 & YMASK) >> 16) +

            (ABSDIFF(yuv1 & UMASK, yuv2 & UMASK) >>  8) +

             ABSDIFF(yuv1 & VMASK, yuv2 & VMASK);

 }


 #define ALPHA_BLEND_128_W(a, b) ((((a) & LB_MASK) >> 1) + (((b) & LB_MASK) >> 1))

 #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)))) \

                                       | (GREEN_MASK    & (((a) & GREEN_MASK)    + (((((b) & GREEN_MASK)    - ((a) & GREEN_MASK))    * (m)) >> (s)))))

 #define ALPHA_BLEND_32_W(a, b)  ALPHA_BLEND_BASE(a, b, 1, 3)

 #define ALPHA_BLEND_64_W(a, b)  ALPHA_BLEND_BASE(a, b, 1, 2)

 #define ALPHA_BLEND_192_W(a, b) ALPHA_BLEND_BASE(a, b, 3, 2)

 #define ALPHA_BLEND_224_W(a, b) ALPHA_BLEND_BASE(a, b, 7, 3)


 #define df(A, B) pixel_diff(A, B, r2y)

 #define eq(A, B) (df(A, B) < 155)


 #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) do {                                                                  \

     if (PE != PH && PE != PF) {                                                                     \

         const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2);          \

         const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2);          \

         if (e <= i) {                                                                               \

             const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH;                                   \

             if (e < i && (!eq(PF,PB) && !eq(PH,PD) || eq(PE,PI)                                     \

                           && (!eq(PF,I4) && !eq(PH,I5))                                             \

                           || eq(PE,PG) || eq(PE,PC))) {                                             \

                 const unsigned ke = df(PF,PG);                                                      \

                 const unsigned ki = df(PH,PC);                                                      \

                 const int left    = ke<<1 <= ki && PE != PG && PD != PG;                            \

                 const int up      = ke >= ki<<1 && PE != PC && PB != PC;                            \

                 if (left && up) {                                                                   \

                     E[N3] = ALPHA_BLEND_224_W(E[N3], px);                                           \

                     E[N2] = ALPHA_BLEND_64_W( E[N2], px);                                           \

                     E[N1] = E[N2];                                                                  \

                 } else if (left) {                                                                  \

                     E[N3] = ALPHA_BLEND_192_W(E[N3], px);                                           \

                     E[N2] = ALPHA_BLEND_64_W( E[N2], px);                                           \

                 } else if (up) {                                                                    \

                     E[N3] = ALPHA_BLEND_192_W(E[N3], px);                                           \

                     E[N1] = ALPHA_BLEND_64_W( E[N1], px);                                           \

                 } else { /* diagonal */                                                             \

                     E[N3] = ALPHA_BLEND_128_W(E[N3], px);                                           \

                 }                                                                                   \

             } else {                                                                                \

                 E[N3] = ALPHA_BLEND_128_W(E[N3], px);                                               \

             }                                                                                       \

         }                                                                                           \

     }                                                                                               \

 } while (0)


 #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) do {                                              \

     if (PE != PH && PE != PF) {                                                                     \

         const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2);          \

         const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2);          \

         if (e <= i) {                                                                               \

             const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH;                                   \

             if (e < i && (!eq(PF,PB) && !eq(PF,PC) || !eq(PH,PD) && !eq(PH,PG) || eq(PE,PI)         \

                           && (!eq(PF,F4) && !eq(PF,I4) || !eq(PH,H5) && !eq(PH,I5))                 \

                           || eq(PE,PG) || eq(PE,PC))) {                                             \

                 const unsigned ke = df(PF,PG);                                                      \

                 const unsigned ki = df(PH,PC);                                                      \

                 const int left    = ke<<1 <= ki && PE != PG && PD != PG;                            \

                 const int up      = ke >= ki<<1 && PE != PC && PB != PC;                            \

                 if (left && up) {                                                                   \

                     E[N7] = ALPHA_BLEND_192_W(E[N7], px);                                           \

                     E[N6] = ALPHA_BLEND_64_W( E[N6], px);                                           \

                     E[N5] = E[N7];                                                                  \

                     E[N2] = E[N6];                                                                  \

                     E[N8] = px;                                                                     \

                 } else if (left) {                                                                  \

                     E[N7] = ALPHA_BLEND_192_W(E[N7], px);                                           \

                     E[N5] = ALPHA_BLEND_64_W( E[N5], px);                                           \

                     E[N6] = ALPHA_BLEND_64_W( E[N6], px);                                           \

                     E[N8] = px;                                                                     \

                 } else if (up) {                                                                    \

                     E[N5] = ALPHA_BLEND_192_W(E[N5], px);                                           \

                     E[N7] = ALPHA_BLEND_64_W( E[N7], px);                                           \

                     E[N2] = ALPHA_BLEND_64_W( E[N2], px);                                           \

                     E[N8] = px;                                                                     \

                 } else { /* diagonal */                                                             \

                     E[N8] = ALPHA_BLEND_224_W(E[N8], px);                                           \

                     E[N5] = ALPHA_BLEND_32_W( E[N5], px);                                           \

                     E[N7] = ALPHA_BLEND_32_W( E[N7], px);                                           \

                 }                                                                                   \

             } else {                                                                                \

                 E[N8] = ALPHA_BLEND_128_W(E[N8], px);                                               \

             }                                                                                       \

         }                                                                                           \

     }                                                                                               \

 } while (0)


 #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) do {            \

     if (PE != PH && PE != PF) {                                                                     \

         const unsigned e = df(PE,PC) + df(PE,PG) + df(PI,H5) + df(PI,F4) + (df(PH,PF)<<2);          \

         const unsigned i = df(PH,PD) + df(PH,I5) + df(PF,I4) + df(PF,PB) + (df(PE,PI)<<2);          \

         if (e <= i) {                                                                               \

             const unsigned px = df(PE,PF) <= df(PE,PH) ? PF : PH;                                   \

             if (e < i && (!eq(PF,PB) && !eq(PH,PD) || eq(PE,PI)                                     \

                           && (!eq(PF,I4) && !eq(PH,I5))                                             \

                           || eq(PE,PG) || eq(PE,PC))) {                                             \

                 const unsigned ke = df(PF,PG);                                                      \

                 const unsigned ki = df(PH,PC);                                                      \

                 const int left    = ke<<1 <= ki && PE != PG && PD != PG;                            \

                 const int up      = ke >= ki<<1 && PE != PC && PB != PC;                            \

                 if (left && up) {                                                                   \

                     E[N13] = ALPHA_BLEND_192_W(E[N13], px);                                         \

                     E[N12] = ALPHA_BLEND_64_W( E[N12], px);                                         \

                     E[N15] = E[N14] = E[N11] = px;                                                  \

                     E[N10] = E[N3]  = E[N12];                                                       \

                     E[N7]  = E[N13];                                                                \

                 } else if (left) {                                                                  \

                     E[N11] = ALPHA_BLEND_192_W(E[N11], px);                                         \

                     E[N13] = ALPHA_BLEND_192_W(E[N13], px);                                         \

                     E[N10] = ALPHA_BLEND_64_W( E[N10], px);                                         \

                     E[N12] = ALPHA_BLEND_64_W( E[N12], px);                                         \

                     E[N14] = px;                                                                    \

                     E[N15] = px;                                                                    \

                 } else if (up) {                                                                    \

                     E[N14] = ALPHA_BLEND_192_W(E[N14], px);                                         \

                     E[N7 ] = ALPHA_BLEND_192_W(E[N7 ], px);                                         \

                     E[N10] = ALPHA_BLEND_64_W( E[N10], px);                                         \

                     E[N3 ] = ALPHA_BLEND_64_W( E[N3 ], px);                                         \

                     E[N11] = px;                                                                    \

                     E[N15] = px;                                                                    \

                 } else { /* diagonal */                                                             \

                     E[N11] = ALPHA_BLEND_128_W(E[N11], px);                                         \

                     E[N14] = ALPHA_BLEND_128_W(E[N14], px);                                         \

                     E[N15] = px;                                                                    \

                 }                                                                                   \

             } else {                                                                                \

                 E[N15] = ALPHA_BLEND_128_W(E[N15], px);                                             \

             }                                                                                       \

         }                                                                                           \

     }                                                                                               \

 } while (0)


 static av_always_inline void xbr_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)

 {

     int x, y;

     const AVFrame *input = td->in;

     AVFrame *output = td->out;

     const uint32_t *r2y = td->rgbtoyuv;

     const int slice_start = (input->height *  jobnr   ) / nb_jobs;

     const int slice_end   = (input->height * (jobnr+1)) / nb_jobs;

     const int nl = output->linesize[0] >> 2;

     const int nl1 = nl + nl;

     const int nl2 = nl1 + nl;


     for (y = slice_start; y < slice_end; y++) {


         uint32_t *E = (uint32_t *)(output->data[0] + y * output->linesize[0] * n);

         const uint32_t *sa2 = (uint32_t *)(input->data[0] + y * input->linesize[0] - 8); /* center */

         const uint32_t *sa1 = sa2 - (input->linesize[0]>>2); /* up x1 */

         const uint32_t *sa0 = sa1 - (input->linesize[0]>>2); /* up x2 */

         const uint32_t *sa3 = sa2 + (input->linesize[0]>>2); /* down x1 */

         const uint32_t *sa4 = sa3 + (input->linesize[0]>>2); /* down x2 */


         if (y <= 1) {

             sa0 = sa1;

             if (y == 0) {

                 sa0 = sa1 = sa2;

             }

         }


         if (y >= input->height - 2) {

             sa4 = sa3;

             if (y == input->height - 1) {

                 sa4 = sa3 = sa2;

             }

         }


         for (x = 0; x < input->width; x++) {

             const uint32_t B1 = sa0[2];

             const uint32_t PB = sa1[2];

             const uint32_t PE = sa2[2];

             const uint32_t PH = sa3[2];

             const uint32_t H5 = sa4[2];


             const int pprev = 2 - (x > 0);

             const uint32_t A1 = sa0[pprev];

             const uint32_t PA = sa1[pprev];

             const uint32_t PD = sa2[pprev];

             const uint32_t PG = sa3[pprev];

             const uint32_t G5 = sa4[pprev];


             const int pprev2 = pprev - (x > 1);

             const uint32_t A0 = sa1[pprev2];

             const uint32_t D0 = sa2[pprev2];

             const uint32_t G0 = sa3[pprev2];


             const int pnext = 3 - (x == input->width - 1);

             const uint32_t C1 = sa0[pnext];

             const uint32_t PC = sa1[pnext];

             const uint32_t PF = sa2[pnext];

             const uint32_t PI = sa3[pnext];

             const uint32_t I5 = sa4[pnext];


             const int pnext2 = pnext + 1 - (x >= input->width - 2);

             const uint32_t C4 = sa1[pnext2];

             const uint32_t F4 = sa2[pnext2];

             const uint32_t I4 = sa3[pnext2];


             if (n == 2) {

                 E[0]  = E[1]      =     // 0, 1

                 E[nl] = E[nl + 1] = PE; // 2, 3


                 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);

                 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);

                 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);

                 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);

             } else if (n == 3) {

                 E[0]   = E[1]     = E[2]     =     // 0, 1, 2

                 E[nl]  = E[nl+1]  = E[nl+2]  =     // 3, 4, 5

                 E[nl1] = E[nl1+1] = E[nl1+2] = PE; // 6, 7, 8


                 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);

                 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);

                 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);

                 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);

             } else if (n == 4) {

                 E[0]   = E[1]     = E[2]     = E[3]     =     //  0,  1,  2,  3

                 E[nl]  = E[nl+1]  = E[nl+2]  = E[nl+3]  =     //  4,  5,  6,  7

                 E[nl1] = E[nl1+1] = E[nl1+2] = E[nl1+3] =     //  8,  9, 10, 11

                 E[nl2] = E[nl2+1] = E[nl2+2] = E[nl2+3] = PE; // 12, 13, 14, 15


                 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);

                 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);

                 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);

                 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);

             }


             sa0 += 1;

             sa1 += 1;

             sa2 += 1;

             sa3 += 1;

             sa4 += 1;


             E += n;

         }

     }

 }


 #define XBR_FUNC(size) \

 static int xbr##size##x(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \

 { \

     xbr_filter(arg, jobnr, nb_jobs, size); \

     return 0; \

 }


 XBR_FUNC(2)

 XBR_FUNC(3)

 XBR_FUNC(4)


 static int config_output(AVFilterLink *outlink)

 {

     AVFilterContext *ctx = outlink->src;

     XBRContext *s = ctx->priv;

     AVFilterLink *inlink = ctx->inputs[0];


     outlink->w = inlink->w * s->n;

     outlink->h = inlink->h * s->n;

     return 0;

 }


 static int query_formats(AVFilterContext *ctx)

 {

     static const enum AVPixelFormat pix_fmts[] = {

         AV_PIX_FMT_0RGB32, AV_PIX_FMT_NONE,

     };


     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

     if (!fmts_list)

         return AVERROR(ENOMEM);

     return ff_set_common_formats(ctx, fmts_list);

 }


 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

 {

     AVFilterContext *ctx = inlink->dst;

     AVFilterLink *outlink = ctx->outputs[0];

     XBRContext *s = ctx->priv;

     ThreadData td;


     AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

     if (!out) {

         av_frame_free(&in);

         return AVERROR(ENOMEM);

     }


     av_frame_copy_props(out, in);


     td.in = in;

     td.out = out;

     td.rgbtoyuv = s->rgbtoyuv;

     ctx->internal->execute(ctx, s->func, &td, NULL, FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));


     out->width  = outlink->w;

     out->height = outlink->h;


     av_frame_free(&in);

     return ff_filter_frame(outlink, out);

 }


 static int init(AVFilterContext *ctx)

 {

     XBRContext *s = ctx->priv;

     static const xbrfunc_t xbrfuncs[] = {xbr2x, xbr3x, xbr4x};


     uint32_t c;

     int bg, rg, g;


     for (bg = -255; bg < 256; bg++) {

         for (rg = -255; rg < 256; rg++) {

             const uint32_t u = (uint32_t)((-169*rg + 500*bg)/1000) + 128;

             const uint32_t v = (uint32_t)(( 500*rg -  81*bg)/1000) + 128;

             int startg = FFMAX3(-bg, -rg, 0);

             int endg = FFMIN3(255-bg, 255-rg, 255);

             uint32_t y = (uint32_t)(( 299*rg + 1000*startg + 114*bg)/1000);

             c = bg + (rg<<16) + 0x010101 * startg;

             for (g = startg; g <= endg; g++) {

                 s->rgbtoyuv[c] = ((y++) << 16) + (u << 8) + v;

                 c+= 0x010101;

             }

         }

     }


     s->func = xbrfuncs[s->n - 2];

     return 0;

 }


 static const AVFilterPad xbr_inputs[] = {

     {

         .name         = "default",

         .type         = AVMEDIA_TYPE_VIDEO,

         .filter_frame = filter_frame,

     },

     { NULL }

 };


 static const AVFilterPad xbr_outputs[] = {

     {

         .name         = "default",

         .type         = AVMEDIA_TYPE_VIDEO,

         .config_props = config_output,

     },

     { NULL }

 };


 AVFilter ff_vf_xbr = {

     .name          = "xbr",

     .description   = NULL_IF_CONFIG_SMALL("Scale the input using xBR algorithm."),

     .inputs        = xbr_inputs,

     .outputs       = xbr_outputs,

     .query_formats = query_formats,

     .priv_size     = sizeof(XBRContext),

     .priv_class    = &xbr_class,

     .init          = init,

     .flags         = AVFILTER_FLAG_SLICE_THREADS,

 };

NULL
#define NULL
Definition: coverity.c:32

s
const char * s
Definition: avisynth_c.h:768

ThreadData::out
AVFrame * out
Definition: af_headphone.c:146

VMASK
#define VMASK

AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201

AV_PIX_FMT_NONE
Definition: pixfmt.h:61

AVOption
AVOption.
Definition: opt.h:246

A1
#define A1
Definition: binkdsp.c:31

xbr_options
static const AVOption xbr_options[]
Definition: vf_xbr.c:60

XBRContext::func
xbrfunc_t func
Definition: vf_xbr.c:49

g
const char * g
Definition: vf_curves.c:112

AV_OPT_TYPE_INT
Definition: opt.h:223

OFFSET
#define OFFSET(x)
Definition: vf_xbr.c:58

AVFilterLink::h
int h
agreed upon image height
Definition: avfilter.h:434

xbr_inputs
static const AVFilterPad xbr_inputs[]
Definition: vf_xbr.c:410

PF
#define PF(suf)

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:92

ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283

B1
#define B1
Definition: faandct.c:41

AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60

AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346

ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1151

ThreadData::in
AVFrame * in
Definition: af_headphone.c:146

opt.h
AVOptions.

xbrfunc_t
int(* xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_xbr.c:44

ABSDIFF
#define ABSDIFF(a, b)

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:127

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:93

flags
static int flags
Definition: log.c:57

FFMIN3
#define FFMIN3(a, b, c)
Definition: common.h:97

AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54

AVFilterLink
A link between two filters.
Definition: avfilter.h:423

XBRContext::n
int n
Definition: vf_xbr.c:48

C1
#define C1
Definition: simple_idct_mmi.c:29

AVFrame::width
int width
Definition: frame.h:259

ff_set_common_formats
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:568

td
#define td
Definition: regdef.h:70

AVERROR
#define AVERROR(e)
Definition: error.h:43

av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163

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:179

AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:353

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:116

arg
const char * arg
Definition: jacosubdec.c:66

config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_xbr.c:333

avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().

ff_vf_xbr
AVFilter ff_vf_xbr
Definition: vf_xbr.c:428

query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_xbr.c:344

AVFilterLink::w
int w
agreed upon image width
Definition: avfilter.h:433

YMASK
#define YMASK

xbr_filter
static av_always_inline void xbr_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)
Definition: vf_xbr.c:215

pixdesc.h

E
#define E
Definition: avdct.c:32

ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:857

FFMIN
#define FFMIN(a, b)
Definition: common.h:96

FLAGS
#define FLAGS
Definition: vf_xbr.c:59

UMASK
#define UMASK

ctx
AVFormatContext * ctx
Definition: movenc.c:48

XBRContext
Definition: vf_xbr.c:46

n
int n
Definition: avisynth_c.h:684

C4
#define C4
Definition: simple_idct_mmi.c:32

ThreadData
Definition: af_headphone.c:145

AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232

ThreadData::rgbtoyuv
const uint32_t * rgbtoyuv
Definition: vf_hqx.c:46

in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
Definition: audio_convert.c:194

AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67

AVFilter
Filter definition.
Definition: avfilter.h:144

XBR_FUNC
#define XBR_FUNC(size)
Definition: vf_xbr.c:321

filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_xbr.c:356

pixel_diff
static uint32_t pixel_diff(uint32_t x, uint32_t y, const uint32_t *r2y)
Definition: vf_xbr.c:67

AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148

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

u
#define u(width,...)
Definition: vaapi_encode_h26x.h:36

AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350

pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266

AVFilterContext::internal
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378

AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215

int
int
Definition: ffmpeg_filter.c:190

c
static double c[64]
Definition: vsrc_mptestsrc.c:87

AVFilterInternal::execute
avfilter_execute_func * execute
Definition: internal.h:155

slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2052

AVFilterLink::dst
AVFilterContext * dst
dest filter
Definition: avfilter.h:427

AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64

AVFilterContext
An instance of a filter.
Definition: avfilter.h:338

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:169

AVFrame::height
int height
Definition: frame.h:259

out
FILE * out
Definition: movenc.c:54

AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201

av_always_inline
#define av_always_inline
Definition: attributes.h:39

internal.h
internal API functions

xbr_outputs
static const AVFilterPad xbr_outputs[]
Definition: vf_xbr.c:419

init
static int init(AVFilterContext *ctx)
Definition: vf_xbr.c:383

AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60

AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(xbr)

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:603

FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:95

XBRContext::rgbtoyuv
uint32_t rgbtoyuv[1<< 24]
Definition: vf_xbr.c:50

AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:357