[FFmpeg-devel] [PATCH 31/35] avfilter/avfiltergraph: Avoid allocation for AVFilterGraphInternal
Andreas Rheinhardt
andreas.rheinhardt at outlook.com
Sun Feb 11 01:04:07 EET 2024
To do this, allocate AVFilterGraphInternal jointly with AVFilterGraph
and rename it to FFFilterGraph in the process (similarly to
AVStream/FFStream).
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt at outlook.com>
---
libavfilter/avfilter.c | 6 +++---
libavfilter/avfilter.h | 7 -------
libavfilter/avfilter_internal.h | 17 +++++++++++++----
libavfilter/avfiltergraph.c | 32 +++++++++++++++-----------------
libavfilter/pthread.c | 23 ++++++++++++-----------
5 files changed, 43 insertions(+), 42 deletions(-)
diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c
index 85e2936e6e..af46011b27 100644
--- a/libavfilter/avfilter.c
+++ b/libavfilter/avfilter.c
@@ -187,7 +187,7 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
link->format = -1;
link->colorspace = AVCOL_SPC_UNSPECIFIED;
- ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);
+ ff_framequeue_init(&link->fifo, &fffiltergraph(src->graph)->frame_queues);
return 0;
}
@@ -888,9 +888,9 @@ int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
- ctx->graph->internal->thread_execute) {
+ fffiltergraph(ctx->graph)->thread_execute) {
ctx->thread_type = AVFILTER_THREAD_SLICE;
- ctxi->execute = ctx->graph->internal->thread_execute;
+ ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
} else {
ctx->thread_type = 0;
}
diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h
index a3725b1516..65034f831a 100644
--- a/libavfilter/avfilter.h
+++ b/libavfilter/avfilter.h
@@ -843,8 +843,6 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
*/
const AVClass *avfilter_get_class(void);
-typedef struct AVFilterGraphInternal AVFilterGraphInternal;
-
/**
* A function pointer passed to the @ref AVFilterGraph.execute callback to be
* executed multiple times, possibly in parallel.
@@ -902,11 +900,6 @@ typedef struct AVFilterGraph {
*/
int nb_threads;
- /**
- * Opaque object for libavfilter internal use.
- */
- AVFilterGraphInternal *internal;
-
/**
* Opaque user data. May be set by the caller to an arbitrary value, e.g. to
* be used from callbacks like @ref AVFilterGraph.execute.
diff --git a/libavfilter/avfilter_internal.h b/libavfilter/avfilter_internal.h
index 3dd51fb993..9ddb82bf26 100644
--- a/libavfilter/avfilter_internal.h
+++ b/libavfilter/avfilter_internal.h
@@ -36,11 +36,20 @@ typedef struct AVFilterCommand {
struct AVFilterCommand *next;
} AVFilterCommand;
-struct AVFilterGraphInternal {
+typedef struct FFFilterGraph {
+ /**
+ * The public AVFilterGraph. See avfilter.h for it.
+ */
+ AVFilterGraph p;
void *thread;
avfilter_execute_func *thread_execute;
FFFrameQueueGlobal frame_queues;
-};
+} FFFilterGraph;
+
+static inline FFFilterGraph *fffiltergraph(AVFilterGraph *graph)
+{
+ return (FFFilterGraph*)graph;
+}
/**
* Update the position of a link in the age heap.
@@ -77,8 +86,8 @@ int ff_filter_activate(AVFilterContext *filter);
int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
AVDictionary **options, const char *args);
-int ff_graph_thread_init(AVFilterGraph *graph);
+int ff_graph_thread_init(FFFilterGraph *graph);
-void ff_graph_thread_free(AVFilterGraph *graph);
+void ff_graph_thread_free(FFFilterGraph *graph);
#endif /* AVFILTER_AVFILTER_INTERNAL_H */
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index 193fafe61c..0e2b5ee1f2 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -68,33 +68,30 @@ static const AVClass filtergraph_class = {
};
#if !HAVE_THREADS
-void ff_graph_thread_free(AVFilterGraph *graph)
+void ff_graph_thread_free(FFFilterGraph *graph)
{
}
-int ff_graph_thread_init(AVFilterGraph *graph)
+int ff_graph_thread_init(FFFilterGraph *graph)
{
- graph->thread_type = 0;
- graph->nb_threads = 1;
+ graph->p.thread_type = 0;
+ graph->p.nb_threads = 1;
return 0;
}
#endif
AVFilterGraph *avfilter_graph_alloc(void)
{
- AVFilterGraph *ret = av_mallocz(sizeof(*ret));
- if (!ret)
- return NULL;
+ FFFilterGraph *graph = av_mallocz(sizeof(*graph));
+ AVFilterGraph *ret;
- ret->internal = av_mallocz(sizeof(*ret->internal));
- if (!ret->internal) {
- av_freep(&ret);
+ if (!graph)
return NULL;
- }
+ ret = &graph->p;
ret->av_class = &filtergraph_class;
av_opt_set_defaults(ret);
- ff_framequeue_global_init(&ret->internal->frame_queues);
+ ff_framequeue_global_init(&graph->frame_queues);
return ret;
}
@@ -120,6 +117,7 @@ void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter
void avfilter_graph_free(AVFilterGraph **graphp)
{
AVFilterGraph *graph = *graphp;
+ FFFilterGraph *graphi = fffiltergraph(graph);
if (!graph)
return;
@@ -127,14 +125,13 @@ void avfilter_graph_free(AVFilterGraph **graphp)
while (graph->nb_filters)
avfilter_free(graph->filters[0]);
- ff_graph_thread_free(graph);
+ ff_graph_thread_free(graphi);
av_freep(&graph->sink_links);
av_opt_free(graph);
av_freep(&graph->filters);
- av_freep(&graph->internal);
av_freep(graphp);
}
@@ -170,12 +167,13 @@ AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
const char *name)
{
AVFilterContext **filters, *s;
+ FFFilterGraph *graphi = fffiltergraph(graph);
- if (graph->thread_type && !graph->internal->thread_execute) {
+ if (graph->thread_type && !graphi->thread_execute) {
if (graph->execute) {
- graph->internal->thread_execute = graph->execute;
+ graphi->thread_execute = graph->execute;
} else {
- int ret = ff_graph_thread_init(graph);
+ int ret = ff_graph_thread_init(graphi);
if (ret < 0) {
av_log(graph, AV_LOG_ERROR, "Error initializing threading: %s.\n", av_err2str(ret));
return NULL;
diff --git a/libavfilter/pthread.c b/libavfilter/pthread.c
index a0336a8e04..06590fe65a 100644
--- a/libavfilter/pthread.c
+++ b/libavfilter/pthread.c
@@ -58,7 +58,7 @@ static void slice_thread_uninit(ThreadContext *c)
static int thread_execute(AVFilterContext *ctx, avfilter_action_func *func,
void *arg, int *ret, int nb_jobs)
{
- ThreadContext *c = ctx->graph->internal->thread;
+ ThreadContext *c = fffiltergraph(ctx->graph)->thread;
if (nb_jobs <= 0)
return 0;
@@ -79,8 +79,9 @@ static int thread_init_internal(ThreadContext *c, int nb_threads)
return FFMAX(nb_threads, 1);
}
-int ff_graph_thread_init(AVFilterGraph *graph)
+int ff_graph_thread_init(FFFilterGraph *graphi)
{
+ AVFilterGraph *graph = &graphi->p;
int ret;
if (graph->nb_threads == 1) {
@@ -88,27 +89,27 @@ int ff_graph_thread_init(AVFilterGraph *graph)
return 0;
}
- graph->internal->thread = av_mallocz(sizeof(ThreadContext));
- if (!graph->internal->thread)
+ graphi->thread = av_mallocz(sizeof(ThreadContext));
+ if (!graphi->thread)
return AVERROR(ENOMEM);
- ret = thread_init_internal(graph->internal->thread, graph->nb_threads);
+ ret = thread_init_internal(graphi->thread, graph->nb_threads);
if (ret <= 1) {
- av_freep(&graph->internal->thread);
+ av_freep(&graphi->thread);
graph->thread_type = 0;
graph->nb_threads = 1;
return (ret < 0) ? ret : 0;
}
graph->nb_threads = ret;
- graph->internal->thread_execute = thread_execute;
+ graphi->thread_execute = thread_execute;
return 0;
}
-void ff_graph_thread_free(AVFilterGraph *graph)
+void ff_graph_thread_free(FFFilterGraph *graph)
{
- if (graph->internal->thread)
- slice_thread_uninit(graph->internal->thread);
- av_freep(&graph->internal->thread);
+ if (graph->thread)
+ slice_thread_uninit(graph->thread);
+ av_freep(&graph->thread);
}
--
2.34.1
More information about the ffmpeg-devel
mailing list