git.sesse.net Git - ffmpeg/blob - libavfilter/vf_fieldhint.c

   1 /*
   2  * Copyright (c) 2016 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/avassert.h"
  22 #include "libavutil/imgutils.h"
  23 #include "libavutil/internal.h"
  24 #include "libavutil/opt.h"
  25 #include "libavutil/pixdesc.h"
  26 #include "avfilter.h"
  27 #include "internal.h"
  28 #include "video.h"
  29
  30 typedef struct FieldHintContext {
  31     const AVClass *class;
  32
  33     char *hint_file_str;
  34     FILE *hint;
  35     int mode;
  36
  37     AVFrame *frame[3];
  38
  39     int64_t line;
  40     int nb_planes;
  41     int eof;
  42     int planewidth[4];
  43     int planeheight[4];
  44 } FieldHintContext;
  45
  46 #define OFFSET(x) offsetof(FieldHintContext, x)
  47 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  48
  49 static const AVOption fieldhint_options[] = {
  50     { "hint", "set hint file", OFFSET(hint_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
  51     { "mode", "set hint mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "mode" },
  52     {   "absolute", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
  53     {   "relative", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
  54     { NULL }
  55 };
  56
  57 AVFILTER_DEFINE_CLASS(fieldhint);
  58
  59 static av_cold int init(AVFilterContext *ctx)
  60 {
  61     FieldHintContext *s = ctx->priv;
  62     int ret;
  63
  64     if (!s->hint_file_str) {
  65         av_log(ctx, AV_LOG_ERROR, "Hint file must be set.\n");
  66         return AVERROR(EINVAL);
  67     }
  68     s->hint = fopen(s->hint_file_str, "r");
  69     if (!s->hint) {
  70         ret = AVERROR(errno);
  71         av_log(ctx, AV_LOG_ERROR, "%s: %s\n", s->hint_file_str, av_err2str(ret));
  72         return ret;
  73     }
  74
  75     return 0;
  76 }
  77
  78 static int query_formats(AVFilterContext *ctx)
  79 {
  80     AVFilterFormats *pix_fmts = NULL;
  81     int fmt, ret;
  82
  83     for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
  84         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
  85         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
  86               desc->flags & AV_PIX_FMT_FLAG_PAL     ||
  87               desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
  88             (ret = ff_add_format(&pix_fmts, fmt)) < 0)
  89             return ret;
  90     }
  91
  92     return ff_set_common_formats(ctx, pix_fmts);
  93 }
  94
  95 static int config_input(AVFilterLink *inlink)
  96 {
  97     FieldHintContext *s = inlink->dst->priv;
  98     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
  99     int ret;
 100
 101     if ((ret = av_image_fill_linesizes(s->planewidth, inlink->format, inlink->w)) < 0)
 102         return ret;
 103
 104     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
 105     s->planeheight[0] = s->planeheight[3] = inlink->h;
 106
 107     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
 108
 109     return 0;
 110 }
 111
 112 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 113 {
 114     AVFilterContext *ctx = inlink->dst;
 115     AVFilterLink *outlink = ctx->outputs[0];
 116     FieldHintContext *s = ctx->priv;
 117     AVFrame *out, *top, *bottom;
 118     char buf[1024] = { 0 };
 119     int64_t tf, bf;
 120     char hint = '=';
 121     int p;
 122
 123     av_frame_free(&s->frame[0]);
 124     s->frame[0] = s->frame[1];
 125     s->frame[1] = s->frame[2];
 126     s->frame[2] = in;
 127     if (!s->frame[1])
 128         return 0;
 129     else if (!s->frame[0]) {
 130         s->frame[0] = av_frame_clone(s->frame[1]);
 131         if (!s->frame[0])
 132             return AVERROR(ENOMEM);
 133     }
 134
 135     while (1) {
 136         if (fgets(buf, sizeof(buf)-1, s->hint)) {
 137             s->line++;
 138             if (buf[0] == '#' || buf[0] == ';') {
 139                 continue;
 140             } else if (sscanf(buf, "%"PRId64",%"PRId64" %c", &tf, &bf, &hint) == 3) {
 141                 ;
 142             } else if (sscanf(buf, "%"PRId64",%"PRId64"", &tf, &bf) == 2) {
 143                 ;
 144             } else {
 145                 av_log(ctx, AV_LOG_ERROR, "Invalid entry at line %"PRId64".\n", s->line);
 146                 return AVERROR_INVALIDDATA;
 147             }
 148             switch (s->mode) {
 149             case 0:
 150                 if (tf > outlink->frame_count_in + 1 || tf < FFMAX(0, outlink->frame_count_in - 1) ||
 151                     bf > outlink->frame_count_in + 1 || bf < FFMAX(0, outlink->frame_count_in - 1)) {
 152                     av_log(ctx, AV_LOG_ERROR, "Out of range frames %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out);
 153                     return AVERROR_INVALIDDATA;
 154                 }
 155                 break;
 156             case 1:
 157                 if (tf > 1 || tf < -1 ||
 158                     bf > 1 || bf < -1) {
 159                     av_log(ctx, AV_LOG_ERROR, "Out of range %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out);
 160                     return AVERROR_INVALIDDATA;
 161                 }
 162             };
 163             break;
 164         } else {
 165             av_log(ctx, AV_LOG_ERROR, "Missing entry for %"PRId64". input frame.\n", inlink->frame_count_out);
 166             return AVERROR_INVALIDDATA;
 167         }
 168     }
 169
 170     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
 171     if (!out)
 172         return AVERROR(ENOMEM);
 173     av_frame_copy_props(out, s->frame[1]);
 174
 175     switch (s->mode) {
 176     case 0:
 177         top    = s->frame[tf - outlink->frame_count_in + 1];
 178         bottom = s->frame[bf - outlink->frame_count_in + 1];
 179         break;
 180     case 1:
 181         top    = s->frame[1 + tf];
 182         bottom = s->frame[1 + bf];
 183         break;
 184     default:
 185         av_assert0(0);
 186     }
 187
 188     switch (hint) {
 189     case '+':
 190         out->interlaced_frame = 1;
 191         break;
 192     case '-':
 193         out->interlaced_frame = 0;
 194         break;
 195     case '=':
 196         break;
 197     default:
 198         av_log(ctx, AV_LOG_ERROR, "Invalid hint: %c.\n", hint);
 199         av_frame_free(&out);
 200         return AVERROR(EINVAL);
 201     }
 202
 203     for (p = 0; p < s->nb_planes; p++) {
 204         av_image_copy_plane(out->data[p],
 205                             out->linesize[p] * 2,
 206                             top->data[p],
 207                             top->linesize[p] * 2,
 208                             s->planewidth[p],
 209                             (s->planeheight[p] + 1) / 2);
 210         av_image_copy_plane(out->data[p] + out->linesize[p],
 211                             out->linesize[p] * 2,
 212                             bottom->data[p] + bottom->linesize[p],
 213                             bottom->linesize[p] * 2,
 214                             s->planewidth[p],
 215                             (s->planeheight[p] + 1) / 2);
 216     }
 217
 218     return ff_filter_frame(outlink, out);
 219 }
 220
 221 static int request_frame(AVFilterLink *outlink)
 222 {
 223     AVFilterContext *ctx = outlink->src;
 224     FieldHintContext *s = ctx->priv;
 225     int ret;
 226
 227     if (s->eof)
 228         return AVERROR_EOF;
 229
 230     ret = ff_request_frame(ctx->inputs[0]);
 231     if (ret == AVERROR_EOF && s->frame[2]) {
 232         AVFrame *next = av_frame_clone(s->frame[2]);
 233         if (!next)
 234             return AVERROR(ENOMEM);
 235         ret = filter_frame(ctx->inputs[0], next);
 236         s->eof = 1;
 237     }
 238
 239     return ret;
 240 }
 241
 242 static av_cold void uninit(AVFilterContext *ctx)
 243 {
 244     FieldHintContext *s = ctx->priv;
 245
 246     if (s->hint)
 247         fclose(s->hint);
 248     s->hint = NULL;
 249
 250     av_frame_free(&s->frame[0]);
 251     av_frame_free(&s->frame[1]);
 252     av_frame_free(&s->frame[2]);
 253 }
 254
 255 static const AVFilterPad inputs[] = {
 256     {
 257         .name         = "default",
 258         .type         = AVMEDIA_TYPE_VIDEO,
 259         .config_props = config_input,
 260         .filter_frame = filter_frame,
 261     },
 262     { NULL }
 263 };
 264
 265 static const AVFilterPad outputs[] = {
 266     {
 267         .name          = "default",
 268         .type          = AVMEDIA_TYPE_VIDEO,
 269         .request_frame = request_frame,
 270     },
 271     { NULL }
 272 };
 273
 274 AVFilter ff_vf_fieldhint = {
 275     .name          = "fieldhint",
 276     .description   = NULL_IF_CONFIG_SMALL("Field matching using hints."),
 277     .priv_size     = sizeof(FieldHintContext),
 278     .priv_class    = &fieldhint_class,
 279     .init          = init,
 280     .uninit        = uninit,
 281     .query_formats = query_formats,
 282     .inputs        = inputs,
 283     .outputs       = outputs,
 284 };