lavfi: replace avfilter_open() with avfilter_graph_alloc_filter().

Since we do not support "standalone" filters not attached to an AVFilterGraph, we should not have a public function to create such filters. In addition that function is horribly named, the action it does cannot be possibly described as "opening" a filter.

Anton Khirnov committed 13 years ago

Commit bc1a9851 parent 38f0c077 files · +83 −20Browse files

Unified · Split

7 files

doc/APIchanges +1 −0
libavfilter/avfilter.c +13 −7
libavfilter/avfilter.h +24 −2
libavfilter/avfiltergraph.c +30 −4
libavfilter/graphparser.c +2 −7
libavfilter/internal.h +10 −0
libavfilter/version.h +3 −0

doc/APIchanges+1−0

@@ -16,6 +16,7 @@ API changes, most recent first: · 15 unmodified lines
16	2013-xx-xx - lavfi 3.8.0	16	2013-xx-xx - lavfi 3.8.0
17	Move all content from avfiltergraph.h to avfilter.h. Deprecate	17	Move all content from avfiltergraph.h to avfilter.h. Deprecate
18	avfilterhraph.h, user applications should include just avfilter.h	18	avfilterhraph.h, user applications should include just avfilter.h
		19	Add avfilter_graph_alloc_filter(), deprecate avfilter_open().
19		20
20	2013-xx-xx - lavfi 3.7.0 - avfilter.h	21	2013-xx-xx - lavfi 3.7.0 - avfilter.h
21	Add AVFilter.priv_class for exporting filter options through the AVOptions API	22	Add AVFilter.priv_class for exporting filter options through the AVOptions API

libavfilter/avfilter.c+13−7

     .child_class_next = filter_child_class_next,
 };
-int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
+AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
 {
     AVFilterContext *ret;
-    *filter_ctx = NULL;
     if (!filter)
-        return AVERROR(EINVAL);
+        return NULL;
     ret = av_mallocz(sizeof(AVFilterContext));
     if (!ret)
-        return AVERROR(ENOMEM);
+        return NULL;
     ret->av_class = &avfilter_class;
     ret->filter   = filter;
     ret->input_count  = ret->nb_inputs;
 #endif
-    *filter_ctx = ret;
+    return ret;
-    return 0;
 err:
     av_freep(&ret->inputs);
     ret->nb_outputs = 0;
     av_freep(&ret->priv);
     av_free(ret);
-    return AVERROR(ENOMEM);
+    return NULL;
 }
+#if FF_API_AVFILTER_OPEN
+int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
+{
+    *filter_ctx = ff_filter_alloc(filter, inst_name);
+    return *filter_ctx ? 0 : AVERROR(ENOMEM);
+}
+#endif
 void avfilter_free(AVFilterContext *filter)
 {
     int i;

libavfilter/avfilter.h+24−2

 /**
  * Register a filter. This is only needed if you plan to use
  * avfilter_get_by_name later to lookup the AVFilter structure by name. A
- * filter can still by instantiated with avfilter_open even if it is not
+ * filter can still by instantiated with avfilter_graph_alloc_filter even if it
- * registered.
+ * is not registered.
  *
  * @param filter the filter to register
  * @return 0 if the registration was succesfull, a negative value
  */
 AVFilter **av_filter_next(AVFilter **filter);
+#if FF_API_AVFILTER_OPEN
 /**
  * Create a filter instance.
  *
  * @param filter    the filter to create an instance of
  * @param inst_name Name to give to the new instance. Can be NULL for none.
  * @return >= 0 in case of success, a negative error code otherwise
+ * @deprecated use avfilter_graph_alloc_filter() instead
  */
+attribute_deprecated
 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
+#endif
 /**
  * Initialize a filter.
  */
 AVFilterGraph *avfilter_graph_alloc(void);
+/**
+ * Create a new filter instance in a filter graph.
+ *
+ * @param graph graph in which the new filter will be used
+ * @param filter the filter to create an instance of
+ * @param name Name to give to the new instance (will be copied to
+ *             AVFilterContext.name). This may be used by the caller to identify
+ *             different filters, libavfilter itself assigns no semantics to
+ *             this parameter. May be NULL.
+ *
+ * @return the context of the newly created filter instance (note that it is
+ *         also retrievable directly through AVFilterGraph.filters or with
+ *         avfilter_graph_get_filter()) on success or NULL or failure.
+ */
+AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
+                                             const AVFilter *filter,
+                                             const char *name);
 /**
  * Get a filter instance with name name from graph.
  *

libavfilter/avfiltergraph.c+30−4

@@ -81,12 +81,12 @@ int avfilter_graph_create_filter(AVFilterContext *filt_ctx, AVFilter filt, · 80 unmodified lines
81	{	81	{
82	int ret;	82	int ret;
83		83
84	if ((ret = avfilter_open(filt_ctx, filt, name)) < 0)	84	*filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
85	goto fail;	85	if (!*filt_ctx)
		86	return AVERROR(ENOMEM);
86	if ((ret = avfilter_init_filter(*filt_ctx, args, opaque)) < 0)	87	if ((ret = avfilter_init_filter(*filt_ctx, args, opaque)) < 0)
87	goto fail;	88	goto fail;
88	if ((ret = avfilter_graph_add_filter(graph_ctx, *filt_ctx)) < 0)	89
89	goto fail;
90	return 0;	90	return 0;
91		91
92	fail:	92	fail:
@@ -96,6 +96,32 @@ fail: · 3 unmodified lines
96	return ret;	96	return ret;
97	}	97	}
98		98
		99	AVFilterContext avfilter_graph_alloc_filter(AVFilterGraph graph,
		100	const AVFilter *filter,
		101	const char *name)
		102	{
		103	AVFilterContext *filters, s;
		104
		105	s = ff_filter_alloc(filter, name);
		106	if (!s)
		107	return NULL;
		108
		109	filters = av_realloc(graph->filters, sizeof(filters) (graph->nb_filters + 1));
		110	if (!filters) {
		111	avfilter_free(s);
		112	return NULL;
		113	}
		114
		115	graph->filters = filters;
		116	graph->filters[graph->nb_filters++] = s;
		117
		118	#if FF_API_FOO_COUNT
		119	graph->filter_count = graph->nb_filters;
		120	#endif
		121
		122	return s;
		123	}
		124
99	/**	125	/**
100	* Check for the validity of graph.	126	* Check for the validity of graph.
101	*	127	*

libavfilter/graphparser.c+2−7

         return AVERROR(EINVAL);
     }
-    ret = avfilter_open(filt_ctx, filt, inst_name);
+    *filt_ctx = avfilter_graph_alloc_filter(ctx, filt, inst_name);
     if (!*filt_ctx) {
         av_log(log_ctx, AV_LOG_ERROR,
                "Error creating filter '%s'\n", filt_name);
-        return ret;
+        return AVERROR(ENOMEM);
-    }
-    if ((ret = avfilter_graph_add_filter(ctx, *filt_ctx)) < 0) {
-        avfilter_free(*filt_ctx);
-        return ret;
     }
     if (!strcmp(filt_name, "scale") && args && !strstr(args, "flags") &&

libavfilter/internal.h+10−0

@@ -196,4 +196,14 @@ int ff_request_frame(AVFilterLink *link); · 195 unmodified lines
196	*/	196	*/
197	int ff_filter_frame(AVFilterLink link, AVFrame frame);	197	int ff_filter_frame(AVFilterLink link, AVFrame frame);
198		198
		199	/**
		200	* Allocate a new filter context and return it.
		201	*
		202	* @param filter what filter to create an instance of
		203	* @param inst_name name to give to the new filter context
		204	*
		205	* @return newly created filter context or NULL on failure
		206	*/
		207	AVFilterContext ff_filter_alloc(const AVFilter filter, const char *inst_name);
		208
199	#endif /* AVFILTER_INTERNAL_H */	209	#endif /* AVFILTER_INTERNAL_H */

libavfilter/version.h+3−0

@@ -58,5 +58,8 @@ · 57 unmodified lines
58	#ifndef FF_API_OLD_FILTER_OPTS	58	#ifndef FF_API_OLD_FILTER_OPTS
59	#define FF_API_OLD_FILTER_OPTS (LIBAVFILTER_VERSION_MAJOR < 4)	59	#define FF_API_OLD_FILTER_OPTS (LIBAVFILTER_VERSION_MAJOR < 4)
60	#endif	60	#endif
		61	#ifndef FF_API_AVFILTER_OPEN
		62	#define FF_API_AVFILTER_OPEN (LIBAVFILTER_VERSION_MAJOR < 4)
		63	#endif
61		64
62	#endif /* AVFILTER_VERSION_H */	65	#endif /* AVFILTER_VERSION_H */

lavfi: replace avfilter_open() with avfilter_graph_alloc_filter().

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code