0,0 → 1,240 |
/* |
* Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org> |
* |
* This file is part of FFmpeg. |
* |
* FFmpeg is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* FFmpeg is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
* GNU Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with FFmpeg; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
*/ |
|
/** |
* @file |
* Stream (de)synchronization filter |
*/ |
|
#include "libavutil/eval.h" |
#include "libavutil/opt.h" |
#include "avfilter.h" |
#include "audio.h" |
#include "internal.h" |
|
#define QUEUE_SIZE 16 |
|
static const char * const var_names[] = { |
"b1", "b2", |
"s1", "s2", |
"t1", "t2", |
NULL |
}; |
|
enum var_name { |
VAR_B1, VAR_B2, |
VAR_S1, VAR_S2, |
VAR_T1, VAR_T2, |
VAR_NB |
}; |
|
typedef struct { |
const AVClass *class; |
AVExpr *expr; |
char *expr_str; |
double var_values[VAR_NB]; |
struct buf_queue { |
AVFrame *buf[QUEUE_SIZE]; |
unsigned tail, nb; |
/* buf[tail] is the oldest, |
buf[(tail + nb) % QUEUE_SIZE] is where the next is added */ |
} queue[2]; |
int req[2]; |
int next_out; |
int eof; /* bitmask, one bit for each stream */ |
} AStreamSyncContext; |
|
#define OFFSET(x) offsetof(AStreamSyncContext, x) |
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM |
static const AVOption astreamsync_options[] = { |
{ "expr", "set stream selection expression", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "t1-t2" }, .flags = FLAGS }, |
{ "e", "set stream selection expression", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "t1-t2" }, .flags = FLAGS }, |
{ NULL } |
}; |
|
AVFILTER_DEFINE_CLASS(astreamsync); |
|
static av_cold int init(AVFilterContext *ctx) |
{ |
AStreamSyncContext *as = ctx->priv; |
int r, i; |
|
r = av_expr_parse(&as->expr, as->expr_str, var_names, |
NULL, NULL, NULL, NULL, 0, ctx); |
if (r < 0) { |
av_log(ctx, AV_LOG_ERROR, "Error in expression \"%s\"\n", as->expr_str); |
return r; |
} |
for (i = 0; i < 42; i++) |
av_expr_eval(as->expr, as->var_values, NULL); /* exercize prng */ |
return 0; |
} |
|
static int query_formats(AVFilterContext *ctx) |
{ |
int i; |
AVFilterFormats *formats, *rates; |
AVFilterChannelLayouts *layouts; |
|
for (i = 0; i < 2; i++) { |
formats = ctx->inputs[i]->in_formats; |
ff_formats_ref(formats, &ctx->inputs[i]->out_formats); |
ff_formats_ref(formats, &ctx->outputs[i]->in_formats); |
rates = ff_all_samplerates(); |
ff_formats_ref(rates, &ctx->inputs[i]->out_samplerates); |
ff_formats_ref(rates, &ctx->outputs[i]->in_samplerates); |
layouts = ctx->inputs[i]->in_channel_layouts; |
ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts); |
ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts); |
} |
return 0; |
} |
|
static int config_output(AVFilterLink *outlink) |
{ |
AVFilterContext *ctx = outlink->src; |
int id = outlink == ctx->outputs[1]; |
|
outlink->sample_rate = ctx->inputs[id]->sample_rate; |
outlink->time_base = ctx->inputs[id]->time_base; |
return 0; |
} |
|
static int send_out(AVFilterContext *ctx, int out_id) |
{ |
AStreamSyncContext *as = ctx->priv; |
struct buf_queue *queue = &as->queue[out_id]; |
AVFrame *buf = queue->buf[queue->tail]; |
int ret; |
|
queue->buf[queue->tail] = NULL; |
as->var_values[VAR_B1 + out_id]++; |
as->var_values[VAR_S1 + out_id] += buf->nb_samples; |
if (buf->pts != AV_NOPTS_VALUE) |
as->var_values[VAR_T1 + out_id] = |
av_q2d(ctx->outputs[out_id]->time_base) * buf->pts; |
as->var_values[VAR_T1 + out_id] += buf->nb_samples / |
(double)ctx->inputs[out_id]->sample_rate; |
ret = ff_filter_frame(ctx->outputs[out_id], buf); |
queue->nb--; |
queue->tail = (queue->tail + 1) % QUEUE_SIZE; |
if (as->req[out_id]) |
as->req[out_id]--; |
return ret; |
} |
|
static void send_next(AVFilterContext *ctx) |
{ |
AStreamSyncContext *as = ctx->priv; |
int i; |
|
while (1) { |
if (!as->queue[as->next_out].nb) |
break; |
send_out(ctx, as->next_out); |
if (!as->eof) |
as->next_out = av_expr_eval(as->expr, as->var_values, NULL) >= 0; |
} |
for (i = 0; i < 2; i++) |
if (as->queue[i].nb == QUEUE_SIZE) |
send_out(ctx, i); |
} |
|
static int request_frame(AVFilterLink *outlink) |
{ |
AVFilterContext *ctx = outlink->src; |
AStreamSyncContext *as = ctx->priv; |
int id = outlink == ctx->outputs[1]; |
|
as->req[id]++; |
while (as->req[id] && !(as->eof & (1 << id))) { |
if (as->queue[as->next_out].nb) { |
send_next(ctx); |
} else { |
as->eof |= 1 << as->next_out; |
ff_request_frame(ctx->inputs[as->next_out]); |
if (as->eof & (1 << as->next_out)) |
as->next_out = !as->next_out; |
} |
} |
return 0; |
} |
|
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) |
{ |
AVFilterContext *ctx = inlink->dst; |
AStreamSyncContext *as = ctx->priv; |
int id = inlink == ctx->inputs[1]; |
|
as->queue[id].buf[(as->queue[id].tail + as->queue[id].nb++) % QUEUE_SIZE] = |
insamples; |
as->eof &= ~(1 << id); |
send_next(ctx); |
return 0; |
} |
|
static av_cold void uninit(AVFilterContext *ctx) |
{ |
AStreamSyncContext *as = ctx->priv; |
|
av_expr_free(as->expr); |
as->expr = NULL; |
} |
|
static const AVFilterPad astreamsync_inputs[] = { |
{ |
.name = "in1", |
.type = AVMEDIA_TYPE_AUDIO, |
.filter_frame = filter_frame, |
},{ |
.name = "in2", |
.type = AVMEDIA_TYPE_AUDIO, |
.filter_frame = filter_frame, |
}, |
{ NULL } |
}; |
|
static const AVFilterPad astreamsync_outputs[] = { |
{ |
.name = "out1", |
.type = AVMEDIA_TYPE_AUDIO, |
.config_props = config_output, |
.request_frame = request_frame, |
},{ |
.name = "out2", |
.type = AVMEDIA_TYPE_AUDIO, |
.config_props = config_output, |
.request_frame = request_frame, |
}, |
{ NULL } |
}; |
|
AVFilter avfilter_af_astreamsync = { |
.name = "astreamsync", |
.description = NULL_IF_CONFIG_SMALL("Copy two streams of audio data " |
"in a configurable order."), |
.priv_size = sizeof(AStreamSyncContext), |
.init = init, |
.uninit = uninit, |
.query_formats = query_formats, |
.inputs = astreamsync_inputs, |
.outputs = astreamsync_outputs, |
.priv_class = &astreamsync_class, |
}; |