libavfilter/vf_epx.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "libavutil/opt.h"
  20 #include "libavutil/pixdesc.h"
  21 #include "internal.h"
  22 #include "video.h"
  23
  24 typedef struct EPXContext {
  25     const AVClass *class;
  26
  27     int n;
  28
  29     int (*epx_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  30 } EPXContext;
  31
  32 typedef struct ThreadData {
  33     AVFrame *in, *out;
  34 } ThreadData;
  35
  36 #define OFFSET(x) offsetof(EPXContext, x)
  37 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
  38 static const AVOption epx_options[] = {
  39     { "n", "set scale factor", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 3}, 2, 3, .flags = FLAGS },
  40     { NULL }
  41 };
  42
  43 AVFILTER_DEFINE_CLASS(epx);
  44
  45 static int epx2_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
  46 {
  47     ThreadData *td = arg;
  48     const AVFrame *in = td->in;
  49     AVFrame *out = td->out;
  50     const int slice_start = (in->height *  jobnr   ) / nb_jobs;
  51     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;
  52
  53     for (int p = 0; p < 1; p++) {
  54         const int width = in->width;
  55         const int height = in->height;
  56         const int src_linesize = in->linesize[p] / 4;
  57         const int dst_linesize = out->linesize[p] / 4;
  58         const uint32_t *src = (const uint32_t *)in->data[p];
  59         uint32_t *dst = (uint32_t *)out->data[p];
  60         const uint32_t *src_line[3];
  61
  62         src_line[0] = src + src_linesize * FFMAX(slice_start - 1, 0);
  63         src_line[1] = src + src_linesize * slice_start;
  64         src_line[2] = src + src_linesize * FFMIN(slice_start + 1, height-1);
  65
  66         for (int y = slice_start; y < slice_end; y++) {
  67             uint32_t *dst_line[2];
  68
  69             dst_line[0] = dst + dst_linesize*2*y;
  70             dst_line[1] = dst + dst_linesize*(2*y+1);
  71
  72             for (int x = 0; x < width; x++) {
  73                 uint32_t E0, E1, E2, E3;
  74                 uint32_t B, D, E, F, H;
  75
  76                 B = src_line[0][x];
  77                 D = src_line[1][FFMAX(x-1, 0)];
  78                 E = src_line[1][x];
  79                 F = src_line[1][FFMIN(x+1, width - 1)];
  80                 H = src_line[2][x];
  81
  82                 if (B != H && D != F) {
  83                     E0 = D == B ? D : E;
  84                     E1 = B == F ? F : E;
  85                     E2 = D == H ? D : E;
  86                     E3 = H == F ? F : E;
  87                 } else {
  88                     E0 = E;
  89                     E1 = E;
  90                     E2 = E;
  91                     E3 = E;
  92                 }
  93
  94                 dst_line[0][x*2]   = E0;
  95                 dst_line[0][x*2+1] = E1;
  96                 dst_line[1][x*2]   = E2;
  97                 dst_line[1][x*2+1] = E3;
  98             }
  99
 100             src_line[0] = src_line[1];
 101             src_line[1] = src_line[2];
 102             src_line[2] = src_line[1];
 103
 104             if (y < height - 2)
 105                 src_line[2] += src_linesize;
 106         }
 107     }
 108
 109     return 0;
 110 }
 111
 112 static int epx3_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 113 {
 114     ThreadData *td = arg;
 115     const AVFrame *in = td->in;
 116     AVFrame *out = td->out;
 117     const int slice_start = (in->height *  jobnr   ) / nb_jobs;
 118     const int slice_end   = (in->height * (jobnr+1)) / nb_jobs;
 119
 120     for (int p = 0; p < 1; p++) {
 121         const int width = in->width;
 122         const int height = in->height;
 123         const int src_linesize = in->linesize[p] / 4;
 124         const int dst_linesize = out->linesize[p] / 4;
 125         const uint32_t *src = (const uint32_t *)in->data[p];
 126         uint32_t *dst = (uint32_t *)out->data[p];
 127         const uint32_t *src_line[3];
 128
 129         src_line[0] = src + src_linesize * FFMAX(slice_start - 1, 0);
 130         src_line[1] = src + src_linesize * slice_start;
 131         src_line[2] = src + src_linesize * FFMIN(slice_start + 1, height-1);
 132
 133         for (int y = slice_start; y < slice_end; y++) {
 134             uint32_t *dst_line[3];
 135
 136             dst_line[0] = dst + dst_linesize*3*y;
 137             dst_line[1] = dst + dst_linesize*(3*y+1);
 138             dst_line[2] = dst + dst_linesize*(3*y+2);
 139
 140             for (int x = 0; x < width; x++) {
 141                 uint32_t E0, E1, E2, E3, E4, E5, E6, E7, E8;
 142                 uint32_t A, B, C, D, E, F, G, H, I;
 143
 144                 A = src_line[0][FFMAX(x-1, 0)];
 145                 B = src_line[0][x];
 146                 C = src_line[0][FFMIN(x+1, width - 1)];
 147                 D = src_line[1][FFMAX(x-1, 0)];
 148                 E = src_line[1][x];
 149                 F = src_line[1][FFMIN(x+1, width - 1)];
 150                 G = src_line[2][FFMAX(x-1, 0)];
 151                 H = src_line[2][x];
 152                 I = src_line[2][FFMIN(x+1, width - 1)];
 153
 154                 if (B != H && D != F) {
 155                     E0 = D == B ? D : E;
 156                     E1 = (D == B && E != C) || (B == F && E != A) ? B : E;
 157                     E2 = B == F ? F : E;
 158                     E3 = (D == B && E != G) || (D == H && E != A) ? D : E;
 159                     E4 = E;
 160                     E5 = (B == F && E != I) || (H == F && E != C) ? F : E;
 161                     E6 = D == H ? D : E;
 162                     E7 = (D == H && E != I) || (H == F && E != G) ? H : E;
 163                     E8 = H == F ? F : E;
 164                 } else {
 165                     E0 = E;
 166                     E1 = E;
 167                     E2 = E;
 168                     E3 = E;
 169                     E4 = E;
 170                     E5 = E;
 171                     E6 = E;
 172                     E7 = E;
 173                     E8 = E;
 174                 }
 175
 176                 dst_line[0][x*3]   = E0;
 177                 dst_line[0][x*3+1] = E1;
 178                 dst_line[0][x*3+2] = E2;
 179                 dst_line[1][x*3]   = E3;
 180                 dst_line[1][x*3+1] = E4;
 181                 dst_line[1][x*3+2] = E5;
 182                 dst_line[2][x*3]   = E6;
 183                 dst_line[2][x*3+1] = E7;
 184                 dst_line[2][x*3+2] = E8;
 185             }
 186
 187             src_line[0] = src_line[1];
 188             src_line[1] = src_line[2];
 189             src_line[2] = src_line[1];
 190
 191             if (y < height - 2)
 192                 src_line[2] += src_linesize;
 193         }
 194     }
 195
 196     return 0;
 197 }
 198
 199 static int config_output(AVFilterLink *outlink)
 200 {
 201     AVFilterContext *ctx = outlink->src;
 202     EPXContext *s = ctx->priv;
 203     AVFilterLink *inlink = ctx->inputs[0];
 204     const AVPixFmtDescriptor *desc;
 205
 206     desc = av_pix_fmt_desc_get(outlink->format);
 207     if (!desc)
 208         return AVERROR_BUG;
 209
 210     outlink->w = inlink->w * s->n;
 211     outlink->h = inlink->h * s->n;
 212
 213     switch (s->n) {
 214     case 2:
 215         s->epx_slice = epx2_slice;
 216         break;
 217     case 3:
 218         s->epx_slice = epx3_slice;
 219         break;
 220     }
 221
 222     return 0;
 223 }
 224
 225 static const enum AVPixelFormat pix_fmts[] = {
 226     AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
 227     AV_PIX_FMT_NONE,
 228 };
 229
 230 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 231 {
 232     AVFilterContext *ctx = inlink->dst;
 233     AVFilterLink *outlink = ctx->outputs[0];
 234     EPXContext *s = ctx->priv;
 235     ThreadData td;
 236
 237     AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
 238     if (!out) {
 239         av_frame_free(&in);
 240         return AVERROR(ENOMEM);
 241     }
 242
 243     av_frame_copy_props(out, in);
 244
 245     td.in = in, td.out = out;
 246     ff_filter_execute(ctx, s->epx_slice, &td, NULL,
 247                       FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));
 248
 249     av_frame_free(&in);
 250     return ff_filter_frame(outlink, out);
 251 }
 252
 253 static const AVFilterPad inputs[] = {
 254     {
 255         .name         = "default",
 256         .type         = AVMEDIA_TYPE_VIDEO,
 257         .filter_frame = filter_frame,
 258     },
 259 };
 260
 261 static const AVFilterPad outputs[] = {
 262     {
 263         .name         = "default",
 264         .type         = AVMEDIA_TYPE_VIDEO,
 265         .config_props = config_output,
 266     },
 267 };
 268
 269 const AVFilter ff_vf_epx = {
 270     .name          = "epx",
 271     .description   = NULL_IF_CONFIG_SMALL("Scale the input using EPX algorithm."),
 272     FILTER_INPUTS(inputs),
 273     FILTER_OUTPUTS(outputs),
 274     FILTER_PIXFMTS_ARRAY(pix_fmts),
 275     .priv_size     = sizeof(EPXContext),
 276     .priv_class    = &epx_class,
 277     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 278 };