[FFmpeg-devel] [PATCH 31/35] avfilter/avfiltergraph: Avoid allocation for AVFilterGraphInternal

[Andreas Rheinhardt <andreas.rheinhardt@outlook.com>]

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@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

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".