avfilter/avfiltergraph: Avoid allocation for AVFilterGraphInternal

To do this, allocate AVFilterGraphInternal jointly with AVFilterGraph
and rename it to FFFilterGraph in the process (similarly to
AVStream/FFStream).
The AVFilterGraphInternal* will be removed on the next major version
bump.

Signed-off-by: Andreas Rheinhardt <[email protected]>

Author: mkver

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(&li->fifo, &src->graph->internal->frame_queues);
+    ff_framequeue_init(&li->fifo, &fffiltergraph(src->graph)->frame_queues);
 
     return 0;
 }
@@ -904,9 +904,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;
     }

libavfilter/avfilter_internal.h

@@ -78,11 +78,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.
@@ -119,8 +128,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 */

libavfilter/avfiltergraph.c

@@ -67,33 +67,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;
 }
@@ -119,21 +116,21 @@ 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;
 
     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);
 }
 
@@ -169,12 +166,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;

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,36 +79,37 @@ 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) {
         graph->thread_type = 0;
         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);
 }