1
0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
FFmpeg/libavcodec/threadprogress.c
Andreas Rheinhardt 89828417b0 avcodec/threadprogress: Add new API for frame-threaded progress
The API is similar to the ThreadFrame API, with the exception
that it no longer has an included AVFrame and that it has its
own mutexes and condition variables which makes it more independent
of pthread_frame.c. One can wait on anything via a ThreadProgress.
One just has to ensure that the lifetime of the object containing
the ThreadProgress is long enough. This will typically be solved
by putting a ThreadProgress in a refcounted structure that is
shared between threads.

Reviewed-by: Anton Khirnov <anton@khirnov.net>
Reviewed-by: epirat07@gmail.com
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2024-04-19 13:07:48 +02:00

80 lines
2.6 KiB
C

/*
* Copyright (c) 2022 Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <limits.h>
#include <stdatomic.h>
#include "pthread_internal.h"
#include "threadprogress.h"
#include "libavutil/attributes.h"
#include "libavutil/thread.h"
DEFINE_OFFSET_ARRAY(ThreadProgress, thread_progress, init,
(offsetof(ThreadProgress, progress_mutex)),
(offsetof(ThreadProgress, progress_cond)));
av_cold int ff_thread_progress_init(ThreadProgress *pro, int init_mode)
{
atomic_init(&pro->progress, init_mode ? -1 : INT_MAX);
#if HAVE_THREADS
if (init_mode)
return ff_pthread_init(pro, thread_progress_offsets);
#endif
pro->init = init_mode;
return 0;
}
av_cold void ff_thread_progress_destroy(ThreadProgress *pro)
{
#if HAVE_THREADS
ff_pthread_free(pro, thread_progress_offsets);
#else
pro->init = 0;
#endif
}
void ff_thread_progress_report(ThreadProgress *pro, int n)
{
if (atomic_load_explicit(&pro->progress, memory_order_relaxed) >= n)
return;
atomic_store_explicit(&pro->progress, n, memory_order_release);
ff_mutex_lock(&pro->progress_mutex);
ff_cond_broadcast(&pro->progress_cond);
ff_mutex_unlock(&pro->progress_mutex);
}
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
{
/* Casting const away here is safe, because we only read from progress
* and will leave pro_c in the same state upon leaving the function
* as it had at the beginning. */
ThreadProgress *pro = (ThreadProgress*)pro_c;
if (atomic_load_explicit(&pro->progress, memory_order_acquire) >= n)
return;
ff_mutex_lock(&pro->progress_mutex);
while (atomic_load_explicit(&pro->progress, memory_order_relaxed) < n)
ff_cond_wait(&pro->progress_cond, &pro->progress_mutex);
ff_mutex_unlock(&pro->progress_mutex);
}