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

   1 /*
   2  * Copyright (c) 2013 Stefano Sabatini
   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 /**
  22  * @file
  23  * audio and video interleaver
  24  */
  25
  26 #include "libavutil/avassert.h"
  27 #include "libavutil/avstring.h"
  28 #include "libavutil/opt.h"
  29
  30 #define FF_INTERNAL_FIELDS 1
  31 #include "framequeue.h"
  32
  33 #include "avfilter.h"
  34 #include "bufferqueue.h"
  35 #include "formats.h"
  36 #include "internal.h"
  37 #include "audio.h"
  38 #include "video.h"
  39
  40 typedef struct {
  41     const AVClass *class;
  42     int nb_inputs;
  43     struct FFBufQueue *queues;
  44 } InterleaveContext;
  45
  46 #define OFFSET(x) offsetof(InterleaveContext, x)
  47
  48 #define DEFINE_OPTIONS(filt_name, flags_)                           \
  49 static const AVOption filt_name##_options[] = {                     \
  50    { "nb_inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
  51    { "n",         "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
  52    { NULL }                                                         \
  53 }
  54
  55 inline static int push_frame(AVFilterContext *ctx)
  56 {
  57     InterleaveContext *s = ctx->priv;
  58     AVFrame *frame;
  59     int i, queue_idx = -1;
  60     int64_t pts_min = INT64_MAX;
  61
  62     /* look for oldest frame */
  63     for (i = 0; i < ctx->nb_inputs; i++) {
  64         struct FFBufQueue *q = &s->queues[i];
  65
  66         if (!q->available && !ctx->inputs[i]->status_out)
  67             return 0;
  68         if (q->available) {
  69             frame = ff_bufqueue_peek(q, 0);
  70             if (frame->pts < pts_min) {
  71                 pts_min = frame->pts;
  72                 queue_idx = i;
  73             }
  74         }
  75     }
  76
  77     /* all inputs are closed */
  78     if (queue_idx < 0)
  79         return AVERROR_EOF;
  80
  81     frame = ff_bufqueue_get(&s->queues[queue_idx]);
  82     av_log(ctx, AV_LOG_DEBUG, "queue:%d -> frame time:%f\n",
  83            queue_idx, frame->pts * av_q2d(AV_TIME_BASE_Q));
  84     return ff_filter_frame(ctx->outputs[0], frame);
  85 }
  86
  87 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
  88 {
  89     AVFilterContext *ctx = inlink->dst;
  90     InterleaveContext *s = ctx->priv;
  91     unsigned in_no = FF_INLINK_IDX(inlink);
  92
  93     if (frame->pts == AV_NOPTS_VALUE) {
  94         av_log(ctx, AV_LOG_WARNING,
  95                "NOPTS value for input frame cannot be accepted, frame discarded\n");
  96         av_frame_free(&frame);
  97         return AVERROR_INVALIDDATA;
  98     }
  99
 100     /* queue frame */
 101     frame->pts = av_rescale_q(frame->pts, inlink->time_base, AV_TIME_BASE_Q);
 102     av_log(ctx, AV_LOG_DEBUG, "frame pts:%f -> queue idx:%d available:%d\n",
 103            frame->pts * av_q2d(AV_TIME_BASE_Q), in_no, s->queues[in_no].available);
 104     ff_bufqueue_add(ctx, &s->queues[in_no], frame);
 105
 106     return push_frame(ctx);
 107 }
 108
 109 static av_cold int init(AVFilterContext *ctx)
 110 {
 111     InterleaveContext *s = ctx->priv;
 112     const AVFilterPad *outpad = &ctx->filter->outputs[0];
 113     int i;
 114
 115     s->queues = av_calloc(s->nb_inputs, sizeof(s->queues[0]));
 116     if (!s->queues)
 117         return AVERROR(ENOMEM);
 118
 119     for (i = 0; i < s->nb_inputs; i++) {
 120         AVFilterPad inpad = { 0 };
 121
 122         inpad.name = av_asprintf("input%d", i);
 123         if (!inpad.name)
 124             return AVERROR(ENOMEM);
 125         inpad.type         = outpad->type;
 126         inpad.filter_frame = filter_frame;
 127
 128         switch (outpad->type) {
 129         case AVMEDIA_TYPE_VIDEO:
 130             inpad.get_video_buffer = ff_null_get_video_buffer; break;
 131         case AVMEDIA_TYPE_AUDIO:
 132             inpad.get_audio_buffer = ff_null_get_audio_buffer; break;
 133         default:
 134             av_assert0(0);
 135         }
 136         ff_insert_inpad(ctx, i, &inpad);
 137     }
 138
 139     return 0;
 140 }
 141
 142 static av_cold void uninit(AVFilterContext *ctx)
 143 {
 144     InterleaveContext *s = ctx->priv;
 145     int i;
 146
 147     for (i = 0; i < ctx->nb_inputs; i++) {
 148         ff_bufqueue_discard_all(&s->queues[i]);
 149         av_freep(&s->queues[i]);
 150         av_freep(&ctx->input_pads[i].name);
 151     }
 152 }
 153
 154 static int config_output(AVFilterLink *outlink)
 155 {
 156     AVFilterContext *ctx = outlink->src;
 157     AVFilterLink *inlink0 = ctx->inputs[0];
 158     int i;
 159
 160     if (outlink->type == AVMEDIA_TYPE_VIDEO) {
 161         outlink->time_base           = AV_TIME_BASE_Q;
 162         outlink->w                   = inlink0->w;
 163         outlink->h                   = inlink0->h;
 164         outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
 165         outlink->format              = inlink0->format;
 166         outlink->frame_rate = (AVRational) {1, 0};
 167         for (i = 1; i < ctx->nb_inputs; i++) {
 168             AVFilterLink *inlink = ctx->inputs[i];
 169
 170             if (outlink->w                       != inlink->w                       ||
 171                 outlink->h                       != inlink->h                       ||
 172                 outlink->sample_aspect_ratio.num != inlink->sample_aspect_ratio.num ||
 173                 outlink->sample_aspect_ratio.den != inlink->sample_aspect_ratio.den) {
 174                 av_log(ctx, AV_LOG_ERROR, "Parameters for input link %s "
 175                        "(size %dx%d, SAR %d:%d) do not match the corresponding "
 176                        "output link parameters (%dx%d, SAR %d:%d)\n",
 177                        ctx->input_pads[i].name, inlink->w, inlink->h,
 178                        inlink->sample_aspect_ratio.num,
 179                        inlink->sample_aspect_ratio.den,
 180                        outlink->w, outlink->h,
 181                        outlink->sample_aspect_ratio.num,
 182                        outlink->sample_aspect_ratio.den);
 183                 return AVERROR(EINVAL);
 184             }
 185         }
 186     }
 187     return 0;
 188 }
 189
 190 static int request_frame(AVFilterLink *outlink)
 191 {
 192     AVFilterContext *ctx = outlink->src;
 193     InterleaveContext *s = ctx->priv;
 194     int i, ret;
 195
 196     for (i = 0; i < ctx->nb_inputs; i++) {
 197         if (!s->queues[i].available && !ctx->inputs[i]->status_out) {
 198             ret = ff_request_frame(ctx->inputs[i]);
 199             if (ret != AVERROR_EOF)
 200                 return ret;
 201         }
 202     }
 203
 204     return push_frame(ctx);
 205 }
 206
 207 #if CONFIG_INTERLEAVE_FILTER
 208
 209 DEFINE_OPTIONS(interleave, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
 210 AVFILTER_DEFINE_CLASS(interleave);
 211
 212 static const AVFilterPad interleave_outputs[] = {
 213     {
 214         .name          = "default",
 215         .type          = AVMEDIA_TYPE_VIDEO,
 216         .config_props  = config_output,
 217         .request_frame = request_frame,
 218     },
 219     { NULL }
 220 };
 221
 222 AVFilter ff_vf_interleave = {
 223     .name        = "interleave",
 224     .description = NULL_IF_CONFIG_SMALL("Temporally interleave video inputs."),
 225     .priv_size   = sizeof(InterleaveContext),
 226     .init        = init,
 227     .uninit      = uninit,
 228     .outputs     = interleave_outputs,
 229     .priv_class  = &interleave_class,
 230     .flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
 231 };
 232
 233 #endif
 234
 235 #if CONFIG_AINTERLEAVE_FILTER
 236
 237 DEFINE_OPTIONS(ainterleave, AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
 238 AVFILTER_DEFINE_CLASS(ainterleave);
 239
 240 static const AVFilterPad ainterleave_outputs[] = {
 241     {
 242         .name          = "default",
 243         .type          = AVMEDIA_TYPE_AUDIO,
 244         .config_props  = config_output,
 245         .request_frame = request_frame,
 246     },
 247     { NULL }
 248 };
 249
 250 AVFilter ff_af_ainterleave = {
 251     .name        = "ainterleave",
 252     .description = NULL_IF_CONFIG_SMALL("Temporally interleave audio inputs."),
 253     .priv_size   = sizeof(InterleaveContext),
 254     .init        = init,
 255     .uninit      = uninit,
 256     .outputs     = ainterleave_outputs,
 257     .priv_class  = &ainterleave_class,
 258     .flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
 259 };
 260
 261 #endif