This is an automated email from the git hooks/post-receive script. Git pushed a commit to branch master in repository ffmpeg.
commit b2854aadce556094f9d3293ae8b5ebad1d9500ea Author: Kacper Michajłow <[email protected]> AuthorDate: Sun Sep 6 08:45:48 2026 +0200 Commit: Kacper Michajłow <[email protected]> CommitDate: Mon Sep 14 04:35:12 2026 +0200 compat/atomics: split the generic stdatomic.h from the backend primitives The win32 and dummy headers shared the whole standard surface, move it into common header and keep backend specific implementation in _impl.h headers. Signed-off-by: Kacper Michajłow <[email protected]> --- compat/atomics/dummy/stdatomic_impl.h | 106 ++++++++ compat/atomics/{dummy => }/stdatomic.h | 103 ++----- .../win32/{stdatomic.h => stdatomic_impl.h} | 298 +-------------------- configure | 1 + 4 files changed, 130 insertions(+), 378 deletions(-) diff --git a/compat/atomics/dummy/stdatomic_impl.h b/compat/atomics/dummy/stdatomic_impl.h new file mode 100644 index 0000000000..2e3f9a5760 --- /dev/null +++ b/compat/atomics/dummy/stdatomic_impl.h @@ -0,0 +1,106 @@ +/* + * 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 + */ + +#ifndef COMPAT_ATOMICS_DUMMY_STDATOMIC_IMPL_H +#define COMPAT_ATOMICS_DUMMY_STDATOMIC_IMPL_H + +#include <string.h> + +#define FF_ATOMIC_LOCK_FREE 0 +#define FF_ATOMIC_ALIGN64 + +#define ff_atomic_thread_fence(order) \ + ((void)(order)) + +#define ff_atomic_signal_fence(order) \ + ((void)(order)) + +/* + * The accesses go through memcpy instead of casted pointers to stay clear + * of strict-aliasing violations for types like long that have the size of + * an intN_t without being compatible with it. They are ordinary accesses, + * a volatile qualification of the object is not honoured. + */ +#define DUMMY_ATOMIC_FETCH(op, OP, name, type) \ +static av_always_inline type ff_atomic_##op##name(volatile void *object, \ + type operand, \ + memory_order order) \ +{ \ + type old = ff_atomic_load##name(object, order); \ + ff_atomic_store##name(object, old OP operand, order); \ + return old; \ +} + +#define DUMMY_ATOMIC_OPS(name, type) \ +static av_always_inline type \ +ff_atomic_load_##name(const volatile void *object, memory_order order) \ +{ \ + (void)order; \ + type v; \ + memcpy(&v, (const void *)object, sizeof(v)); \ + return v; \ +} \ + \ +static av_always_inline void ff_atomic_store_##name(volatile void *object, \ + type desired, \ + memory_order order) \ +{ \ + (void)order; \ + memcpy((void *)object, &desired, sizeof(desired)); \ +} \ + \ +static av_always_inline type ff_atomic_exchange_##name(volatile void *object, \ + type desired, \ + memory_order order) \ +{ \ + type old = ff_atomic_load_##name(object, order); \ + ff_atomic_store_##name(object, desired, order); \ + return old; \ +} \ + \ +static av_always_inline bool ff_atomic_cas_##name(volatile void *object, \ + void *expected, \ + type desired, \ + memory_order order) \ +{ \ + type old = ff_atomic_load_##name(object, order); \ + if (old == ff_atomic_load_##name(expected, order)) { \ + ff_atomic_store_##name(object, desired, order); \ + return 1; \ + } \ + ff_atomic_store_##name(expected, old, order); \ + return 0; \ +} \ + \ +DUMMY_ATOMIC_FETCH(fetch_add, +, _##name, type) \ +DUMMY_ATOMIC_FETCH(fetch_sub, -, _##name, type) \ +DUMMY_ATOMIC_FETCH(fetch_or, |, _##name, type) \ +DUMMY_ATOMIC_FETCH(fetch_xor, ^, _##name, type) \ +DUMMY_ATOMIC_FETCH(fetch_and, &, _##name, type) + +/* bool objects get their own set, for normalization */ +DUMMY_ATOMIC_OPS(bool, bool) +DUMMY_ATOMIC_OPS(8, uint8_t) +DUMMY_ATOMIC_OPS(16, uint16_t) +DUMMY_ATOMIC_OPS(32, uint32_t) +DUMMY_ATOMIC_OPS(64, uint64_t) + +#undef DUMMY_ATOMIC_OPS +#undef DUMMY_ATOMIC_FETCH + +#endif /* COMPAT_ATOMICS_DUMMY_STDATOMIC_IMPL_H */ diff --git a/compat/atomics/dummy/stdatomic.h b/compat/atomics/stdatomic.h similarity index 72% rename from compat/atomics/dummy/stdatomic.h rename to compat/atomics/stdatomic.h index 41e0cb4c26..71bc52c430 100644 --- a/compat/atomics/dummy/stdatomic.h +++ b/compat/atomics/stdatomic.h @@ -16,13 +16,12 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef COMPAT_ATOMICS_DUMMY_STDATOMIC_H -#define COMPAT_ATOMICS_DUMMY_STDATOMIC_H +#ifndef COMPAT_ATOMICS_STDATOMIC_H +#define COMPAT_ATOMICS_STDATOMIC_H #include <stdbool.h> #include <stddef.h> #include <stdint.h> -#include <string.h> #include "libavutil/attributes.h" @@ -35,87 +34,25 @@ typedef enum { memory_order_seq_cst } memory_order; -#define FF_ATOMIC_LOCK_FREE 0 -#define FF_ATOMIC_ALIGN64 - -#define ff_atomic_thread_fence(order) \ - ((void)(order)) - -#define ff_atomic_signal_fence(order) \ - ((void)(order)) - /* - * The accesses go through memcpy instead of casted pointers to stay clear - * of strict-aliasing violations for types like long that have the size of - * an intN_t without being compatible with it. They are ordinary accesses, - * a volatile qualification of the object is not honoured. + * The implementation header provides the primitives: + * - FF_ATOMIC_LOCK_FREE, the value of the ATOMIC_*_LOCK_FREE macros. + * - FF_ATOMIC_ALIGN64, the declaration specifier that aligns the 8-byte + * types to 8 bytes, empty where they are naturally aligned. + * - ff_atomic_thread_fence(order) and ff_atomic_signal_fence(order). + * - Helpers for the widths W = bool, 8, 16, 32 and 64, selected by the size + * of the object, taking it as a void pointer and the values as the + * unsigned integer type of the width, which every value of an object of + * the width converts to, bool for the bool set: + * type ff_atomic_load_W(object, memory_order order) + * void ff_atomic_store_W(object, type desired, memory_order order) + * type ff_atomic_exchange_W(object, type desired, memory_order order) + * bool ff_atomic_cas_W(object, void *expected, type desired, memory_order order) + * type ff_atomic_fetch_{add,sub,or,xor,and}_W(object, type operand, memory_order order) + * The _Generic dispatch below selects one by the object type, the argument + * and result conversions happen at the call. */ -#define DUMMY_ATOMIC_FETCH(op, OP, name, type) \ -static av_always_inline type ff_atomic_##op##name(volatile void *object, \ - type operand, \ - memory_order order) \ -{ \ - type old = ff_atomic_load##name(object, order); \ - ff_atomic_store##name(object, old OP operand, order); \ - return old; \ -} - -#define DUMMY_ATOMIC_OPS(name, type) \ -static av_always_inline type \ -ff_atomic_load_##name(const volatile void *object, memory_order order) \ -{ \ - (void)order; \ - type v; \ - memcpy(&v, (const void *)object, sizeof(v)); \ - return v; \ -} \ - \ -static av_always_inline void ff_atomic_store_##name(volatile void *object, \ - type desired, \ - memory_order order) \ -{ \ - (void)order; \ - memcpy((void *)object, &desired, sizeof(desired)); \ -} \ - \ -static av_always_inline type ff_atomic_exchange_##name(volatile void *object, \ - type desired, \ - memory_order order) \ -{ \ - type old = ff_atomic_load_##name(object, order); \ - ff_atomic_store_##name(object, desired, order); \ - return old; \ -} \ - \ -static av_always_inline bool ff_atomic_cas_##name(volatile void *object, \ - void *expected, \ - type desired, \ - memory_order order) \ -{ \ - type old = ff_atomic_load_##name(object, order); \ - if (old == ff_atomic_load_##name(expected, order)) { \ - ff_atomic_store_##name(object, desired, order); \ - return 1; \ - } \ - ff_atomic_store_##name(expected, old, order); \ - return 0; \ -} \ - \ -DUMMY_ATOMIC_FETCH(fetch_add, +, _##name, type) \ -DUMMY_ATOMIC_FETCH(fetch_sub, -, _##name, type) \ -DUMMY_ATOMIC_FETCH(fetch_or, |, _##name, type) \ -DUMMY_ATOMIC_FETCH(fetch_xor, ^, _##name, type) \ -DUMMY_ATOMIC_FETCH(fetch_and, &, _##name, type) - -/* bool objects get their own set, for normalization */ -DUMMY_ATOMIC_OPS(bool, bool) -DUMMY_ATOMIC_OPS(8, uint8_t) -DUMMY_ATOMIC_OPS(16, uint16_t) -DUMMY_ATOMIC_OPS(32, uint32_t) -DUMMY_ATOMIC_OPS(64, uint64_t) - -#undef DUMMY_ATOMIC_OPS -#undef DUMMY_ATOMIC_FETCH +#include "stdatomic_impl.h" typedef bool atomic_bool; typedef char atomic_char; @@ -395,4 +332,4 @@ typedef struct atomic_flag { #define atomic_flag_clear(object) \ atomic_flag_clear_explicit(object, memory_order_seq_cst) -#endif /* COMPAT_ATOMICS_DUMMY_STDATOMIC_H */ +#endif /* COMPAT_ATOMICS_STDATOMIC_H */ diff --git a/compat/atomics/win32/stdatomic.h b/compat/atomics/win32/stdatomic_impl.h similarity index 53% rename from compat/atomics/win32/stdatomic.h rename to compat/atomics/win32/stdatomic_impl.h index a70dc572d0..4d84b74962 100644 --- a/compat/atomics/win32/stdatomic.h +++ b/compat/atomics/win32/stdatomic_impl.h @@ -16,27 +16,13 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef COMPAT_ATOMICS_WIN32_STDATOMIC_H -#define COMPAT_ATOMICS_WIN32_STDATOMIC_H +#ifndef COMPAT_ATOMICS_WIN32_STDATOMIC_IMPL_H +#define COMPAT_ATOMICS_WIN32_STDATOMIC_IMPL_H -#include <stdbool.h> -#include <stddef.h> -#include <stdint.h> #include <string.h> #include <intrin.h> -#include "libavutil/attributes.h" - -typedef enum { - memory_order_relaxed, - memory_order_consume, - memory_order_acquire, - memory_order_release, - memory_order_acq_rel, - memory_order_seq_cst -} memory_order; - #define FF_ATOMIC_LOCK_FREE 2 /* x86 aligns the 8-byte automatic objects to 4 bytes, where an 8-byte access @@ -315,282 +301,4 @@ WIN32_ATOMIC_RMW(64, unsigned long long, _Interlocked, 64) #undef WIN32_ATOMIC_XCHG_REL #undef win32_InterlockedCompareExchange64 -typedef bool atomic_bool; -typedef char atomic_char; -typedef signed char atomic_schar; -typedef unsigned char atomic_uchar; -typedef short atomic_short; -typedef unsigned short atomic_ushort; -typedef int atomic_int; -typedef unsigned int atomic_uint; -typedef long atomic_long; -typedef unsigned long atomic_ulong; -typedef FF_ATOMIC_ALIGN64 long long atomic_llong; -typedef FF_ATOMIC_ALIGN64 unsigned long long atomic_ullong; -typedef unsigned char atomic_char8_t; -typedef uint_least16_t atomic_char16_t; -typedef uint_least32_t atomic_char32_t; -typedef wchar_t atomic_wchar_t; -typedef int_least8_t atomic_int_least8_t; -typedef uint_least8_t atomic_uint_least8_t; -typedef int_least16_t atomic_int_least16_t; -typedef uint_least16_t atomic_uint_least16_t; -typedef int_least32_t atomic_int_least32_t; -typedef uint_least32_t atomic_uint_least32_t; -typedef FF_ATOMIC_ALIGN64 int_least64_t atomic_int_least64_t; -typedef FF_ATOMIC_ALIGN64 uint_least64_t atomic_uint_least64_t; -typedef int_fast8_t atomic_int_fast8_t; -typedef uint_fast8_t atomic_uint_fast8_t; -typedef int_fast16_t atomic_int_fast16_t; -typedef uint_fast16_t atomic_uint_fast16_t; -typedef int_fast32_t atomic_int_fast32_t; -typedef uint_fast32_t atomic_uint_fast32_t; -typedef FF_ATOMIC_ALIGN64 int_fast64_t atomic_int_fast64_t; -typedef FF_ATOMIC_ALIGN64 uint_fast64_t atomic_uint_fast64_t; -typedef intptr_t atomic_intptr_t; -typedef uintptr_t atomic_uintptr_t; -typedef size_t atomic_size_t; -typedef ptrdiff_t atomic_ptrdiff_t; -typedef FF_ATOMIC_ALIGN64 intmax_t atomic_intmax_t; -typedef FF_ATOMIC_ALIGN64 uintmax_t atomic_uintmax_t; - -/* - * Emulation of the _Atomic qualifier form for integer and pointer types of at - * most 8 bytes. This has very limited support, and will fail to compile when - * used with other types. Notably: - * - The specifier form "_Atomic(T)" is not supported, a macro cannot - * provide both forms. - * - Loads and exchanges of pointer objects return void *, not T *. Function - * pointer objects rely on the common extension converting them to and - * from void *. - * - Enumerated types are not supported, MSVC does not match them against - * their underlying type in _Generic. - * - atomic_fetch_add() and atomic_fetch_sub() stay restricted to integer - * types, on pointers they would have to scale by the pointee size. - * - Plain accesses to atomic objects, _Atomic qualified or the atomic_* - * typedefs, are ordinary accesses, unlike in C11 where they are - * implicitly atomic. Every access has to go through the atomic_* - * functions. - * - The 8-byte typedefs carry the alignment their accesses need to be - * atomic where the compiler does not provide it, on 32-bit x86, the - * qualifier form cannot. - */ -#define _Atomic - -#define atomic_init(obj, value) ((void)(*(obj) = (value))) - -#define kill_dependency(y) (y) - -#define ATOMIC_BOOL_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_CHAR_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_CHAR8_T_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_CHAR16_T_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_CHAR32_T_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_WCHAR_T_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_SHORT_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_INT_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_LONG_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_LLONG_LOCK_FREE FF_ATOMIC_LOCK_FREE -#define ATOMIC_POINTER_LOCK_FREE FF_ATOMIC_LOCK_FREE - -#define atomic_is_lock_free(obj) ((void)(obj), (bool)(FF_ATOMIC_LOCK_FREE == 2)) - -#define atomic_thread_fence(order) ff_atomic_thread_fence(order) -#define atomic_signal_fence(order) ff_atomic_signal_fence(order) - -#define FF_ATOMIC_SIZE(op, size) \ - _Generic((char (*)[size])0, \ - char (*)[1]: ff_atomic_##op##_8, \ - char (*)[2]: ff_atomic_##op##_16, \ - char (*)[4]: ff_atomic_##op##_32, \ - char (*)[8]: ff_atomic_##op##_64) - -static av_always_inline uintptr_t -ff_atomic_load_ptr(const volatile void *object, memory_order order) -{ - return FF_ATOMIC_SIZE(load, sizeof(void *))(object, order); -} - -static av_always_inline void ff_atomic_store_ptr(volatile void *object, - const volatile void *desired, - memory_order order) -{ - FF_ATOMIC_SIZE(store, sizeof(void *))(object, (uintptr_t)desired, order); -} - -static av_always_inline uintptr_t -ff_atomic_exchange_ptr(volatile void *object, const volatile void *desired, - memory_order order) -{ - return FF_ATOMIC_SIZE(exchange, sizeof(void *))(object, (uintptr_t)desired, - order); -} - -static av_always_inline bool ff_atomic_cas_ptr(volatile void *object, - void *expected, - const volatile void *desired, - memory_order order) -{ - return FF_ATOMIC_SIZE(cas, sizeof(void *))(object, expected, - (uintptr_t)desired, order); -} - -void ff_atomic_unsupported(void); - -/* the pointer helpers, for the objects of the pointer size only */ -#define FF_ATOMIC_PTR(op, object) \ - _Generic((char (*)[sizeof(*(object))])0, \ - char (*)[sizeof(void *)]: ff_atomic_##op##_ptr, \ - default: ff_atomic_unsupported) - -/* MSVC before 19.44 does not treat char as its own type in _Generic. It matches - * either signed char or unsigned char, depending on /J, and rejects a separate - * char association as a duplicate. - * <https://developercommunity.visualstudio.com/t/_Generic-char-signed-char-unsigned-cha/1228885> */ -#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1944 -#define FF_ATOMIC_CHAR(x) -#else -#define FF_ATOMIC_CHAR(x) char: x, -#endif - -#define FF_ATOMIC_INT(op, object) \ - FF_ATOMIC_CHAR(FF_ATOMIC_SIZE(op, sizeof(*(object)))) \ - signed char: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - unsigned char: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - short: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - unsigned short: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - int: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - unsigned int: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - long: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - unsigned long: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - long long: FF_ATOMIC_SIZE(op, sizeof(*(object))), \ - unsigned long long: FF_ATOMIC_SIZE(op, sizeof(*(object))) - -/* bool objects have their own set for the normalization */ -#define FF_ATOMIC_FN(op, object) \ - _Generic(*(object), \ - bool: ff_atomic_##op##_bool, \ - FF_ATOMIC_INT(op, object), \ - default: FF_ATOMIC_PTR(op, object)) - -/* the fetch operations are for the integer objects only, bool is excluded - * and on pointers they would have to scale by the pointee size */ -#define FF_ATOMIC_FETCH_FN(op, object) \ - _Generic(*(object), FF_ATOMIC_INT(op, object)) - -/* the width or uintptr_t result back to the non-atomic type C */ -#define ff_atomic_c(object, x) \ - _Generic(*(object), \ - bool: (bool)(x), \ - FF_ATOMIC_CHAR((char)(x)) \ - signed char: (signed char)(x), \ - unsigned char: (unsigned char)(x), \ - short: (short)(x), \ - unsigned short: (unsigned short)(x), \ - int: (int)(x), \ - unsigned int: (unsigned int)(x), \ - long: (long)(x), \ - unsigned long: (unsigned long)(x), \ - long long: (long long)(x), \ - unsigned long long: (unsigned long long)(x), \ - default: (void *)(uintptr_t)(x)) - -#define atomic_load_explicit(object, order) \ - ff_atomic_c(object, FF_ATOMIC_FN(load, object)(object, order)) - -#define atomic_load(object) \ - atomic_load_explicit(object, memory_order_seq_cst) - -#define atomic_store_explicit(object, desired, order) \ - FF_ATOMIC_FN(store, object)(object, desired, order) - -#define atomic_store(object, desired) \ - atomic_store_explicit(object, desired, memory_order_seq_cst) - -#define atomic_exchange_explicit(object, desired, order) \ - ff_atomic_c(object, FF_ATOMIC_FN(exchange, object)(object, desired, order)) - -#define atomic_exchange(object, desired) \ - atomic_exchange_explicit(object, desired, memory_order_seq_cst) - -static av_always_inline memory_order ff_atomic_cas_order(memory_order success, - memory_order failure) -{ - if (success == memory_order_release && failure != memory_order_relaxed) - return memory_order_acq_rel; - return success; -} - -/* expected has to point to an object of the width of the atomic one */ -#define atomic_compare_exchange_strong_explicit(object, expected, desired, \ - success, failure) \ - ((void)_Generic((char (*)[sizeof(*(expected))])0, \ - char (*)[sizeof(*(object))]: 0), \ - FF_ATOMIC_FN(cas, object)(object, expected, desired, \ - ff_atomic_cas_order(success, failure))) - -#define atomic_compare_exchange_strong(object, expected, desired) \ - atomic_compare_exchange_strong_explicit(object, expected, desired, \ - memory_order_seq_cst, \ - memory_order_seq_cst) - -#define atomic_compare_exchange_weak_explicit(object, expected, desired, \ - success, failure) \ - atomic_compare_exchange_strong_explicit(object, expected, desired, \ - success, failure) - -#define atomic_compare_exchange_weak(object, expected, desired) \ - atomic_compare_exchange_strong(object, expected, desired) - -#define ff_atomic_fetch(object, operand, op, order) \ - ff_atomic_c(object, FF_ATOMIC_FETCH_FN(op, object)(object, operand, order)) - -#define atomic_fetch_add_explicit(object, operand, order) \ - ff_atomic_fetch(object, operand, fetch_add, order) - -#define atomic_fetch_sub_explicit(object, operand, order) \ - ff_atomic_fetch(object, operand, fetch_sub, order) - -#define atomic_fetch_or_explicit(object, operand, order) \ - ff_atomic_fetch(object, operand, fetch_or, order) - -#define atomic_fetch_xor_explicit(object, operand, order) \ - ff_atomic_fetch(object, operand, fetch_xor, order) - -#define atomic_fetch_and_explicit(object, operand, order) \ - ff_atomic_fetch(object, operand, fetch_and, order) - -#define atomic_fetch_add(object, operand) \ - atomic_fetch_add_explicit(object, operand, memory_order_seq_cst) - -#define atomic_fetch_sub(object, operand) \ - atomic_fetch_sub_explicit(object, operand, memory_order_seq_cst) - -#define atomic_fetch_or(object, operand) \ - atomic_fetch_or_explicit(object, operand, memory_order_seq_cst) - -#define atomic_fetch_xor(object, operand) \ - atomic_fetch_xor_explicit(object, operand, memory_order_seq_cst) - -#define atomic_fetch_and(object, operand) \ - atomic_fetch_and_explicit(object, operand, memory_order_seq_cst) - -typedef struct atomic_flag { - atomic_bool value; -} atomic_flag; - -#define ATOMIC_FLAG_INIT { 0 } - -#define atomic_flag_test_and_set_explicit(object, order) \ - atomic_exchange_explicit(&(object)->value, 1, order) - -#define atomic_flag_test_and_set(object) \ - atomic_flag_test_and_set_explicit(object, memory_order_seq_cst) - -#define atomic_flag_clear_explicit(object, order) \ - atomic_store_explicit(&(object)->value, 0, order) - -#define atomic_flag_clear(object) \ - atomic_flag_clear_explicit(object, memory_order_seq_cst) - -#endif /* COMPAT_ATOMICS_WIN32_STDATOMIC_H */ +#endif /* COMPAT_ATOMICS_WIN32_STDATOMIC_IMPL_H */ diff --git a/configure b/configure index e84ec098e6..472f04de76 100755 --- a/configure +++ b/configure @@ -8155,6 +8155,7 @@ for thread in $THREADS_LIST; do done if disabled stdatomic; then + add_cppflags '-I\$(SRC_PATH)/compat/atomics' if enabled atomics_win32; then add_cppflags '-I\$(SRC_PATH)/compat/atomics/win32' else -- To stop receiving notification emails like this one, please contact [email protected]. _______________________________________________ ffmpeg-cvslog mailing list -- [email protected] To unsubscribe send an email to [email protected]
