RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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 <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt 2024-02-10 18:26:54 +01:00
parent a1aec776f1
commit 03567ed80c
4 changed files with 44 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libavfilter/avfilter.c
View File

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

17
libavfilter/avfilter_internal.h
View File

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

34
libavfilter/avfiltergraph.c
View File

@ -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)
FFFilterGraph *graph = av_mallocz(sizeof(*graph));
AVFilterGraph *ret;
if (!graph)
return NULL;
ret->internal = av_mallocz(sizeof(*ret->internal));
if (!ret->internal) {
av_freep(&ret);
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,6 +116,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;
@ -126,14 +124,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);
}
@ -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;

23
libavfilter/pthread.c
View File

@ -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);
}