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 = av_fopen_utf8(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 *formats = NULL;
  81     int ret;
  82
  83     ret = ff_formats_pixdesc_filter(&formats, 0,
  84                                     AV_PIX_FMT_FLAG_HWACCEL |
  85                                     AV_PIX_FMT_FLAG_BITSTREAM |
  86                                     AV_PIX_FMT_FLAG_PAL);
  87     if (ret < 0)
  88         return ret;
  89     return ff_set_common_formats(ctx, formats);
  90 }
  91
  92 static int config_input(AVFilterLink *inlink)
  93 {
  94     FieldHintContext *s = inlink->dst->priv;
  95     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
  96     int ret;
  97
  98     if ((ret = av_image_fill_linesizes(s->planewidth, inlink->format, inlink->w)) < 0)
  99         return ret;
 100
 101     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
 102     s->planeheight[0] = s->planeheight[3] = inlink->h;
 103
 104     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
 105
 106     return 0;
 107 }
 108
 109 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 110 {
 111     AVFilterContext *ctx = inlink->dst;
 112     AVFilterLink *outlink = ctx->outputs[0];
 113     FieldHintContext *s = ctx->priv;
 114     AVFrame *out, *top, *bottom;
 115     char buf[1024] = { 0 };
 116     int64_t tf, bf;
 117     int tfactor = 0, bfactor = 1;
 118     char hint = '=', field = '=';
 119     int p;
 120
 121     av_frame_free(&s->frame[0]);
 122     s->frame[0] = s->frame[1];
 123     s->frame[1] = s->frame[2];
 124     s->frame[2] = in;
 125     if (!s->frame[1])
 126         return 0;
 127     else if (!s->frame[0]) {
 128         s->frame[0] = av_frame_clone(s->frame[1]);
 129         if (!s->frame[0])
 130             return AVERROR(ENOMEM);
 131     }
 132
 133     while (1) {
 134         if (fgets(buf, sizeof(buf)-1, s->hint)) {
 135             s->line++;
 136             if (buf[0] == '#' || buf[0] == ';') {
 137                 continue;
 138             } else if (sscanf(buf, "%"PRId64",%"PRId64" %c %c", &tf, &bf, &hint, &field) == 4) {
 139                 ;
 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 (field) {
 189     case 'b':
 190         tfactor = 1;
 191         top = bottom;
 192         break;
 193     case 't':
 194         bfactor = 0;
 195         bottom = top;
 196         break;
 197     case '=':
 198         break;
 199     default:
 200         av_log(ctx, AV_LOG_ERROR, "Invalid field: %c.\n", field);
 201         av_frame_free(&out);
 202         return AVERROR(EINVAL);
 203     }
 204
 205     switch (hint) {
 206     case '+':
 207         out->interlaced_frame = 1;
 208         break;
 209     case '-':
 210         out->interlaced_frame = 0;
 211         break;
 212     case '=':
 213         break;
 214     case 'b':
 215         tfactor = 1;
 216         top = bottom;
 217         break;
 218     case 't':
 219         bfactor = 0;
 220         bottom = top;
 221         break;
 222     default:
 223         av_log(ctx, AV_LOG_ERROR, "Invalid hint: %c.\n", hint);
 224         av_frame_free(&out);
 225         return AVERROR(EINVAL);
 226     }
 227
 228     for (p = 0; p < s->nb_planes; p++) {
 229         av_image_copy_plane(out->data[p],
 230                             out->linesize[p] * 2,
 231                             top->data[p] + tfactor * top->linesize[p],
 232                             top->linesize[p] * 2,
 233                             s->planewidth[p],
 234                             (s->planeheight[p] + 1) / 2);
 235         av_image_copy_plane(out->data[p] + out->linesize[p],
 236                             out->linesize[p] * 2,
 237                             bottom->data[p] + bfactor * bottom->linesize[p],
 238                             bottom->linesize[p] * 2,
 239                             s->planewidth[p],
 240                             (s->planeheight[p] + 1) / 2);
 241     }
 242
 243     return ff_filter_frame(outlink, out);
 244 }
 245
 246 static int request_frame(AVFilterLink *outlink)
 247 {
 248     AVFilterContext *ctx = outlink->src;
 249     FieldHintContext *s = ctx->priv;
 250     int ret;
 251
 252     if (s->eof)
 253         return AVERROR_EOF;
 254
 255     ret = ff_request_frame(ctx->inputs[0]);
 256     if (ret == AVERROR_EOF && s->frame[2]) {
 257         AVFrame *next = av_frame_clone(s->frame[2]);
 258         if (!next)
 259             return AVERROR(ENOMEM);
 260         ret = filter_frame(ctx->inputs[0], next);
 261         s->eof = 1;
 262     }
 263
 264     return ret;
 265 }
 266
 267 static av_cold void uninit(AVFilterContext *ctx)
 268 {
 269     FieldHintContext *s = ctx->priv;
 270
 271     if (s->hint)
 272         fclose(s->hint);
 273     s->hint = NULL;
 274
 275     av_frame_free(&s->frame[0]);
 276     av_frame_free(&s->frame[1]);
 277     av_frame_free(&s->frame[2]);
 278 }
 279
 280 static const AVFilterPad inputs[] = {
 281     {
 282         .name         = "default",
 283         .type         = AVMEDIA_TYPE_VIDEO,
 284         .config_props = config_input,
 285         .filter_frame = filter_frame,
 286     },
 287     { NULL }
 288 };
 289
 290 static const AVFilterPad outputs[] = {
 291     {
 292         .name          = "default",
 293         .type          = AVMEDIA_TYPE_VIDEO,
 294         .request_frame = request_frame,
 295     },
 296     { NULL }
 297 };
 298
 299 const AVFilter ff_vf_fieldhint = {
 300     .name          = "fieldhint",
 301     .description   = NULL_IF_CONFIG_SMALL("Field matching using hints."),
 302     .priv_size     = sizeof(FieldHintContext),
 303     .priv_class    = &fieldhint_class,
 304     .init          = init,
 305     .uninit        = uninit,
 306     .query_formats = query_formats,
 307     .inputs        = inputs,
 308     .outputs       = outputs,
 309 };