Commit 82541d83 authored by Nicolas George's avatar Nicolas George

lavfi: merge all filtering code into ff_filter_frame.

parent 765158dd
......@@ -179,114 +179,3 @@ AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
nb_samples, sample_fmt,
channels, channel_layout);
}
static int default_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)
{
return ff_filter_frame(link->dst->outputs[0], frame);
}
int ff_filter_samples_framed(AVFilterLink *link, AVFilterBufferRef *samplesref)
{
int (*filter_frame)(AVFilterLink *, AVFilterBufferRef *);
AVFilterPad *src = link->srcpad;
AVFilterPad *dst = link->dstpad;
int64_t pts;
AVFilterBufferRef *buf_out;
int ret;
FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1);
if (link->closed) {
avfilter_unref_buffer(samplesref);
return AVERROR_EOF;
}
if (!(filter_frame = dst->filter_frame))
filter_frame = default_filter_frame;
av_assert1((samplesref->perms & src->min_perms) == src->min_perms);
samplesref->perms &= ~ src->rej_perms;
/* prepare to copy the samples if the buffer has insufficient permissions */
if ((dst->min_perms & samplesref->perms) != dst->min_perms ||
dst->rej_perms & samplesref->perms) {
av_log(link->dst, AV_LOG_DEBUG,
"Copying audio data in avfilter (have perms %x, need %x, reject %x)\n",
samplesref->perms, link->dstpad->min_perms, link->dstpad->rej_perms);
buf_out = ff_default_get_audio_buffer(link, dst->min_perms,
samplesref->audio->nb_samples);
if (!buf_out) {
avfilter_unref_buffer(samplesref);
return AVERROR(ENOMEM);
}
buf_out->pts = samplesref->pts;
buf_out->audio->sample_rate = samplesref->audio->sample_rate;
/* Copy actual data into new samples buffer */
av_samples_copy(buf_out->extended_data, samplesref->extended_data,
0, 0, samplesref->audio->nb_samples,
av_get_channel_layout_nb_channels(link->channel_layout),
link->format);
avfilter_unref_buffer(samplesref);
} else
buf_out = samplesref;
link->cur_buf = buf_out;
pts = buf_out->pts;
ret = filter_frame(link, buf_out);
ff_update_link_current_pts(link, pts);
return ret;
}
int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
{
int insamples = samplesref->audio->nb_samples, inpos = 0, nb_samples;
AVFilterBufferRef *pbuf = link->partial_buf;
int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
int ret = 0;
av_assert1(samplesref->format == link->format);
av_assert1(samplesref->audio->channels == link->channels);
av_assert1(samplesref->audio->channel_layout == link->channel_layout);
av_assert1(samplesref->audio->sample_rate == link->sample_rate);
if (!link->min_samples ||
(!pbuf &&
insamples >= link->min_samples && insamples <= link->max_samples)) {
return ff_filter_samples_framed(link, samplesref);
}
/* Handle framing (min_samples, max_samples) */
while (insamples) {
if (!pbuf) {
AVRational samples_tb = { 1, link->sample_rate };
int perms = link->dstpad->min_perms | AV_PERM_WRITE;
pbuf = ff_get_audio_buffer(link, perms, link->partial_buf_size);
if (!pbuf) {
av_log(link->dst, AV_LOG_WARNING,
"Samples dropped due to memory allocation failure.\n");
return 0;
}
avfilter_copy_buffer_ref_props(pbuf, samplesref);
pbuf->pts = samplesref->pts +
av_rescale_q(inpos, samples_tb, link->time_base);
pbuf->audio->nb_samples = 0;
}
nb_samples = FFMIN(insamples,
link->partial_buf_size - pbuf->audio->nb_samples);
av_samples_copy(pbuf->extended_data, samplesref->extended_data,
pbuf->audio->nb_samples, inpos,
nb_samples, nb_channels, link->format);
inpos += nb_samples;
insamples -= nb_samples;
pbuf->audio->nb_samples += nb_samples;
if (pbuf->audio->nb_samples >= link->min_samples) {
ret = ff_filter_samples_framed(link, pbuf);
pbuf = NULL;
}
}
avfilter_unref_buffer(samplesref);
link->partial_buf = pbuf;
return ret;
}
......@@ -34,6 +34,8 @@
#include "internal.h"
#include "audio.h"
static int ff_filter_frame_framed(AVFilterLink *link, AVFilterBufferRef *frame);
char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)
{
snprintf(buf, buf_size, "%s%s%s%s%s%s",
......@@ -342,7 +344,7 @@ int ff_request_frame(AVFilterLink *link)
if (ret == AVERROR_EOF && link->partial_buf) {
AVFilterBufferRef *pbuf = link->partial_buf;
link->partial_buf = NULL;
ff_filter_samples_framed(link, pbuf);
ff_filter_frame_framed(link, pbuf);
return 0;
}
if (ret == AVERROR_EOF)
......@@ -631,22 +633,161 @@ enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
return pads[pad_idx].type;
}
static int default_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)
{
return ff_filter_frame(link->dst->outputs[0], frame);
}
static int ff_filter_frame_framed(AVFilterLink *link, AVFilterBufferRef *frame)
{
int (*filter_frame)(AVFilterLink *, AVFilterBufferRef *);
AVFilterPad *src = link->srcpad;
AVFilterPad *dst = link->dstpad;
AVFilterBufferRef *out;
int perms, ret;
AVFilterCommand *cmd= link->dst->command_queue;
int64_t pts;
if (link->closed) {
avfilter_unref_buffer(frame);
return AVERROR_EOF;
}
if (!(filter_frame = dst->filter_frame))
filter_frame = default_filter_frame;
av_assert1((frame->perms & src->min_perms) == src->min_perms);
frame->perms &= ~ src->rej_perms;
perms = frame->perms;
if (frame->linesize[0] < 0)
perms |= AV_PERM_NEG_LINESIZES;
/* prepare to copy the frame if the buffer has insufficient permissions */
if ((dst->min_perms & perms) != dst->min_perms ||
dst->rej_perms & perms) {
av_log(link->dst, AV_LOG_DEBUG,
"Copying data in avfilter (have perms %x, need %x, reject %x)\n",
perms, link->dstpad->min_perms, link->dstpad->rej_perms);
/* Maybe use ff_copy_buffer_ref instead? */
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
out = ff_get_video_buffer(link, dst->min_perms,
link->w, link->h);
break;
case AVMEDIA_TYPE_AUDIO:
out = ff_get_audio_buffer(link, dst->min_perms,
frame->audio->nb_samples);
break;
default: return AVERROR(EINVAL);
}
if (!out) {
avfilter_unref_buffer(frame);
return AVERROR(ENOMEM);
}
avfilter_copy_buffer_ref_props(out, frame);
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
av_image_copy(out->data, out->linesize, frame->data, frame->linesize,
frame->format, frame->video->w, frame->video->h);
break;
case AVMEDIA_TYPE_AUDIO:
av_samples_copy(out->extended_data, frame->extended_data,
0, 0, frame->audio->nb_samples,
av_get_channel_layout_nb_channels(frame->audio->channel_layout),
frame->format);
break;
default: return AVERROR(EINVAL);
}
avfilter_unref_buffer(frame);
} else
out = frame;
while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
av_log(link->dst, AV_LOG_DEBUG,
"Processing command time:%f command:%s arg:%s\n",
cmd->time, cmd->command, cmd->arg);
avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
ff_command_queue_pop(link->dst);
cmd= link->dst->command_queue;
}
pts = out->pts;
ret = filter_frame(link, out);
ff_update_link_current_pts(link, pts);
return ret;
}
static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFilterBufferRef *frame)
{
int insamples = frame->audio->nb_samples, inpos = 0, nb_samples;
AVFilterBufferRef *pbuf = link->partial_buf;
int nb_channels = frame->audio->channels;
int ret = 0;
/* Handle framing (min_samples, max_samples) */
while (insamples) {
if (!pbuf) {
AVRational samples_tb = { 1, link->sample_rate };
int perms = link->dstpad->min_perms | AV_PERM_WRITE;
pbuf = ff_get_audio_buffer(link, perms, link->partial_buf_size);
if (!pbuf) {
av_log(link->dst, AV_LOG_WARNING,
"Samples dropped due to memory allocation failure.\n");
return 0;
}
avfilter_copy_buffer_ref_props(pbuf, frame);
pbuf->pts = frame->pts +
av_rescale_q(inpos, samples_tb, link->time_base);
pbuf->audio->nb_samples = 0;
}
nb_samples = FFMIN(insamples,
link->partial_buf_size - pbuf->audio->nb_samples);
av_samples_copy(pbuf->extended_data, frame->extended_data,
pbuf->audio->nb_samples, inpos,
nb_samples, nb_channels, link->format);
inpos += nb_samples;
insamples -= nb_samples;
pbuf->audio->nb_samples += nb_samples;
if (pbuf->audio->nb_samples >= link->min_samples) {
ret = ff_filter_frame_framed(link, pbuf);
pbuf = NULL;
}
}
avfilter_unref_buffer(frame);
link->partial_buf = pbuf;
return ret;
}
int ff_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)
{
int ret;
FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
if((ret = ff_start_frame(link, frame)) < 0)
return ret;
if((ret = ff_draw_slice(link, 0, frame->video->h, 1)) < 0)
return ret;
if((ret = ff_end_frame(link)) < 0)
return ret;
return ret;
case AVMEDIA_TYPE_AUDIO:
return ff_filter_samples(link, frame);
default: return AVERROR(EINVAL);
/* Consistency checks */
if (link->type == AVMEDIA_TYPE_VIDEO) {
if (strcmp(link->dst->filter->name, "scale")) {
av_assert1(frame->format == link->format);
av_assert1(frame->video->w == link->w);
av_assert1(frame->video->h == link->h);
}
} else {
av_assert1(frame->format == link->format);
av_assert1(frame->audio->channels == link->channels);
av_assert1(frame->audio->channel_layout == link->channel_layout);
av_assert1(frame->audio->sample_rate == link->sample_rate);
}
/* Go directly to actual filtering if possible */
if (link->type == AVMEDIA_TYPE_AUDIO &&
link->min_samples &&
(link->partial_buf ||
frame->audio->nb_samples < link->min_samples ||
frame->audio->nb_samples > link->max_samples)) {
return ff_filter_frame_needs_framing(link, frame);
} else {
return ff_filter_frame_framed(link, frame);
}
}
......@@ -158,204 +158,3 @@ AVFilterBufferRef *ff_get_video_buffer(AVFilterLink *link, int perms, int w, int
return ret;
}
static int default_start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
{
AVFilterLink *outlink = NULL;
if (inlink->dstpad->filter_frame)
return 0;
if (inlink->dst->nb_outputs)
outlink = inlink->dst->outputs[0];
if (outlink && (inlink->dstpad->start_frame || inlink->dstpad->end_frame)) {
AVFilterBufferRef *buf_out;
outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
if (!outlink->out_buf)
return AVERROR(ENOMEM);
avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
outlink->out_buf->video->w = outlink->w;
outlink->out_buf->video->h = outlink->h;
buf_out = avfilter_ref_buffer(outlink->out_buf, ~0);
if (!buf_out)
return AVERROR(ENOMEM);
return ff_start_frame(outlink, buf_out);
}
return 0;
}
static void clear_link(AVFilterLink *link)
{
avfilter_unref_bufferp(&link->cur_buf);
avfilter_unref_bufferp(&link->src_buf);
avfilter_unref_bufferp(&link->out_buf);
link->cur_buf_copy = NULL; /* we do not own the reference */
}
/* XXX: should we do the duplicating of the picture ref here, instead of
* forcing the source filter to do it? */
int ff_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
{
int (*start_frame)(AVFilterLink *, AVFilterBufferRef *);
AVFilterPad *src = link->srcpad;
AVFilterPad *dst = link->dstpad;
int ret, perms;
AVFilterCommand *cmd= link->dst->command_queue;
int64_t pts;
FF_TPRINTF_START(NULL, start_frame); ff_tlog_link(NULL, link, 0); ff_tlog(NULL, " "); ff_tlog_ref(NULL, picref, 1);
if (strcmp(link->dst->filter->name, "scale")) {
av_assert1(picref->format == link->format);
av_assert1(picref->video->w == link->w);
av_assert1(picref->video->h == link->h);
}
if (link->closed) {
avfilter_unref_buffer(picref);
return AVERROR_EOF;
}
if (!(start_frame = dst->start_frame))
start_frame = default_start_frame;
av_assert1((picref->perms & src->min_perms) == src->min_perms);
picref->perms &= ~ src->rej_perms;
perms = picref->perms;
if (picref->linesize[0] < 0)
perms |= AV_PERM_NEG_LINESIZES;
/* prepare to copy the picture if it has insufficient permissions */
if ((dst->min_perms & perms) != dst->min_perms || dst->rej_perms & perms) {
av_log(link->dst, AV_LOG_DEBUG,
"frame copy needed (have perms %x, need %x, reject %x)\n",
picref->perms,
link->dstpad->min_perms, link->dstpad->rej_perms);
link->cur_buf = ff_get_video_buffer(link, dst->min_perms, link->w, link->h);
if (!link->cur_buf) {
avfilter_unref_bufferp(&picref);
return AVERROR(ENOMEM);
}
link->src_buf = picref;
avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);
/* copy palette if required */
if (av_pix_fmt_desc_get(link->format)->flags & PIX_FMT_PAL)
memcpy(link->cur_buf->data[1], link->src_buf-> data[1], AVPALETTE_SIZE);
}
else
link->cur_buf = picref;
link->cur_buf_copy = link->cur_buf;
while(cmd && cmd->time <= picref->pts * av_q2d(link->time_base)){
av_log(link->dst, AV_LOG_DEBUG,
"Processing command time:%f command:%s arg:%s\n",
cmd->time, cmd->command, cmd->arg);
avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
ff_command_queue_pop(link->dst);
cmd= link->dst->command_queue;
}
pts = link->cur_buf->pts;
ret = start_frame(link, link->cur_buf);
ff_update_link_current_pts(link, pts);
if (ret < 0)
clear_link(link);
else
/* incoming buffers must not be freed in start frame,
because they can still be in use by the automatic copy mechanism */
av_assert1(link->cur_buf_copy->buf->refcount > 0);
return ret;
}
static int default_end_frame(AVFilterLink *inlink)
{
AVFilterLink *outlink = NULL;
if (inlink->dstpad->filter_frame) {
int ret = inlink->dstpad->filter_frame(inlink, inlink->cur_buf);
inlink->cur_buf = NULL;
return ret;
}
if (inlink->dst->nb_outputs)
outlink = inlink->dst->outputs[0];
if (outlink) {
if (inlink->dstpad->filter_frame) {
int ret = inlink->dstpad->filter_frame(inlink, inlink->cur_buf);
inlink->cur_buf = NULL;
return ret;
} else if (inlink->dstpad->start_frame || inlink->dstpad->end_frame){
return ff_end_frame(outlink);
} else {
int ret = ff_filter_frame(outlink, inlink->cur_buf);
inlink->cur_buf = NULL;
return ret;
}
}
return 0;
}
int ff_end_frame(AVFilterLink *link)
{
int (*end_frame)(AVFilterLink *);
int ret;
if (!(end_frame = link->dstpad->end_frame))
end_frame = default_end_frame;
ret = end_frame(link);
clear_link(link);
return ret;
}
int ff_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
{
uint8_t *src[4], *dst[4];
int i, j, vsub;
FF_TPRINTF_START(NULL, draw_slice); ff_tlog_link(NULL, link, 0); ff_tlog(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
/* copy the slice if needed for permission reasons */
if (link->src_buf) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
vsub = desc->log2_chroma_h;
for (i = 0; i < 4; i++) {
if (link->src_buf->data[i]) {
src[i] = link->src_buf-> data[i] +
(y >> (i==1 || i==2 ? vsub : 0)) * link->src_buf-> linesize[i];
dst[i] = link->cur_buf_copy->data[i] +
(y >> (i==1 || i==2 ? vsub : 0)) * link->cur_buf_copy->linesize[i];
} else
src[i] = dst[i] = NULL;
}
for (i = 0; i < 4; i++) {
int planew =
av_image_get_linesize(link->format, link->cur_buf_copy->video->w, i);
if (!src[i]) continue;
for (j = 0; j < h >> (i==1 || i==2 ? vsub : 0); j++) {
memcpy(dst[i], src[i], planew);
src[i] += link->src_buf->linesize[i];
dst[i] += link->cur_buf_copy->linesize[i];
}
}
}
/* incoming buffers must not be freed in start frame,
because they can still be in use by the automatic copy mechanism */
av_assert1(link->cur_buf_copy->buf->refcount > 0);
return 0;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment