doxygen/3.4/vf__deband_8c_source.html

 /*

  * Copyright (c) 2015 Niklas Haas

  * Copyright (c) 2015 Paul B Mahol

  *

  * Permission is hereby granted, free of charge, to any person obtaining a copy

  * of this software and associated documentation files (the "Software"), to deal

  * in the Software without restriction, including without limitation the rights

  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  * copies of the Software, and to permit persons to whom the Software is

  * furnished to do so, subject to the following conditions:

  *

  * The above copyright notice and this permission notice shall be included in

  * all copies or substantial portions of the Software.

  *

  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  * SOFTWARE.

  */


 #include "libavutil/opt.h"

 #include "libavutil/pixdesc.h"

 #include "avfilter.h"

 #include "internal.h"

 #include "video.h"


 typedef struct DebandContext {

     const AVClass *class;


     int coupling;

     float threshold[4];

     int range;

     int blur;

     float direction;


     int nb_components;

     int planewidth[4];

     int planeheight[4];

     int shift[2];

     int thr[4];


     int *x_pos;

     int *y_pos;


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

 } DebandContext;


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

 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM


 static const AVOption deband_options[] = {

     { "1thr",      "set 1st plane threshold", OFFSET(threshold[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.02},  0.00003,     0.5, FLAGS },

     { "2thr",      "set 2nd plane threshold", OFFSET(threshold[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.02},  0.00003,     0.5, FLAGS },

     { "3thr",      "set 3rd plane threshold", OFFSET(threshold[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.02},  0.00003,     0.5, FLAGS },

     { "4thr",      "set 4th plane threshold", OFFSET(threshold[3]), AV_OPT_TYPE_FLOAT, {.dbl=0.02},  0.00003,     0.5, FLAGS },

     { "range",     "set range",               OFFSET(range),        AV_OPT_TYPE_INT,   {.i64=16},    INT_MIN, INT_MAX, FLAGS },

     { "r",         "set range",               OFFSET(range),        AV_OPT_TYPE_INT,   {.i64=16},    INT_MIN, INT_MAX, FLAGS },

     { "direction", "set direction",           OFFSET(direction),    AV_OPT_TYPE_FLOAT, {.dbl=2*M_PI},-2*M_PI,  2*M_PI, FLAGS },

     { "d",         "set direction",           OFFSET(direction),    AV_OPT_TYPE_FLOAT, {.dbl=2*M_PI},-2*M_PI,  2*M_PI, FLAGS },

     { "blur",      "set blur",                OFFSET(blur),         AV_OPT_TYPE_BOOL,  {.i64=1},           0,       1, FLAGS },

     { "b",         "set blur",                OFFSET(blur),         AV_OPT_TYPE_BOOL,  {.i64=1},           0,       1, FLAGS },

     { "coupling",  "set plane coupling",      OFFSET(coupling),     AV_OPT_TYPE_BOOL,  {.i64=0},           0,       1, FLAGS },

     { "c",         "set plane coupling",      OFFSET(coupling),     AV_OPT_TYPE_BOOL,  {.i64=0},           0,       1, FLAGS },

     { NULL }

 };


 AVFILTER_DEFINE_CLASS(deband);


 static int query_formats(AVFilterContext *ctx)

 {

     DebandContext *s = ctx->priv;


     static const enum AVPixelFormat pix_fmts[] = {

         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,

         AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,

         AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,

         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,

         AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ440P,

         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,

         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,

         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,

         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,

         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,

         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,

         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,

         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,

         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,

         AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,

         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,

         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,

         AV_PIX_FMT_NONE

     };


     static const enum AVPixelFormat cpix_fmts[] = {

         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,

         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P9,

         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,

         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,

         AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA444P16,

         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,

         AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,

         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,

         AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,

         AV_PIX_FMT_NONE

     };


     AVFilterFormats *fmts_list = ff_make_format_list(s->coupling ? cpix_fmts : pix_fmts);

     if (!fmts_list)

         return AVERROR(ENOMEM);


     return ff_set_common_formats(ctx, fmts_list);

 }


 static float frand(int x, int y)

 {

     const float r = sinf(x * 12.9898 + y * 78.233) * 43758.545;


     return r - floorf(r);

 }


 static int inline get_avg(int ref0, int ref1, int ref2, int ref3)

 {

     return (ref0 + ref1 + ref2 + ref3) / 4;

 }


 typedef struct ThreadData {

     AVFrame *in, *out;

 } ThreadData;


 static int deband_8_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

 {

     DebandContext *s = ctx->priv;

     ThreadData *td = arg;

     AVFrame *in = td->in;

     AVFrame *out = td->out;

     int x, y, p;


     for (p = 0; p < s->nb_components; p++) {

         const uint8_t *src_ptr = (const uint8_t *)in->data[p];

         uint8_t *dst_ptr = (uint8_t *)out->data[p];

         const int dst_linesize = out->linesize[p];

         const int src_linesize = in->linesize[p];

         const int thr = s->thr[p];

         const int start = (s->planeheight[p] *  jobnr   ) / nb_jobs;

         const int end   = (s->planeheight[p] * (jobnr+1)) / nb_jobs;

         const int w = s->planewidth[p] - 1;

         const int h = s->planeheight[p] - 1;


         for (y = start; y < end; y++) {

             const int pos = y * s->planewidth[0];


             for (x = 0; x < s->planewidth[p]; x++) {

                 const int x_pos = s->x_pos[pos + x];

                 const int y_pos = s->y_pos[pos + x];

                 const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int src0 = src_ptr[y * src_linesize + x];


                 if (s->blur) {

                     const int avg = get_avg(ref0, ref1, ref2, ref3);

                     const int diff = FFABS(src0 - avg);


                     dst_ptr[y * dst_linesize + x] = diff < thr ? avg : src0;

                 } else {

                     dst_ptr[y * dst_linesize + x] = (FFABS(src0 - ref0) < thr) &&

                                                     (FFABS(src0 - ref1) < thr) &&

                                                     (FFABS(src0 - ref2) < thr) &&

                                                     (FFABS(src0 - ref3) < thr) ? get_avg(ref0, ref1, ref2, ref3) : src0;

                 }

             }

         }

     }


     return 0;

 }


 static int deband_8_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

 {

     DebandContext *s = ctx->priv;

     ThreadData *td = arg;

     AVFrame *in = td->in;

     AVFrame *out = td->out;

     const int start = (s->planeheight[0] *  jobnr   ) / nb_jobs;

     const int end   = (s->planeheight[0] * (jobnr+1)) / nb_jobs;

     int x, y, p;


     for (y = start; y < end; y++) {

         const int pos = y * s->planewidth[0];


         for (x = 0; x < s->planewidth[0]; x++) {

             const int x_pos = s->x_pos[pos + x];

             const int y_pos = s->y_pos[pos + x];

             int avg[4], cmp[4] = { 0 }, src[4];


             for (p = 0; p < s->nb_components; p++) {

                 const uint8_t *src_ptr = (const uint8_t *)in->data[p];

                 const int src_linesize = in->linesize[p];

                 const int thr = s->thr[p];

                 const int w = s->planewidth[p] - 1;

                 const int h = s->planeheight[p] - 1;

                 const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int src0 = src_ptr[y * src_linesize + x];


                 src[p] = src0;

                 avg[p] = get_avg(ref0, ref1, ref2, ref3);


                 if (s->blur) {

                     cmp[p] = FFABS(src0 - avg[p]) < thr;

                 } else {

                     cmp[p] = (FFABS(src0 - ref0) < thr) &&

                              (FFABS(src0 - ref1) < thr) &&

                              (FFABS(src0 - ref2) < thr) &&

                              (FFABS(src0 - ref3) < thr);

                 }

             }


             for (p = 0; p < s->nb_components; p++)

                 if (!cmp[p])

                     break;

             if (p == s->nb_components) {

                 for (p = 0; p < s->nb_components; p++) {

                     const int dst_linesize = out->linesize[p];


                     out->data[p][y * dst_linesize + x] = avg[p];

                 }

             } else {

                 for (p = 0; p < s->nb_components; p++) {

                     const int dst_linesize = out->linesize[p];


                     out->data[p][y * dst_linesize + x] = src[p];

                 }

             }

         }

     }


     return 0;

 }


 static int deband_16_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

 {

     DebandContext *s = ctx->priv;

     ThreadData *td = arg;

     AVFrame *in = td->in;

     AVFrame *out = td->out;

     const int start = (s->planeheight[0] *  jobnr   ) / nb_jobs;

     const int end   = (s->planeheight[0] * (jobnr+1)) / nb_jobs;

     int x, y, p, z;


     for (y = start; y < end; y++) {

         const int pos = y * s->planewidth[0];


         for (x = 0; x < s->planewidth[0]; x++) {

             const int x_pos = s->x_pos[pos + x];

             const int y_pos = s->y_pos[pos + x];

             int avg[4], cmp[4] = { 0 }, src[4];


             for (p = 0; p < s->nb_components; p++) {

                 const uint16_t *src_ptr = (const uint16_t *)in->data[p];

                 const int src_linesize = in->linesize[p] / 2;

                 const int thr = s->thr[p];

                 const int w = s->planewidth[p] - 1;

                 const int h = s->planeheight[p] - 1;

                 const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int src0 = src_ptr[y * src_linesize + x];


                 src[p] = src0;

                 avg[p] = get_avg(ref0, ref1, ref2, ref3);


                 if (s->blur) {

                     cmp[p] = FFABS(src0 - avg[p]) < thr;

                 } else {

                     cmp[p] = (FFABS(src0 - ref0) < thr) &&

                              (FFABS(src0 - ref1) < thr) &&

                              (FFABS(src0 - ref2) < thr) &&

                              (FFABS(src0 - ref3) < thr);

                 }

             }


             for (z = 0; z < s->nb_components; z++)

                 if (!cmp[z])

                     break;

             if (z == s->nb_components) {

                 for (p = 0; p < s->nb_components; p++) {

                     const int dst_linesize = out->linesize[p] / 2;

                     uint16_t *dst = (uint16_t *)out->data[p] + y * dst_linesize + x;


                     dst[0] = avg[p];

                 }

             } else {

                 for (p = 0; p < s->nb_components; p++) {

                     const int dst_linesize = out->linesize[p] / 2;

                     uint16_t *dst = (uint16_t *)out->data[p] + y * dst_linesize + x;


                     dst[0] = src[p];

                 }

             }

         }

     }


     return 0;

 }


 static int deband_16_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)

 {

     DebandContext *s = ctx->priv;

     ThreadData *td = arg;

     AVFrame *in = td->in;

     AVFrame *out = td->out;

     int x, y, p;


     for (p = 0; p < s->nb_components; p++) {

         const uint16_t *src_ptr = (const uint16_t *)in->data[p];

         uint16_t *dst_ptr = (uint16_t *)out->data[p];

         const int dst_linesize = out->linesize[p] / 2;

         const int src_linesize = in->linesize[p] / 2;

         const int thr = s->thr[p];

         const int start = (s->planeheight[p] *  jobnr   ) / nb_jobs;

         const int end   = (s->planeheight[p] * (jobnr+1)) / nb_jobs;

         const int w = s->planewidth[p] - 1;

         const int h = s->planeheight[p] - 1;


         for (y = start; y < end; y++) {

             const int pos = y * s->planewidth[0];


             for (x = 0; x < s->planewidth[p]; x++) {

                 const int x_pos = s->x_pos[pos + x];

                 const int y_pos = s->y_pos[pos + x];

                 const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];

                 const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];

                 const int src0 = src_ptr[y * src_linesize + x];


                 if (s->blur) {

                     const int avg = get_avg(ref0, ref1, ref2, ref3);

                     const int diff = FFABS(src0 - avg);


                     dst_ptr[y * dst_linesize + x] = diff < thr ? avg : src0;

                 } else {

                     dst_ptr[y * dst_linesize + x] = (FFABS(src0 - ref0) < thr) &&

                                                     (FFABS(src0 - ref1) < thr) &&

                                                     (FFABS(src0 - ref2) < thr) &&

                                                     (FFABS(src0 - ref3) < thr) ? get_avg(ref0, ref1, ref2, ref3) : src0;

                 }

             }

         }

     }


     return 0;

 }


 static int config_input(AVFilterLink *inlink)

 {

     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

     AVFilterContext *ctx = inlink->dst;

     DebandContext *s = ctx->priv;

     const float direction = s->direction;

     const int range = s->range;

     int x, y;


     s->nb_components = desc->nb_components;


     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);

     s->planeheight[0] = s->planeheight[3] = inlink->h;

     s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);

     s->planewidth[0]  = s->planewidth[3]  = inlink->w;

     s->shift[0] = desc->log2_chroma_w;

     s->shift[1] = desc->log2_chroma_h;


     if (s->coupling)

         s->deband = desc->comp[0].depth > 8 ? deband_16_coupling_c : deband_8_coupling_c;

     else

         s->deband = desc->comp[0].depth > 8 ? deband_16_c : deband_8_c;


     s->thr[0] = ((1 << desc->comp[0].depth) - 1) * s->threshold[0];

     s->thr[1] = ((1 << desc->comp[1].depth) - 1) * s->threshold[1];

     s->thr[2] = ((1 << desc->comp[2].depth) - 1) * s->threshold[2];

     s->thr[3] = ((1 << desc->comp[3].depth) - 1) * s->threshold[3];


     s->x_pos = av_malloc(s->planewidth[0] * s->planeheight[0] * sizeof(*s->x_pos));

     s->y_pos = av_malloc(s->planewidth[0] * s->planeheight[0] * sizeof(*s->y_pos));

     if (!s->x_pos || !s->y_pos)

         return AVERROR(ENOMEM);


     for (y = 0; y < s->planeheight[0]; y++) {

         for (x = 0; x < s->planewidth[0]; x++) {

             const float r = frand(x, y);

             const float dir = direction < 0 ? -direction : r * direction;

             const int dist = range < 0 ? -range : r * range;


             s->x_pos[y * s->planewidth[0] + x] = cosf(dir) * dist;

             s->y_pos[y * s->planewidth[0] + x] = sinf(dir) * dist;

         }

     }


     return 0;

 }


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

 {

     AVFilterContext *ctx = inlink->dst;

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

     DebandContext *s = ctx->priv;

     AVFrame *out;

     ThreadData td;


     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;

     ctx->internal->execute(ctx, s->deband, &td, NULL, FFMIN3(s->planeheight[1],

                                                              s->planeheight[2],

                                                              ff_filter_get_nb_threads(ctx)));


     av_frame_free(&in);

     return ff_filter_frame(outlink, out);

 }


 static av_cold void uninit(AVFilterContext *ctx)

 {

     DebandContext *s = ctx->priv;


     av_freep(&s->x_pos);

     av_freep(&s->y_pos);

 }


 static const AVFilterPad avfilter_vf_deband_inputs[] = {

     {

         .name         = "default",

         .type         = AVMEDIA_TYPE_VIDEO,

         .config_props = config_input,

         .filter_frame = filter_frame,

     },

     { NULL }

 };


 static const AVFilterPad avfilter_vf_deband_outputs[] = {

     {

         .name = "default",

         .type = AVMEDIA_TYPE_VIDEO,

     },

     { NULL }

 };


 AVFilter ff_vf_deband = {

     .name          = "deband",

     .description   = NULL_IF_CONFIG_SMALL("Debands video."),

     .priv_size     = sizeof(DebandContext),

     .priv_class    = &deband_class,

     .uninit        = uninit,

     .query_formats = query_formats,

     .inputs        = avfilter_vf_deband_inputs,

     .outputs       = avfilter_vf_deband_outputs,

     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,

 };

DebandContext::range
int range
Definition: vf_deband.c:35

NULL
#define NULL
Definition: coverity.c:32

AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:418

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

avfilter_vf_deband_outputs
static const AVFilterPad avfilter_vf_deband_outputs[]
Definition: vf_deband.c:452

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

DebandContext
Definition: vf_deband.c:30

AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:412

av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2419

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

AV_PIX_FMT_NONE
Definition: pixfmt.h:61

h
h
Definition: vp9dsp_template.c:2038

AVOption
AVOption.
Definition: opt.h:246

AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:414

AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:389

AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:415

AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67

avfilter.h
Main libavfilter public API header.

desc
const char * desc
Definition: nvenc.c:60

AV_OPT_TYPE_INT
Definition: opt.h:223

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

AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:180

AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:395

blur
static void blur(uint8_t *dst, int dst_step, const uint8_t *src, int src_step, int len, int radius, int pixsize)
Definition: vf_boxblur.c:255

AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:383

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

src
#define src
Definition: vp8dsp.c:254

query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_deband.c:72

AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92

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

AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(deband)

AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125

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

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

DebandContext::thr
int thr[4]
Definition: vf_deband.c:43

AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:102

deband_options
static const AVOption deband_options[]
Definition: vf_deband.c:54

AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117

uint8_t
uint8_t
Definition: audio_convert.c:194

av_cold
#define av_cold
Definition: attributes.h:82

av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31

opt.h
AVOptions.

end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90

deband_8_c
static int deband_8_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_deband.c:133

AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:411

cosf
#define cosf(x)
Definition: libm.h:78

AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:394

AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:101

flags
static int flags
Definition: log.c:57

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

AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:75

AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:392

AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:384

AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:417

video.h

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

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

AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:188

DebandContext::threshold
float threshold[4]
Definition: vf_deband.c:34

uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_deband.c:434

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

AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101

OFFSET
#define OFFSET(x)
Definition: vf_deband.c:51

frand
static float frand(int x, int y)
Definition: vf_deband.c:117

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

AV_OPT_TYPE_FLOAT
Definition: opt.h:226

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

DebandContext::blur
int blur
Definition: vf_deband.c:36

r
const char * r
Definition: vf_curves.c:111

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

AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:419

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

deband_8_coupling_c
static int deband_8_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_deband.c:182

DebandContext::coupling
int coupling
Definition: vf_deband.c:33

AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:401

AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:66

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

AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:377

AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83

pixdesc.h

AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:398

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

AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:363

AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:74

deband_16_coupling_c
static int deband_16_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_deband.c:247

filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_deband.c:410

ctx
AVFormatContext * ctx
Definition: movenc.c:48

AV_OPT_TYPE_BOOL
Definition: opt.h:240

FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72

DebandContext::nb_components
int nb_components
Definition: vf_deband.c:39

cmp
static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, const int size, const int h, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags)
compares a block (either a full macroblock or a partition thereof) against a proposed motion-compensa...
Definition: motion_est.c:260

AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:416

outputs
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:389

AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:378

AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:397

AVFilterLink::format
int format
agreed upon media format
Definition: avfilter.h:440

AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:390

sinf
#define sinf(x)
Definition: libm.h:419

inputs
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:379

AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:387

DebandContext::planewidth
int planewidth[4]
Definition: vf_deband.c:40

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

AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:189

AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81

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

AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:68

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

AVFilter
Filter definition.
Definition: avfilter.h:144

DebandContext::y_pos
int * y_pos
Definition: vf_deband.c:46

src0
#define src0
Definition: h264pred.c:138

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

FLAGS
#define FLAGS
Definition: vf_deband.c:52

AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:376

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

DebandContext::x_pos
int * x_pos
Definition: vf_deband.c:45

AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:388

AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:396

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

AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:386

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

avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28

int
int
Definition: ffmpeg_filter.c:190

AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62

DebandContext::direction
float direction
Definition: vf_deband.c:37

AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:70

AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:229

AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:413

AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:76

AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69

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

DebandContext::deband
int(* deband)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_deband.c:48

ff_vf_deband
AVFilter ff_vf_deband
Definition: vf_deband.c:460

DebandContext::shift
int shift[2]
Definition: vf_deband.c:42

diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:133

config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_deband.c:363

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

DebandContext::planeheight
int planeheight[4]
Definition: vf_deband.c:41

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

AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:272

avfilter_vf_deband_inputs
static const AVFilterPad avfilter_vf_deband_inputs[]
Definition: vf_deband.c:442

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

out
FILE * out
Definition: movenc.c:54

get_avg
static int get_avg(int ref0, int ref1, int ref2, int ref3)
Definition: vf_deband.c:124

av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35

AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:100

start
void INT64 start
Definition: avisynth_c.h:690

AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201

M_PI
#define M_PI
Definition: mathematics.h:52

internal.h
internal API functions

AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:58

deband_16_c
static int deband_16_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_deband.c:314

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

AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:391

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

AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58