mirror of
https://git.videolan.org/git/ffmpeg.git
synced 2024-08-01 16:59:58 +02:00
36dc00de52
These fields are needed to be able to know which area of memory is allocated and which is off limits. This reverts 24291 and parts of r24424. Originally committed as revision 26314 to svn://svn.ffmpeg.org/ffmpeg/trunk
618 lines
19 KiB
C
618 lines
19 KiB
C
/*
|
|
* filter layer
|
|
* Copyright (c) 2007 Bobby Bingham
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
/* #define DEBUG */
|
|
|
|
#include "libavutil/pixdesc.h"
|
|
#include "libavutil/rational.h"
|
|
#include "libavcore/imgutils.h"
|
|
#include "avfilter.h"
|
|
#include "internal.h"
|
|
|
|
unsigned avfilter_version(void) {
|
|
return LIBAVFILTER_VERSION_INT;
|
|
}
|
|
|
|
const char *avfilter_configuration(void)
|
|
{
|
|
return FFMPEG_CONFIGURATION;
|
|
}
|
|
|
|
const char *avfilter_license(void)
|
|
{
|
|
#define LICENSE_PREFIX "libavfilter license: "
|
|
return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
|
|
}
|
|
|
|
AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask)
|
|
{
|
|
AVFilterBufferRef *ret = av_malloc(sizeof(AVFilterBufferRef));
|
|
if (!ret)
|
|
return NULL;
|
|
*ret = *ref;
|
|
if (ref->type == AVMEDIA_TYPE_VIDEO) {
|
|
ret->video = av_malloc(sizeof(AVFilterBufferRefVideoProps));
|
|
if (!ret->video) {
|
|
av_free(ret);
|
|
return NULL;
|
|
}
|
|
*ret->video = *ref->video;
|
|
} else if (ref->type == AVMEDIA_TYPE_AUDIO) {
|
|
ret->audio = av_malloc(sizeof(AVFilterBufferRefAudioProps));
|
|
if (!ret->audio) {
|
|
av_free(ret);
|
|
return NULL;
|
|
}
|
|
*ret->audio = *ref->audio;
|
|
}
|
|
ret->perms &= pmask;
|
|
ret->buf->refcount ++;
|
|
return ret;
|
|
}
|
|
|
|
void avfilter_unref_buffer(AVFilterBufferRef *ref)
|
|
{
|
|
if (!(--ref->buf->refcount))
|
|
ref->buf->free(ref->buf);
|
|
av_free(ref->video);
|
|
av_free(ref->audio);
|
|
av_free(ref);
|
|
}
|
|
|
|
void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
|
|
AVFilterPad **pads, AVFilterLink ***links,
|
|
AVFilterPad *newpad)
|
|
{
|
|
unsigned i;
|
|
|
|
idx = FFMIN(idx, *count);
|
|
|
|
*pads = av_realloc(*pads, sizeof(AVFilterPad) * (*count + 1));
|
|
*links = av_realloc(*links, sizeof(AVFilterLink*) * (*count + 1));
|
|
memmove(*pads +idx+1, *pads +idx, sizeof(AVFilterPad) * (*count-idx));
|
|
memmove(*links+idx+1, *links+idx, sizeof(AVFilterLink*) * (*count-idx));
|
|
memcpy(*pads+idx, newpad, sizeof(AVFilterPad));
|
|
(*links)[idx] = NULL;
|
|
|
|
(*count)++;
|
|
for (i = idx+1; i < *count; i++)
|
|
if (*links[i])
|
|
(*(unsigned *)((uint8_t *) *links[i] + padidx_off))++;
|
|
}
|
|
|
|
int avfilter_link(AVFilterContext *src, unsigned srcpad,
|
|
AVFilterContext *dst, unsigned dstpad)
|
|
{
|
|
AVFilterLink *link;
|
|
|
|
if (src->output_count <= srcpad || dst->input_count <= dstpad ||
|
|
src->outputs[srcpad] || dst->inputs[dstpad])
|
|
return -1;
|
|
|
|
src->outputs[srcpad] =
|
|
dst-> inputs[dstpad] = link = av_mallocz(sizeof(AVFilterLink));
|
|
|
|
link->src = src;
|
|
link->dst = dst;
|
|
link->srcpad = &src->output_pads[srcpad];
|
|
link->dstpad = &dst->input_pads[dstpad];
|
|
link->type = src->output_pads[srcpad].type;
|
|
assert(PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
|
|
link->format = -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
|
|
unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
|
|
{
|
|
int ret;
|
|
unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
|
|
|
|
av_log(link->dst, AV_LOG_INFO, "auto-inserting filter '%s' "
|
|
"between the filter '%s' and the filter '%s'\n",
|
|
filt->name, link->src->name, link->dst->name);
|
|
|
|
link->dst->inputs[dstpad_idx] = NULL;
|
|
if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
|
|
/* failed to link output filter to new filter */
|
|
link->dst->inputs[dstpad_idx] = link;
|
|
return ret;
|
|
}
|
|
|
|
/* re-hookup the link to the new destination filter we inserted */
|
|
link->dst = filt;
|
|
link->dstpad = &filt->input_pads[filt_srcpad_idx];
|
|
filt->inputs[filt_srcpad_idx] = link;
|
|
|
|
/* if any information on supported media formats already exists on the
|
|
* link, we need to preserve that */
|
|
if (link->out_formats)
|
|
avfilter_formats_changeref(&link->out_formats,
|
|
&filt->outputs[filt_dstpad_idx]->out_formats);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int avfilter_config_links(AVFilterContext *filter)
|
|
{
|
|
int (*config_link)(AVFilterLink *);
|
|
unsigned i;
|
|
int ret;
|
|
|
|
for (i = 0; i < filter->input_count; i ++) {
|
|
AVFilterLink *link = filter->inputs[i];
|
|
|
|
if (!link) continue;
|
|
|
|
switch (link->init_state) {
|
|
case AVLINK_INIT:
|
|
continue;
|
|
case AVLINK_STARTINIT:
|
|
av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
|
|
return 0;
|
|
case AVLINK_UNINIT:
|
|
link->init_state = AVLINK_STARTINIT;
|
|
|
|
if ((ret = avfilter_config_links(link->src)) < 0)
|
|
return ret;
|
|
|
|
if (!(config_link = link->srcpad->config_props))
|
|
config_link = avfilter_default_config_output_link;
|
|
if ((ret = config_link(link)) < 0)
|
|
return ret;
|
|
|
|
if (link->time_base.num == 0 && link->time_base.den == 0)
|
|
link->time_base = link->src && link->src->input_count ?
|
|
link->src->inputs[0]->time_base : AV_TIME_BASE_Q;
|
|
|
|
if ((config_link = link->dstpad->config_props))
|
|
if ((ret = config_link(link)) < 0)
|
|
return ret;
|
|
|
|
link->init_state = AVLINK_INIT;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)
|
|
{
|
|
snprintf(buf, buf_size, "%s%s%s%s%s%s",
|
|
perms & AV_PERM_READ ? "r" : "",
|
|
perms & AV_PERM_WRITE ? "w" : "",
|
|
perms & AV_PERM_PRESERVE ? "p" : "",
|
|
perms & AV_PERM_REUSE ? "u" : "",
|
|
perms & AV_PERM_REUSE2 ? "U" : "",
|
|
perms & AV_PERM_NEG_LINESIZES ? "n" : "");
|
|
return buf;
|
|
}
|
|
|
|
void ff_dprintf_ref(void *ctx, AVFilterBufferRef *ref, int end)
|
|
{
|
|
av_unused char buf[16];
|
|
dprintf(ctx,
|
|
"ref[%p buf:%p refcount:%d perms:%s data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
|
|
ref, ref->buf, ref->buf->refcount, ff_get_ref_perms_string(buf, sizeof(buf), ref->perms), ref->data[0],
|
|
ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
|
|
ref->pts, ref->pos);
|
|
|
|
if (ref->video) {
|
|
dprintf(ctx, " a:%d/%d s:%dx%d i:%c",
|
|
ref->video->pixel_aspect.num, ref->video->pixel_aspect.den,
|
|
ref->video->w, ref->video->h,
|
|
!ref->video->interlaced ? 'P' : /* Progressive */
|
|
ref->video->top_field_first ? 'T' : 'B'); /* Top / Bottom */
|
|
}
|
|
if (ref->audio) {
|
|
dprintf(ctx, " cl:%"PRId64"d sn:%d s:%d sr:%d p:%d",
|
|
ref->audio->channel_layout,
|
|
ref->audio->samples_nb,
|
|
ref->audio->size,
|
|
ref->audio->sample_rate,
|
|
ref->audio->planar);
|
|
}
|
|
|
|
dprintf(ctx, "]%s", end ? "\n" : "");
|
|
}
|
|
|
|
void ff_dprintf_link(void *ctx, AVFilterLink *link, int end)
|
|
{
|
|
dprintf(ctx,
|
|
"link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s",
|
|
link, link->w, link->h,
|
|
av_pix_fmt_descriptors[link->format].name,
|
|
link->src ? link->src->filter->name : "",
|
|
link->dst ? link->dst->filter->name : "",
|
|
end ? "\n" : "");
|
|
}
|
|
|
|
AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
|
|
{
|
|
AVFilterBufferRef *ret = NULL;
|
|
|
|
av_unused char buf[16];
|
|
FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0);
|
|
dprintf(NULL, " perms:%s w:%d h:%d\n", ff_get_ref_perms_string(buf, sizeof(buf), perms), w, h);
|
|
|
|
if (link->dstpad->get_video_buffer)
|
|
ret = link->dstpad->get_video_buffer(link, perms, w, h);
|
|
|
|
if (!ret)
|
|
ret = avfilter_default_get_video_buffer(link, perms, w, h);
|
|
|
|
if (ret)
|
|
ret->type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " returning "); ff_dprintf_ref(NULL, ret, 1);
|
|
|
|
return ret;
|
|
}
|
|
|
|
AVFilterBufferRef *
|
|
avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
|
|
int w, int h, enum PixelFormat format)
|
|
{
|
|
AVFilterBuffer *pic = av_mallocz(sizeof(AVFilterBuffer));
|
|
AVFilterBufferRef *picref = av_mallocz(sizeof(AVFilterBufferRef));
|
|
|
|
if (!pic || !picref)
|
|
goto fail;
|
|
|
|
picref->buf = pic;
|
|
picref->buf->free = ff_avfilter_default_free_buffer;
|
|
if (!(picref->video = av_mallocz(sizeof(AVFilterBufferRefVideoProps))))
|
|
goto fail;
|
|
|
|
pic->w = picref->video->w = w;
|
|
pic->h = picref->video->h = h;
|
|
|
|
/* make sure the buffer gets read permission or it's useless for output */
|
|
picref->perms = perms | AV_PERM_READ;
|
|
|
|
pic->refcount = 1;
|
|
picref->type = AVMEDIA_TYPE_VIDEO;
|
|
pic->format = picref->format = format;
|
|
|
|
memcpy(pic->data, data, sizeof(pic->data));
|
|
memcpy(pic->linesize, linesize, sizeof(pic->linesize));
|
|
memcpy(picref->data, pic->data, sizeof(picref->data));
|
|
memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
|
|
|
|
return picref;
|
|
|
|
fail:
|
|
if (picref && picref->video)
|
|
av_free(picref->video);
|
|
av_free(picref);
|
|
av_free(pic);
|
|
return NULL;
|
|
}
|
|
|
|
AVFilterBufferRef *avfilter_get_audio_buffer(AVFilterLink *link, int perms,
|
|
enum AVSampleFormat sample_fmt, int size,
|
|
int64_t channel_layout, int planar)
|
|
{
|
|
AVFilterBufferRef *ret = NULL;
|
|
|
|
if (link->dstpad->get_audio_buffer)
|
|
ret = link->dstpad->get_audio_buffer(link, perms, sample_fmt, size, channel_layout, planar);
|
|
|
|
if (!ret)
|
|
ret = avfilter_default_get_audio_buffer(link, perms, sample_fmt, size, channel_layout, planar);
|
|
|
|
if (ret)
|
|
ret->type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int avfilter_request_frame(AVFilterLink *link)
|
|
{
|
|
FF_DPRINTF_START(NULL, request_frame); ff_dprintf_link(NULL, link, 1);
|
|
|
|
if (link->srcpad->request_frame)
|
|
return link->srcpad->request_frame(link);
|
|
else if (link->src->inputs[0])
|
|
return avfilter_request_frame(link->src->inputs[0]);
|
|
else return -1;
|
|
}
|
|
|
|
int avfilter_poll_frame(AVFilterLink *link)
|
|
{
|
|
int i, min = INT_MAX;
|
|
|
|
if (link->srcpad->poll_frame)
|
|
return link->srcpad->poll_frame(link);
|
|
|
|
for (i = 0; i < link->src->input_count; i++) {
|
|
int val;
|
|
if (!link->src->inputs[i])
|
|
return -1;
|
|
val = avfilter_poll_frame(link->src->inputs[i]);
|
|
min = FFMIN(min, val);
|
|
}
|
|
|
|
return min;
|
|
}
|
|
|
|
/* XXX: should we do the duplicating of the picture ref here, instead of
|
|
* forcing the source filter to do it? */
|
|
void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
|
|
{
|
|
void (*start_frame)(AVFilterLink *, AVFilterBufferRef *);
|
|
AVFilterPad *dst = link->dstpad;
|
|
int perms = picref->perms;
|
|
|
|
FF_DPRINTF_START(NULL, start_frame); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " "); ff_dprintf_ref(NULL, picref, 1);
|
|
|
|
if (!(start_frame = dst->start_frame))
|
|
start_frame = avfilter_default_start_frame;
|
|
|
|
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 = avfilter_get_video_buffer(link, dst->min_perms, link->w, link->h);
|
|
link->src_buf = picref;
|
|
avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);
|
|
}
|
|
else
|
|
link->cur_buf = picref;
|
|
|
|
start_frame(link, link->cur_buf);
|
|
}
|
|
|
|
void avfilter_end_frame(AVFilterLink *link)
|
|
{
|
|
void (*end_frame)(AVFilterLink *);
|
|
|
|
if (!(end_frame = link->dstpad->end_frame))
|
|
end_frame = avfilter_default_end_frame;
|
|
|
|
end_frame(link);
|
|
|
|
/* unreference the source picture if we're feeding the destination filter
|
|
* a copied version dues to permission issues */
|
|
if (link->src_buf) {
|
|
avfilter_unref_buffer(link->src_buf);
|
|
link->src_buf = NULL;
|
|
}
|
|
}
|
|
|
|
void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
|
|
{
|
|
uint8_t *src[4], *dst[4];
|
|
int i, j, vsub;
|
|
void (*draw_slice)(AVFilterLink *, int, int, int);
|
|
|
|
FF_DPRINTF_START(NULL, draw_slice); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
|
|
|
|
/* copy the slice if needed for permission reasons */
|
|
if (link->src_buf) {
|
|
vsub = av_pix_fmt_descriptors[link->format].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->data[i] +
|
|
(y >> (i==1 || i==2 ? vsub : 0)) * link->cur_buf->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->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->linesize[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(draw_slice = link->dstpad->draw_slice))
|
|
draw_slice = avfilter_default_draw_slice;
|
|
draw_slice(link, y, h, slice_dir);
|
|
}
|
|
|
|
void avfilter_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
|
|
{
|
|
void (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);
|
|
AVFilterPad *dst = link->dstpad;
|
|
|
|
if (!(filter_samples = dst->filter_samples))
|
|
filter_samples = avfilter_default_filter_samples;
|
|
|
|
/* 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);
|
|
|
|
link->cur_buf = avfilter_default_get_audio_buffer(link, dst->min_perms,
|
|
samplesref->format,
|
|
samplesref->audio->size,
|
|
samplesref->audio->channel_layout,
|
|
samplesref->audio->planar);
|
|
link->cur_buf->pts = samplesref->pts;
|
|
link->cur_buf->audio->sample_rate = samplesref->audio->sample_rate;
|
|
|
|
/* Copy actual data into new samples buffer */
|
|
memcpy(link->cur_buf->data[0], samplesref->data[0], samplesref->audio->size);
|
|
|
|
avfilter_unref_buffer(samplesref);
|
|
} else
|
|
link->cur_buf = samplesref;
|
|
|
|
filter_samples(link, link->cur_buf);
|
|
}
|
|
|
|
#define MAX_REGISTERED_AVFILTERS_NB 64
|
|
|
|
static AVFilter *registered_avfilters[MAX_REGISTERED_AVFILTERS_NB + 1];
|
|
|
|
static int next_registered_avfilter_idx = 0;
|
|
|
|
AVFilter *avfilter_get_by_name(const char *name)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; registered_avfilters[i]; i++)
|
|
if (!strcmp(registered_avfilters[i]->name, name))
|
|
return registered_avfilters[i];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int avfilter_register(AVFilter *filter)
|
|
{
|
|
if (next_registered_avfilter_idx == MAX_REGISTERED_AVFILTERS_NB)
|
|
return -1;
|
|
|
|
registered_avfilters[next_registered_avfilter_idx++] = filter;
|
|
return 0;
|
|
}
|
|
|
|
AVFilter **av_filter_next(AVFilter **filter)
|
|
{
|
|
return filter ? ++filter : ®istered_avfilters[0];
|
|
}
|
|
|
|
void avfilter_uninit(void)
|
|
{
|
|
memset(registered_avfilters, 0, sizeof(registered_avfilters));
|
|
next_registered_avfilter_idx = 0;
|
|
}
|
|
|
|
static int pad_count(const AVFilterPad *pads)
|
|
{
|
|
int count;
|
|
|
|
for(count = 0; pads->name; count ++) pads ++;
|
|
return count;
|
|
}
|
|
|
|
static const char *filter_name(void *p)
|
|
{
|
|
AVFilterContext *filter = p;
|
|
return filter->filter->name;
|
|
}
|
|
|
|
static const AVClass avfilter_class = {
|
|
"AVFilter",
|
|
filter_name,
|
|
NULL,
|
|
LIBAVUTIL_VERSION_INT,
|
|
};
|
|
|
|
int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
|
|
{
|
|
AVFilterContext *ret;
|
|
*filter_ctx = NULL;
|
|
|
|
if (!filter)
|
|
return AVERROR(EINVAL);
|
|
|
|
ret = av_mallocz(sizeof(AVFilterContext));
|
|
|
|
ret->av_class = &avfilter_class;
|
|
ret->filter = filter;
|
|
ret->name = inst_name ? av_strdup(inst_name) : NULL;
|
|
ret->priv = av_mallocz(filter->priv_size);
|
|
|
|
ret->input_count = pad_count(filter->inputs);
|
|
if (ret->input_count) {
|
|
ret->input_pads = av_malloc(sizeof(AVFilterPad) * ret->input_count);
|
|
memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->input_count);
|
|
ret->inputs = av_mallocz(sizeof(AVFilterLink*) * ret->input_count);
|
|
}
|
|
|
|
ret->output_count = pad_count(filter->outputs);
|
|
if (ret->output_count) {
|
|
ret->output_pads = av_malloc(sizeof(AVFilterPad) * ret->output_count);
|
|
memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->output_count);
|
|
ret->outputs = av_mallocz(sizeof(AVFilterLink*) * ret->output_count);
|
|
}
|
|
|
|
*filter_ctx = ret;
|
|
return 0;
|
|
}
|
|
|
|
void avfilter_free(AVFilterContext *filter)
|
|
{
|
|
int i;
|
|
AVFilterLink *link;
|
|
|
|
if (filter->filter->uninit)
|
|
filter->filter->uninit(filter);
|
|
|
|
for (i = 0; i < filter->input_count; i++) {
|
|
if ((link = filter->inputs[i])) {
|
|
if (link->src)
|
|
link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
|
|
avfilter_formats_unref(&link->in_formats);
|
|
avfilter_formats_unref(&link->out_formats);
|
|
}
|
|
av_freep(&link);
|
|
}
|
|
for (i = 0; i < filter->output_count; i++) {
|
|
if ((link = filter->outputs[i])) {
|
|
if (link->dst)
|
|
link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
|
|
avfilter_formats_unref(&link->in_formats);
|
|
avfilter_formats_unref(&link->out_formats);
|
|
}
|
|
av_freep(&link);
|
|
}
|
|
|
|
av_freep(&filter->name);
|
|
av_freep(&filter->input_pads);
|
|
av_freep(&filter->output_pads);
|
|
av_freep(&filter->inputs);
|
|
av_freep(&filter->outputs);
|
|
av_freep(&filter->priv);
|
|
av_free(filter);
|
|
}
|
|
|
|
int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
|
|
{
|
|
int ret=0;
|
|
|
|
if (filter->filter->init)
|
|
ret = filter->filter->init(filter, args, opaque);
|
|
return ret;
|
|
}
|
|
|