[FFmpeg-soc] [soc]: r284 - in libavfilter: . TODO avfilter.c avfilter.h
koorogi
subversion at mplayerhq.hu
Fri Jun 29 19:03:03 CEST 2007
Author: koorogi
Date: Fri Jun 29 19:03:03 2007
New Revision: 284
Log:
Initial stab at an API
Added:
libavfilter/
libavfilter/TODO
libavfilter/avfilter.c
libavfilter/avfilter.h
Added: libavfilter/TODO
==============================================================================
--- (empty file)
+++ libavfilter/TODO Fri Jun 29 19:03:03 2007
@@ -0,0 +1,37 @@
+FRAMEWORK:
+- colorspace negotiation
+- auto-inserting needed filters (colorspace conversion, buffer, etc)
+- parameter passing
+- pass pts, and whatever info is needed to reorder decode ordered frames
+- other useful image flags? interlace? top/bottom field first?
+- rework init sequence
+- ease reuse of same memory for multiple slices
+
+- proper vout filter support, with a display() callback?
+- support for running different filters in different threads?
+
+FILTERS:
+- make existing filters support more useful colorspaces (YUV)
+- colorspace conversion
+- scaling (combine with conversion like mplayer?)
+- (de)slicify
+- decode order -> display order
+- fifo buffer to buffer previous frames needed for next filter context
+- spatial context providing filter
+- picture-in-picture to test multiple inputs
+- splitter, feeding a single input to multiple filters to test multiple outputs
+- decimate to test non 1:1 input:output ratios
+- naive temporal blur to test buffering of previous frames
+- naive spatial blur to test spatial context
+- decoder/encoder wrapper
+
+- port vhook filters
+
+PROGRAMS:
+- make ffplay & ffmpeg support filters
+
+DOCUMENTATION:
+- more & better doxy comments
+- filter writing tutorial
+- filter using tutorial
+
Added: libavfilter/avfilter.c
==============================================================================
--- (empty file)
+++ libavfilter/avfilter.c Fri Jun 29 19:03:03 2007
@@ -0,0 +1,268 @@
+/*
+ * 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
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "avfilter.h"
+
+/** list of registered filters, sorted by name */
+static int filter_count = 0;
+static AVFilter **filters = NULL;
+
+/* TODO: buffer pool. see comment for avfilter_default_get_video_buffer() */
+void avfilter_default_free_video_buffer(AVFilterPic *pic)
+{
+ avpicture_free((AVPicture *) pic);
+ av_free(pic);
+}
+
+/* TODO: set the buffer's priv member to a context structure for the whole
+ * filter chain. This will allow for a buffer pool instead of the constant
+ * alloc & free cycle currently implemented. */
+AVFilterPicRef *avfilter_default_get_video_buffer(AVFilterLink *link, int perms)
+{
+ AVFilterPic *pic = av_mallocz(sizeof(AVFilterPic));
+ AVFilterPicRef *ref = av_mallocz(sizeof(AVFilterPicRef));
+
+ ref->pic = pic;
+ ref->w = link->w;
+ ref->h = link->h;
+ ref->perms = perms;
+
+ pic->refcount = 1;
+ pic->format = link->format;
+ pic->free = avfilter_default_free_video_buffer;
+ avpicture_alloc((AVPicture *)pic, pic->format, ref->w, ref->h);
+
+ ref->data[0] = pic->data[0];
+ ref->data[1] = pic->data[1];
+ ref->data[2] = pic->data[2];
+ ref->data[3] = pic->data[3];
+
+ return ref;
+}
+
+void avfilter_default_start_frame(AVFilterLink *link, AVFilterPicRef *picref)
+{
+ link->cur_pic = picref;
+}
+
+void avfilter_default_end_frame(AVFilterLink *link)
+{
+ avfilter_unref_pic(link->cur_pic);
+ link->cur_pic = NULL;
+}
+
+AVFilterPicRef *avfilter_ref_pic(AVFilterPicRef *ref)
+{
+ AVFilterPicRef *ret = av_malloc(sizeof(AVFilterPicRef));
+ memcpy(ret, ref, sizeof(AVFilterPicRef));
+ ret->pic->refcount ++;
+ return ret;
+}
+
+void avfilter_unref_pic(AVFilterPicRef *ref)
+{
+ if(-- ref->pic->refcount == 0)
+ ref->pic->free(ref->pic);
+ av_free(ref);
+}
+
+int avfilter_link(AVFilterContext *src, unsigned srcpad,
+ AVFilterContext *dst, unsigned dstpad)
+{
+ AVFilterLink *link;
+
+ if(src->outputs[srcpad] || dst->inputs[dstpad])
+ return -1;
+
+ src->outputs[srcpad] =
+ dst->inputs[dstpad] = link = av_malloc(sizeof(AVFilterLink));
+
+ link->src = src;
+ link->dst = dst;
+ link->srcpad = srcpad;
+ link->dstpad = dstpad;
+ link->cur_pic = NULL;
+
+ src->filter->outputs[dstpad].set_video_props(link);
+ return 0;
+}
+
+AVFilterPicRef *avfilter_get_video_buffer(AVFilterLink *link, int perms)
+{
+ AVFilterPicRef *ret = NULL;
+
+ if(link->dst->filter->inputs[link->dstpad].get_video_buffer)
+ ret = link->dst->filter->inputs[link->dstpad].get_video_buffer(link, perms);
+
+ if(!ret)
+ ret = avfilter_default_get_video_buffer(link, perms);
+
+ return ret;
+}
+
+void avfilter_request_frame(AVFilterLink *link)
+{
+ link->src->filter->outputs[link->srcpad].request_frame(link);
+}
+
+/* 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, AVFilterPicRef *picref)
+{
+ void (*start_frame)(AVFilterLink *, AVFilterPicRef *);
+
+ start_frame = link->dst->filter->inputs[link->dstpad].start_frame;
+ if(!start_frame)
+ start_frame = avfilter_default_start_frame;
+
+ start_frame(link, picref);
+}
+
+void avfilter_end_frame(AVFilterLink *link)
+{
+ void (*end_frame)(AVFilterLink *);
+
+ end_frame = link->dst->filter->inputs[link->dstpad].end_frame;
+ if(!end_frame)
+ end_frame = avfilter_default_end_frame;
+
+ end_frame(link);
+}
+
+void avfilter_draw_slice(AVFilterLink *link, uint8_t *data[4], int y, int h)
+{
+ link->dst->filter->inputs[link->dstpad].draw_slice(link, data, y, h);
+}
+
+static int filter_cmp(const void *aa, const void *bb)
+{
+ const AVFilter *a = *(const AVFilter **)aa, *b = *(const AVFilter **)bb;
+ return strcmp(a->name, b->name);
+}
+
+AVFilter *avfilter_get_by_name(char *name)
+{
+ AVFilter key = { .name = name, };
+ AVFilter *key2 = &key;
+ AVFilter **ret;
+
+ ret = bsearch(&key2, filters, filter_count, sizeof(AVFilter **), filter_cmp);
+ if(ret)
+ return *ret;
+ return NULL;
+}
+
+/* FIXME: insert in order, rather than insert at end + resort */
+void avfilter_register(AVFilter *filter)
+{
+ filters = av_realloc(filters, sizeof(AVFilter*) * (filter_count+1));
+ filters[filter_count] = filter;
+ qsort(filters, ++filter_count, sizeof(AVFilter **), filter_cmp);
+}
+
+void avfilter_init(void)
+{
+}
+
+void avfilter_uninit(void)
+{
+ av_freep(&filters);
+ filter_count = 0;
+}
+
+static int pad_count(const AVFilterPad *pads)
+{
+ AVFilterPad *p = (AVFilterPad *) pads;
+ int count;
+
+ for(count = 0; p->name; count ++) p ++;
+ return count;
+}
+
+static const char *filter_name(void *p)
+{
+ AVFilterContext *filter = p;
+ return filter->filter->name;
+}
+
+AVFilterContext *avfilter_create(AVFilter *filter)
+{
+ AVFilterContext *ret = av_malloc(sizeof(AVFilterContext));
+
+ ret->av_class = av_mallocz(sizeof(AVClass));
+ ret->av_class->item_name = filter_name;
+ ret->filter = filter;
+ ret->inputs = av_mallocz(sizeof(AVFilterLink*) * pad_count(filter->inputs));
+ ret->outputs = av_mallocz(sizeof(AVFilterLink*) * pad_count(filter->outputs));
+ ret->priv = av_mallocz(filter->priv_size);
+
+ return ret;
+}
+
+void avfilter_destroy(AVFilterContext *filter)
+{
+ int i;
+
+ if(filter->filter->uninit)
+ filter->filter->uninit(filter);
+
+ for(i = 0; i < pad_count(filter->filter->inputs); i ++) {
+ if(filter->inputs[i])
+ filter->inputs[i]->src->outputs[filter->inputs[i]->srcpad] = NULL;
+ av_free(filter->inputs[i]);
+ }
+ for(i = 0; i < pad_count(filter->filter->outputs); i ++) {
+ if(filter->outputs[i])
+ filter->outputs[i]->dst->inputs[filter->outputs[i]->dstpad] = NULL;
+ av_free(filter->outputs[i]);
+ }
+
+ av_free(filter->inputs);
+ av_free(filter->outputs);
+ av_free(filter->priv);
+ av_free(filter->av_class);
+ av_free(filter);
+}
+
+AVFilterContext *avfilter_create_by_name(char *name)
+{
+ AVFilter *filt;
+
+ if(!(filt = avfilter_get_by_name(name))) return NULL;
+ return avfilter_create(filt);
+}
+
+int avfilter_init_filter(AVFilterContext *filter)
+{
+ int ret, i;
+
+ if(filter->filter->init)
+ if((ret = filter->filter->init(filter))) return ret;
+ for(i = 0; i < pad_count(filter->filter->outputs); i ++)
+ if(filter->outputs[i])
+ filter->filter->outputs[i].set_video_props(filter->outputs[i]);
+ return 0;
+}
+
Added: libavfilter/avfilter.h
==============================================================================
--- (empty file)
+++ libavfilter/avfilter.h Fri Jun 29 19:03:03 2007
@@ -0,0 +1,203 @@
+/*
+ * 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
+ */
+
+#ifndef FFMPEG_AVFILTER_H
+#define FFMPEG_AVFILTER_H
+
+#include "avcodec.h"
+
+typedef struct AVFilterContext AVFilterContext;
+typedef struct AVFilterLink AVFilterLink;
+typedef struct AVFilterPad AVFilterPad;
+
+/* TODO: look for other flags which may be useful in this structure (interlace
+ * flags, etc)
+ */
+/**
+ * A reference-counted picture data type used by the filter system. Filters
+ * should not store pointers to this structure directly, but instead use the
+ * AVFilterPicRef structure below
+ */
+typedef struct AVFilterPic
+{
+ uint8_t *data[4];
+ int linesize[4]; ///< number of bytes per line
+ enum PixelFormat format;
+
+ unsigned refcount;
+ void *priv;
+ void (*free)(struct AVFilterPic *pic);
+} AVFilterPic;
+
+/**
+ * A reference to an AVFilterPic. Since filters can manipulate the origin of
+ * a picture to, for example, crop image without any memcpy, the picture origin
+ * and dimensions are per-reference properties.
+ *
+ * TODO: add pts, and anything necessary for frame reordering
+ */
+typedef struct AVFilterPicRef
+{
+ AVFilterPic *pic;
+ uint8_t *data[4];
+ int w, h;
+
+ int perms; ///< permissions
+#define AV_PERM_READ 0x01 ///< can read from the buffer
+#define AV_PERM_WRITE 0x02 ///< can write to the buffer
+#define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer
+#define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times
+} AVFilterPicRef;
+
+/**
+ * Add a new reference to a picture.
+ * @param ref An existing reference to the picture
+ * @return A new reference to the picture with the same properties as the old
+ */
+AVFilterPicRef *avfilter_ref_pic(AVFilterPicRef *ref);
+
+/**
+ * Remove a reference to a picture. If this is the last reference to the
+ * picture, the picture itself is also automatically freed.
+ * @param ref Reference to the picture.
+ */
+void avfilter_unref_pic(AVFilterPicRef *ref);
+
+struct AVFilterPad
+{
+ /**
+ * Pad name. The name is unique among inputs and among oututs, but an
+ * input may have the same name as an output.
+ */
+ char *name;
+
+ /**
+ * AVFilterPad type. Only video supported now, hopefully someone will
+ * add audio in the future.
+ */
+ int type;
+#define AV_PAD_VIDEO 0
+
+ /**
+ * Callback called before passing the first slice of a new frame. If
+ * NULL, the filter layer will default to storing a reference to the
+ * picture inside the link structure.
+ */
+ void (*start_frame)(AVFilterLink *link, AVFilterPicRef *picref);
+
+ /**
+ * Callback function to get a buffer. If NULL, the filter system will
+ * handle buffer requests. Only required for input video pads.
+ */
+ AVFilterPicRef *(*get_video_buffer)(AVFilterLink *link, int perms);
+
+ /**
+ * Callback called after the slices of a frame are completely sent. If
+ * NULL, the filter layer will default to releasing the reference stored
+ * in the link structure during start_frame().
+ */
+ void (*end_frame)(AVFilterLink *link);
+
+ /**
+ * Slice drawing callback. This is where a filter receives video data
+ * and should do its processing. Only required for input video pads.
+ */
+ void (*draw_slice)(AVFilterLink *link, uint8_t *data[4], int y, int height);
+
+ /**
+ * Frame request callback. A call to this should result in at least one
+ * frame being output over the given link. Video output pads only.
+ */
+ void (*request_frame)(AVFilterLink *link);
+
+ /**
+ * Callback to set properties of the link. Only for video output pads.
+ * XXX: this is not acceptable as is. it needs reworked to allow for
+ * negotiation of colorspace, etc.
+ */
+ int (*set_video_props)(AVFilterLink *link);
+};
+
+/* the default implementations of start_frame() and end_frame() */
+void avfilter_default_start_frame(AVFilterLink *link, AVFilterPicRef *picref);
+void avfilter_default_end_frame(AVFilterLink *link);
+
+typedef struct
+{
+ char *name;
+ char *author;
+
+ int priv_size;
+
+ int (*init)(AVFilterContext *ctx);
+ void (*uninit)(AVFilterContext *ctx);
+
+ const AVFilterPad *inputs; /// NULL terminated list of inputs. NULL if none
+ const AVFilterPad *outputs; /// NULL terminated list of outputs. NULL if none
+} AVFilter;
+
+struct AVFilterContext
+{
+ AVClass *av_class;
+
+ AVFilter *filter;
+
+ AVFilterLink **inputs;
+ AVFilterLink **outputs;
+
+ void *priv;
+};
+
+struct AVFilterLink
+{
+ AVFilterContext *src;
+ unsigned int srcpad;
+
+ AVFilterContext *dst;
+ unsigned int dstpad;
+
+ int w, h;
+ enum PixelFormat format;
+
+ AVFilterPicRef *cur_pic;
+};
+
+/** Link two filters together */
+int avfilter_link(AVFilterContext *src, unsigned srcpad,
+ AVFilterContext *dst, unsigned dstpad);
+
+AVFilterPicRef *avfilter_get_video_buffer(AVFilterLink *link, int perms);
+void avfilter_request_frame(AVFilterLink *link);
+void avfilter_start_frame(AVFilterLink *link, AVFilterPicRef *picref);
+void avfilter_end_frame(AVFilterLink *link);
+void avfilter_draw_slice(AVFilterLink *link, uint8_t *data[4], int y, int h);
+
+void avfilter_init(void);
+void avfilter_uninit(void);
+void avfilter_register(AVFilter *filter);
+AVFilter *avfilter_get_by_name(char *name);
+
+AVFilterContext *avfilter_create(AVFilter *filter);
+AVFilterContext *avfilter_create_by_name(char *name);
+int avfilter_init_filter(AVFilterContext *filter);
+void avfilter_destroy(AVFilterContext *filter);
+
+#endif /* FFMPEG_AVFILTER_H */
More information about the FFmpeg-soc
mailing list