LCOV - code coverage report
Current view: top level - libavfilter - vf_stack.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 96 111 86.5 %
Date: 2017-12-10 21:22:29 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2015 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/avstring.h"
      22             : #include "libavutil/imgutils.h"
      23             : #include "libavutil/opt.h"
      24             : #include "libavutil/pixdesc.h"
      25             : 
      26             : #include "avfilter.h"
      27             : #include "formats.h"
      28             : #include "internal.h"
      29             : #include "framesync.h"
      30             : #include "video.h"
      31             : 
      32             : typedef struct StackContext {
      33             :     const AVClass *class;
      34             :     const AVPixFmtDescriptor *desc;
      35             :     int nb_inputs;
      36             :     int shortest;
      37             :     int is_vertical;
      38             :     int nb_planes;
      39             : 
      40             :     AVFrame **frames;
      41             :     FFFrameSync fs;
      42             : } StackContext;
      43             : 
      44           2 : static int query_formats(AVFilterContext *ctx)
      45             : {
      46           2 :     AVFilterFormats *pix_fmts = NULL;
      47             :     int fmt, ret;
      48             : 
      49         368 :     for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) {
      50         366 :         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
      51        1064 :         if (!(desc->flags & AV_PIX_FMT_FLAG_PAL ||
      52         364 :               desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
      53         660 :               desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
      54         326 :             (ret = ff_add_format(&pix_fmts, fmt)) < 0)
      55           0 :             return ret;
      56             :     }
      57             : 
      58           2 :     return ff_set_common_formats(ctx, pix_fmts);
      59             : }
      60             : 
      61           4 : static av_cold int init(AVFilterContext *ctx)
      62             : {
      63           4 :     StackContext *s = ctx->priv;
      64             :     int i, ret;
      65             : 
      66           4 :     if (!strcmp(ctx->filter->name, "vstack"))
      67           2 :         s->is_vertical = 1;
      68             : 
      69           4 :     s->frames = av_calloc(s->nb_inputs, sizeof(*s->frames));
      70           4 :     if (!s->frames)
      71           0 :         return AVERROR(ENOMEM);
      72             : 
      73          24 :     for (i = 0; i < s->nb_inputs; i++) {
      74           8 :         AVFilterPad pad = { 0 };
      75             : 
      76           8 :         pad.type = AVMEDIA_TYPE_VIDEO;
      77           8 :         pad.name = av_asprintf("input%d", i);
      78           8 :         if (!pad.name)
      79           0 :             return AVERROR(ENOMEM);
      80             : 
      81           8 :         if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
      82           0 :             av_freep(&pad.name);
      83           0 :             return ret;
      84             :         }
      85             :     }
      86             : 
      87           4 :     return 0;
      88             : }
      89             : 
      90         100 : static int process_frame(FFFrameSync *fs)
      91             : {
      92         100 :     AVFilterContext *ctx = fs->parent;
      93         100 :     AVFilterLink *outlink = ctx->outputs[0];
      94         100 :     StackContext *s = fs->opaque;
      95         100 :     AVFrame **in = s->frames;
      96             :     AVFrame *out;
      97         100 :     int i, p, ret, offset[4] = { 0 };
      98             : 
      99         300 :     for (i = 0; i < s->nb_inputs; i++) {
     100         200 :         if ((ret = ff_framesync_get_frame(&s->fs, i, &in[i], 0)) < 0)
     101           0 :             return ret;
     102             :     }
     103             : 
     104         100 :     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
     105         100 :     if (!out)
     106           0 :         return AVERROR(ENOMEM);
     107         100 :     out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, outlink->time_base);
     108         100 :     out->sample_aspect_ratio = outlink->sample_aspect_ratio;
     109             : 
     110         300 :     for (i = 0; i < s->nb_inputs; i++) {
     111         200 :         AVFilterLink *inlink = ctx->inputs[i];
     112             :         int linesize[4];
     113             :         int height[4];
     114             : 
     115         200 :         if ((ret = av_image_fill_linesizes(linesize, inlink->format, inlink->w)) < 0) {
     116           0 :             av_frame_free(&out);
     117           0 :             return ret;
     118             :         }
     119             : 
     120         200 :         height[1] = height[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
     121         200 :         height[0] = height[3] = inlink->h;
     122             : 
     123         800 :         for (p = 0; p < s->nb_planes; p++) {
     124         600 :             if (s->is_vertical) {
     125         900 :                 av_image_copy_plane(out->data[p] + offset[p] * out->linesize[p],
     126         300 :                                     out->linesize[p],
     127         300 :                                     in[i]->data[p],
     128         300 :                                     in[i]->linesize[p],
     129             :                                     linesize[p], height[p]);
     130         300 :                 offset[p] += height[p];
     131             :             } else {
     132         900 :                 av_image_copy_plane(out->data[p] + offset[p],
     133         300 :                                     out->linesize[p],
     134         300 :                                     in[i]->data[p],
     135         300 :                                     in[i]->linesize[p],
     136             :                                     linesize[p], height[p]);
     137         300 :                 offset[p] += linesize[p];
     138             :             }
     139             :         }
     140             :     }
     141             : 
     142         100 :     return ff_filter_frame(outlink, out);
     143             : }
     144             : 
     145           2 : static int config_output(AVFilterLink *outlink)
     146             : {
     147           2 :     AVFilterContext *ctx = outlink->src;
     148           2 :     StackContext *s = ctx->priv;
     149           2 :     AVRational time_base = ctx->inputs[0]->time_base;
     150           2 :     AVRational frame_rate = ctx->inputs[0]->frame_rate;
     151           2 :     AVRational sar = ctx->inputs[0]->sample_aspect_ratio;
     152           2 :     int height = ctx->inputs[0]->h;
     153           2 :     int width = ctx->inputs[0]->w;
     154             :     FFFrameSyncIn *in;
     155             :     int i, ret;
     156             : 
     157           2 :     if (s->is_vertical) {
     158           2 :         for (i = 1; i < s->nb_inputs; i++) {
     159           1 :             if (ctx->inputs[i]->w != width) {
     160           0 :                 av_log(ctx, AV_LOG_ERROR, "Input %d width %d does not match input %d width %d.\n", i, ctx->inputs[i]->w, 0, width);
     161           0 :                 return AVERROR(EINVAL);
     162             :             }
     163           1 :             height += ctx->inputs[i]->h;
     164             :         }
     165             :     } else {
     166           2 :         for (i = 1; i < s->nb_inputs; i++) {
     167           1 :             if (ctx->inputs[i]->h != height) {
     168           0 :                 av_log(ctx, AV_LOG_ERROR, "Input %d height %d does not match input %d height %d.\n", i, ctx->inputs[i]->h, 0, height);
     169           0 :                 return AVERROR(EINVAL);
     170             :             }
     171           1 :             width += ctx->inputs[i]->w;
     172             :         }
     173             :     }
     174             : 
     175           2 :     s->desc = av_pix_fmt_desc_get(outlink->format);
     176           2 :     if (!s->desc)
     177           0 :         return AVERROR_BUG;
     178           2 :     s->nb_planes = av_pix_fmt_count_planes(outlink->format);
     179             : 
     180           2 :     outlink->w          = width;
     181           2 :     outlink->h          = height;
     182           2 :     outlink->time_base  = time_base;
     183           2 :     outlink->frame_rate = frame_rate;
     184           2 :     outlink->sample_aspect_ratio = sar;
     185             : 
     186           2 :     if ((ret = ff_framesync_init(&s->fs, ctx, s->nb_inputs)) < 0)
     187           0 :         return ret;
     188             : 
     189           2 :     in = s->fs.in;
     190           2 :     s->fs.opaque = s;
     191           2 :     s->fs.on_event = process_frame;
     192             : 
     193           6 :     for (i = 0; i < s->nb_inputs; i++) {
     194           4 :         AVFilterLink *inlink = ctx->inputs[i];
     195             : 
     196           4 :         in[i].time_base = inlink->time_base;
     197           4 :         in[i].sync   = 1;
     198           4 :         in[i].before = EXT_STOP;
     199           4 :         in[i].after  = s->shortest ? EXT_STOP : EXT_INFINITY;
     200             :     }
     201             : 
     202           2 :     return ff_framesync_configure(&s->fs);
     203             : }
     204             : 
     205           4 : static av_cold void uninit(AVFilterContext *ctx)
     206             : {
     207           4 :     StackContext *s = ctx->priv;
     208             :     int i;
     209             : 
     210           4 :     ff_framesync_uninit(&s->fs);
     211           4 :     av_freep(&s->frames);
     212             : 
     213          12 :     for (i = 0; i < ctx->nb_inputs; i++)
     214           8 :         av_freep(&ctx->input_pads[i].name);
     215           4 : }
     216             : 
     217         302 : static int activate(AVFilterContext *ctx)
     218             : {
     219         302 :     StackContext *s = ctx->priv;
     220         302 :     return ff_framesync_activate(&s->fs);
     221             : }
     222             : 
     223             : #define OFFSET(x) offsetof(StackContext, x)
     224             : #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
     225             : static const AVOption stack_options[] = {
     226             :     { "inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64=2}, 2, INT_MAX, .flags = FLAGS },
     227             :     { "shortest", "force termination when the shortest input terminates", OFFSET(shortest), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, .flags = FLAGS },
     228             :     { NULL },
     229             : };
     230             : 
     231             : static const AVFilterPad outputs[] = {
     232             :     {
     233             :         .name          = "default",
     234             :         .type          = AVMEDIA_TYPE_VIDEO,
     235             :         .config_props  = config_output,
     236             :     },
     237             :     { NULL }
     238             : };
     239             : 
     240             : #if CONFIG_HSTACK_FILTER
     241             : 
     242             : #define hstack_options stack_options
     243             : AVFILTER_DEFINE_CLASS(hstack);
     244             : 
     245             : AVFilter ff_vf_hstack = {
     246             :     .name          = "hstack",
     247             :     .description   = NULL_IF_CONFIG_SMALL("Stack video inputs horizontally."),
     248             :     .priv_size     = sizeof(StackContext),
     249             :     .priv_class    = &hstack_class,
     250             :     .query_formats = query_formats,
     251             :     .outputs       = outputs,
     252             :     .init          = init,
     253             :     .uninit        = uninit,
     254             :     .activate      = activate,
     255             :     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
     256             : };
     257             : 
     258             : #endif /* CONFIG_HSTACK_FILTER */
     259             : 
     260             : #if CONFIG_VSTACK_FILTER
     261             : 
     262             : #define vstack_options stack_options
     263             : AVFILTER_DEFINE_CLASS(vstack);
     264             : 
     265             : AVFilter ff_vf_vstack = {
     266             :     .name          = "vstack",
     267             :     .description   = NULL_IF_CONFIG_SMALL("Stack video inputs vertically."),
     268             :     .priv_size     = sizeof(StackContext),
     269             :     .priv_class    = &vstack_class,
     270             :     .query_formats = query_formats,
     271             :     .outputs       = outputs,
     272             :     .init          = init,
     273             :     .uninit        = uninit,
     274             :     .activate      = activate,
     275             :     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
     276             : };
     277             : 
     278             : #endif /* CONFIG_VSTACK_FILTER */

Generated by: LCOV version 1.13