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

   1 /*
   2  * Copyright (c) 2020 Nicolas George
   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/imgutils.h"
  22 #include "libavutil/opt.h"
  23 #include "libavutil/pixdesc.h"
  24 #include "avfilter.h"
  25 #include "formats.h"
  26 #include "filters.h"
  27
  28 typedef struct UntileContext {
  29     const AVClass *class;
  30     unsigned w, h;
  31     unsigned current;
  32     unsigned nb_frames;
  33     AVFrame *frame;
  34     const AVPixFmtDescriptor *desc;
  35     int64_t dpts, pts;
  36     int max_step[4];
  37 } UntileContext;
  38
  39 #define OFFSET(x) offsetof(UntileContext, x)
  40 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  41
  42 static const AVOption untile_options[] = {
  43     { "layout", "set grid size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE,
  44         {.str = "6x5"}, 0, 0, FLAGS },
  45     { NULL }
  46 };
  47
  48 AVFILTER_DEFINE_CLASS(untile);
  49
  50 static av_cold int init(AVFilterContext *ctx)
  51 {
  52     UntileContext *s = ctx->priv;
  53
  54     if (s->w > UINT_MAX / s->h) {
  55         av_log(ctx, AV_LOG_ERROR, "Tile size %ux%u is insane.\n",
  56                s->w, s->h);
  57         return AVERROR(EINVAL);
  58     }
  59     s->nb_frames = s->w * s->h;
  60     return 0;
  61 }
  62
  63 static int query_formats(AVFilterContext *ctx)
  64 {
  65     AVFilterFormats *formats = NULL;
  66     int ret;
  67
  68     ret = ff_formats_pixdesc_filter(&formats, 0,
  69                                     AV_PIX_FMT_FLAG_HWACCEL |
  70                                     AV_PIX_FMT_FLAG_BITSTREAM |
  71                                     FF_PIX_FMT_FLAG_SW_FLAT_SUB);
  72     if (ret < 0)
  73         return ret;
  74     return ff_set_common_formats(ctx, formats);
  75 }
  76
  77 static int config_output(AVFilterLink *outlink)
  78 {
  79     AVFilterContext *ctx = outlink->src;
  80     UntileContext *s = ctx->priv;
  81     AVFilterLink *inlink = ctx->inputs[0];
  82     AVRational dt;
  83
  84     s->desc = av_pix_fmt_desc_get(outlink->format);
  85     if (inlink->w % (s->w << s->desc->log2_chroma_w) ||
  86         inlink->h % (s->h << s->desc->log2_chroma_h)) {
  87         av_log(ctx, AV_LOG_ERROR,
  88                "Input resolution %ux%u not multiple of layout %ux%u.\n",
  89                inlink->w, inlink->h, s->w, s->h);
  90         return AVERROR(EINVAL);
  91     }
  92     outlink->w = inlink->w / s->w;
  93     outlink->h = inlink->h / s->h;
  94     outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
  95     outlink->frame_rate = av_mul_q(inlink->frame_rate, av_make_q(s->nb_frames, 1));
  96     if (outlink->frame_rate.num)
  97         dt = av_inv_q(outlink->frame_rate);
  98     else
  99         dt = av_mul_q(inlink->time_base, av_make_q(1, s->nb_frames));
 100     outlink->time_base = av_gcd_q(inlink->time_base, dt, AV_TIME_BASE / 2, AV_TIME_BASE_Q);
 101     s->dpts = av_rescale_q(1, dt, outlink->time_base);
 102     av_log(ctx, AV_LOG_VERBOSE, "frame interval: %"PRId64"*%d/%d\n",
 103            s->dpts, dt.num, dt.den);
 104     av_image_fill_max_pixsteps(s->max_step, NULL, s->desc);
 105     return 0;
 106 }
 107
 108 static int activate(AVFilterContext *ctx)
 109 {
 110     UntileContext *s = ctx->priv;
 111     AVFilterLink *inlink = ctx->inputs[0];
 112     AVFilterLink *outlink = ctx->outputs[0];
 113     AVFrame *out;
 114     int i, x, y, ret;
 115
 116     FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
 117     if (!s->frame) {
 118         ret = ff_inlink_consume_frame(inlink, &s->frame);
 119         if (ret < 0)
 120             return ret;
 121         if (ret)
 122             s->pts = av_rescale_q(s->frame->pts, inlink->time_base, outlink->time_base);
 123     }
 124     if (s->frame) {
 125         if (s->current == s->nb_frames - 1) {
 126             out = s->frame;
 127             s->frame = NULL;
 128         } else {
 129             out = av_frame_clone(s->frame);
 130             if (!out)
 131                 return AVERROR(ENOMEM);
 132         }
 133         x = outlink->w * (s->current % s->w);
 134         y = outlink->h * (s->current / s->w);
 135         out->width = outlink->w;
 136         out->height = outlink->h;
 137         out->data[0] += y * out->linesize[0];
 138         out->data[0] += x * s->max_step[0];
 139         if (!(s->desc->flags & AV_PIX_FMT_FLAG_PAL)) {
 140             for (i = 1; i < 3; i ++) {
 141                 if (out->data[i]) {
 142                     out->data[i] += (y >> s->desc->log2_chroma_w) * out->linesize[i];
 143                     out->data[i] += (x >> s->desc->log2_chroma_h) * s->max_step[i];
 144                 }
 145             }
 146         }
 147         if (out->data[3]) {
 148             out->data[3] += y * out->linesize[3];
 149             out->data[3] += x * s->max_step[3];
 150         }
 151         out->pts = s->pts;
 152         s->pts += s->dpts;
 153         if (++s->current == s->nb_frames)
 154             s->current = 0;
 155         return ff_filter_frame(outlink, out);
 156     }
 157     FF_FILTER_FORWARD_STATUS(inlink, outlink);
 158     FF_FILTER_FORWARD_WANTED(outlink, inlink);
 159     return FFERROR_NOT_READY;
 160
 161 }
 162
 163 static av_cold void uninit(AVFilterContext *ctx)
 164 {
 165     UntileContext *s = ctx->priv;
 166
 167     av_frame_free(&s->frame);
 168 }
 169
 170 static const AVFilterPad untile_inputs[] = {
 171     {
 172         .name         = "default",
 173         .type         = AVMEDIA_TYPE_VIDEO,
 174     },
 175     { NULL }
 176 };
 177
 178 static const AVFilterPad untile_outputs[] = {
 179     {
 180         .name          = "default",
 181         .type          = AVMEDIA_TYPE_VIDEO,
 182         .config_props  = config_output,
 183     },
 184     { NULL }
 185 };
 186
 187 AVFilter ff_vf_untile = {
 188     .name          = "untile",
 189     .description   = NULL_IF_CONFIG_SMALL("Untile a frame into a sequence of frames."),
 190     .init          = init,
 191     .uninit        = uninit,
 192     .query_formats = query_formats,
 193     .activate      = activate,
 194     .priv_size     = sizeof(UntileContext),
 195     .inputs        = untile_inputs,
 196     .outputs       = untile_outputs,
 197     .priv_class    = &untile_class,
 198 };