...

ffmpeg/compat/aix/math.h

@@ -0,0 +1,31 @@
+/*
+ * Work around the class() function in AIX math.h clashing with
+ * identifiers named "class".
+ *
+ * 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_AIX_MATH_H
+#define COMPAT_AIX_MATH_H
+
+#define class class_in_math_h_causes_problems
+
+#include_next <math.h>
+
+#undef class
+
+#endif /* COMPAT_AIX_MATH_H */

ffmpeg/compat/atomics/dummy/stdatomic.h

@@ -0,0 +1,176 @@
+/*
+ * 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
+ */
+
+/*
+ * based on vlc_atomic.h from VLC
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ */
+
+#ifndef COMPAT_ATOMICS_DUMMY_STDATOMIC_H
+#define COMPAT_ATOMICS_DUMMY_STDATOMIC_H
+
+#include <stdint.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    ((void)0)
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (*(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+static inline intptr_t atomic_exchange(intptr_t *object, intptr_t desired)
+{
+    intptr_t ret = *object;
+    *object = desired;
+    return ret;
+}
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    int ret;
+    if (*object == *expected) {
+        *object = desired;
+        ret = 1;
+    } else {
+        *expected = *object;
+        ret = 0;
+    }
+    return ret;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#define FETCH_MODIFY(opname, op)                                            \
+static inline intptr_t atomic_fetch_ ## opname(intptr_t *object, intptr_t operand) \
+{                                                                    \
+    intptr_t ret;                                                    \
+    ret = *object;                                                   \
+    *object = *object op operand;                                    \
+    return ret;                                                      \
+}
+
+FETCH_MODIFY(add, +)
+FETCH_MODIFY(sub, -)
+FETCH_MODIFY(or,  |)
+FETCH_MODIFY(xor, ^)
+FETCH_MODIFY(and, &)
+
+#undef FETCH_MODIFY
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_DUMMY_STDATOMIC_H */

ffmpeg/compat/atomics/win32/stdatomic.h

@@ -0,0 +1,180 @@
+/*
+ * 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_WIN32_STDATOMIC_H
+#define COMPAT_ATOMICS_WIN32_STDATOMIC_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <windows.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    MemoryBarrier();
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+    MemoryBarrier();                    \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (MemoryBarrier(), *(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired) \
+    InterlockedExchangePointer((PVOID volatile *)object, (PVOID)desired)
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    intptr_t old = *expected;
+    *expected = (intptr_t)InterlockedCompareExchangePointer(
+        (PVOID *)object, (PVOID)desired, (PVOID)old);
+    return *expected == old;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#ifdef _WIN64
+#define atomic_fetch_add(object, operand) \
+    InterlockedExchangeAdd64(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    InterlockedExchangeAdd64(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+    InterlockedOr64(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    InterlockedXor64(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    InterlockedAnd64(object, operand)
+#else
+#define atomic_fetch_add(object, operand) \
+    InterlockedExchangeAdd(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    InterlockedExchangeAdd(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+    InterlockedOr(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    InterlockedXor(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    InterlockedAnd(object, operand)
+#endif /* _WIN64 */
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_WIN32_STDATOMIC_H */

ffmpeg/compat/cuda/cuda_runtime.h

@@ -0,0 +1,195 @@
+/*
+ * Minimum CUDA compatibility definitions header
+ *
+ * Copyright (c) 2019 rcombs
+ *
+ * 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_CUDA_CUDA_RUNTIME_H
+#define COMPAT_CUDA_CUDA_RUNTIME_H
+
+// Common macros
+#define __global__ __attribute__((global))
+#define __device__ __attribute__((device))
+#define __device_builtin__ __attribute__((device_builtin))
+#define __align__(N) __attribute__((aligned(N)))
+#define __inline__ __inline__ __attribute__((always_inline))
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define abs(x) ((x) < 0 ? -(x) : (x))
+
+#define atomicAdd(a, b) (__atomic_fetch_add(a, b, __ATOMIC_SEQ_CST))
+
+// Basic typedefs
+typedef __device_builtin__ unsigned long long cudaTextureObject_t;
+
+typedef struct __device_builtin__ __align__(2) uchar2
+{
+    unsigned char x, y;
+} uchar2;
+
+typedef struct __device_builtin__ __align__(4) ushort2
+{
+    unsigned short x, y;
+} ushort2;
+
+typedef struct __device_builtin__ __align__(8) float2
+{
+    float x, y;
+} float2;
+
+typedef struct __device_builtin__ __align__(8) int2
+{
+    int x, y;
+} int2;
+
+typedef struct __device_builtin__ uint3
+{
+    unsigned int x, y, z;
+} uint3;
+
+typedef struct uint3 dim3;
+
+typedef struct __device_builtin__ __align__(4) uchar4
+{
+    unsigned char x, y, z, w;
+} uchar4;
+
+typedef struct __device_builtin__ __align__(8) ushort4
+{
+    unsigned short x, y, z, w;
+} ushort4;
+
+typedef struct __device_builtin__ __align__(16) int4
+{
+    int x, y, z, w;
+} int4;
+
+typedef struct __device_builtin__ __align__(16) float4
+{
+    float x, y, z, w;
+} float4;
+
+// Accessors for special registers
+#define GETCOMP(reg, comp) \
+    asm("mov.u32 %0, %%" #reg "." #comp ";" : "=r"(tmp)); \
+    ret.comp = tmp;
+
+#define GET(name, reg) static inline __device__ uint3 name() {\
+    uint3 ret; \
+    unsigned tmp; \
+    GETCOMP(reg, x) \
+    GETCOMP(reg, y) \
+    GETCOMP(reg, z) \
+    return ret; \
+}
+
+GET(getBlockIdx, ctaid)
+GET(getBlockDim, ntid)
+GET(getThreadIdx, tid)
+
+// Instead of externs for these registers, we turn access to them into calls into trivial ASM
+#define blockIdx (getBlockIdx())
+#define blockDim (getBlockDim())
+#define threadIdx (getThreadIdx())
+
+// Basic initializers (simple macros rather than inline functions)
+#define make_int2(a, b) ((int2){.x = a, .y = b})
+#define make_uchar2(a, b) ((uchar2){.x = a, .y = b})
+#define make_ushort2(a, b) ((ushort2){.x = a, .y = b})
+#define make_float2(a, b) ((float2){.x = a, .y = b})
+#define make_int4(a, b, c, d) ((int4){.x = a, .y = b, .z = c, .w = d})
+#define make_uchar4(a, b, c, d) ((uchar4){.x = a, .y = b, .z = c, .w = d})
+#define make_ushort4(a, b, c, d) ((ushort4){.x = a, .y = b, .z = c, .w = d})
+#define make_float4(a, b, c, d) ((float4){.x = a, .y = b, .z = c, .w = d})
+
+// Conversions from the tex instruction's 4-register output to various types
+#define TEX2D(type, ret) static inline __device__ void conv(type* out, unsigned a, unsigned b, unsigned c, unsigned d) {*out = (ret);}
+
+TEX2D(unsigned char, a & 0xFF)
+TEX2D(unsigned short, a & 0xFFFF)
+TEX2D(float, a)
+TEX2D(uchar2, make_uchar2(a & 0xFF, b & 0xFF))
+TEX2D(ushort2, make_ushort2(a & 0xFFFF, b & 0xFFFF))
+TEX2D(float2, make_float2(a, b))
+TEX2D(uchar4, make_uchar4(a & 0xFF, b & 0xFF, c & 0xFF, d & 0xFF))
+TEX2D(ushort4, make_ushort4(a & 0xFFFF, b & 0xFFFF, c & 0xFFFF, d & 0xFFFF))
+TEX2D(float4, make_float4(a, b, c, d))
+
+// Template calling tex instruction and converting the output to the selected type
+template<typename T>
+inline __device__ T tex2D(cudaTextureObject_t texObject, float x, float y)
+{
+  T ret;
+  unsigned ret1, ret2, ret3, ret4;
+  asm("tex.2d.v4.u32.f32 {%0, %1, %2, %3}, [%4, {%5, %6}];" :
+      "=r"(ret1), "=r"(ret2), "=r"(ret3), "=r"(ret4) :
+      "l"(texObject), "f"(x), "f"(y));
+  conv(&ret, ret1, ret2, ret3, ret4);
+  return ret;
+}
+
+template<>
+inline __device__ float4 tex2D<float4>(cudaTextureObject_t texObject, float x, float y)
+{
+    float4 ret;
+    asm("tex.2d.v4.f32.f32 {%0, %1, %2, %3}, [%4, {%5, %6}];" :
+        "=r"(ret.x), "=r"(ret.y), "=r"(ret.z), "=r"(ret.w) :
+        "l"(texObject), "f"(x), "f"(y));
+    return ret;
+}
+
+template<>
+inline __device__ float tex2D<float>(cudaTextureObject_t texObject, float x, float y)
+{
+    return tex2D<float4>(texObject, x, y).x;
+}
+
+template<>
+inline __device__ float2 tex2D<float2>(cudaTextureObject_t texObject, float x, float y)
+{
+    float4 ret = tex2D<float4>(texObject, x, y);
+    return make_float2(ret.x, ret.y);
+}
+
+// Math helper functions
+static inline __device__ float floorf(float a) { return __builtin_floorf(a); }
+static inline __device__ float floor(float a) { return __builtin_floorf(a); }
+static inline __device__ double floor(double a) { return __builtin_floor(a); }
+static inline __device__ float ceilf(float a) { return __builtin_ceilf(a); }
+static inline __device__ float ceil(float a) { return __builtin_ceilf(a); }
+static inline __device__ double ceil(double a) { return __builtin_ceil(a); }
+static inline __device__ float truncf(float a) { return __builtin_truncf(a); }
+static inline __device__ float trunc(float a) { return __builtin_truncf(a); }
+static inline __device__ double trunc(double a) { return __builtin_trunc(a); }
+static inline __device__ float fabsf(float a) { return __builtin_fabsf(a); }
+static inline __device__ float fabs(float a) { return __builtin_fabsf(a); }
+static inline __device__ double fabs(double a) { return __builtin_fabs(a); }
+static inline __device__ float sqrtf(float a) { return __builtin_sqrtf(a); }
+
+static inline __device__ float __saturatef(float a) { return __nvvm_saturate_f(a); }
+static inline __device__ float __sinf(float a) { return __nvvm_sin_approx_f(a); }
+static inline __device__ float __cosf(float a) { return __nvvm_cos_approx_f(a); }
+static inline __device__ float __expf(float a) { return __nvvm_ex2_approx_f(a * (float)__builtin_log2(__builtin_exp(1))); }
+static inline __device__ float __powf(float a, float b) { return __nvvm_ex2_approx_f(__nvvm_lg2_approx_f(a) * b); }
+
+// Misc helper functions
+extern "C" __device__ int printf(const char*, ...);
+
+#endif /* COMPAT_CUDA_CUDA_RUNTIME_H */

ffmpeg/compat/cuda/dynlink_loader.h

@@ -0,0 +1,33 @@
+/*
+ * 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_CUDA_DYNLINK_LOADER_H
+#define COMPAT_CUDA_DYNLINK_LOADER_H
+
+#include "libavutil/log.h"
+#include "compat/w32dlfcn.h"
+
+#define FFNV_LOAD_FUNC(path) dlopen((path), RTLD_LAZY)
+#define FFNV_SYM_FUNC(lib, sym) dlsym((lib), (sym))
+#define FFNV_FREE_FUNC(lib) dlclose(lib)
+#define FFNV_LOG_FUNC(logctx, msg, ...) av_log(logctx, AV_LOG_ERROR, msg,  __VA_ARGS__)
+#define FFNV_DEBUG_LOG_FUNC(logctx, msg, ...) av_log(logctx, AV_LOG_DEBUG, msg,  __VA_ARGS__)
+
+#include <ffnvcodec/dynlink_loader.h>
+
+#endif /* COMPAT_CUDA_DYNLINK_LOADER_H */

ffmpeg/compat/dispatch_semaphore/semaphore.h

@@ -0,0 +1,42 @@
+/*
+ * 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_DISPATCH_SEMAPHORE_SEMAPHORE_H
+#define COMPAT_DISPATCH_SEMAPHORE_SEMAPHORE_H
+
+#include <dispatch/dispatch.h>
+#include <errno.h>
+
+#define sem_t dispatch_semaphore_t
+#define sem_post(psem)              dispatch_semaphore_signal(*psem)
+#define sem_wait(psem)              dispatch_semaphore_wait(*psem, DISPATCH_TIME_FOREVER)
+#define sem_timedwait(psem, val)    dispatch_semaphore_wait(*psem, dispatch_walltime(val, 0))
+#define sem_destroy(psem)           dispatch_release(*psem)
+
+static inline int compat_sem_init(dispatch_semaphore_t *psem,
+                                  int unused, int val)
+{
+    int ret = !!(*psem = dispatch_semaphore_create(val)) - 1;
+    if (ret < 0)
+        errno = ENOMEM;
+    return ret;
+}
+
+#define sem_init compat_sem_init
+
+#endif /* COMPAT_DISPATCH_SEMAPHORE_SEMAPHORE_H */

ffmpeg/compat/djgpp/math.c

@@ -0,0 +1,47 @@
+/*
+ * 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 <math.h>
+
+#define FUN(name, type, op) \
+type name(type x, type y) \
+{ \
+    if (fpclassify(x) == FP_NAN) return y; \
+    if (fpclassify(y) == FP_NAN) return x; \
+    return x op y ? x : y; \
+}
+
+FUN(fmin, double, <)
+FUN(fmax, double, >)
+FUN(fminf, float, <)
+FUN(fmaxf, float, >)
+
+long double fmodl(long double x, long double y)
+{
+    return fmod(x, y);
+}
+
+long double scalbnl(long double x, int exp)
+{
+    return scalbn(x, exp);
+}
+
+long double copysignl(long double x, long double y)
+{
+    return copysign(x, y);
+}

ffmpeg/compat/djgpp/math.h

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+
+double fmin(double, double);
+double fmax(double, double);
+float fminf(float, float);
+float fmaxf(float, float);
+long double fmodl(long double, long double);
+long double scalbnl(long double, int);
+long double copysignl(long double, long double);

ffmpeg/compat/float/float.h

@@ -0,0 +1,35 @@
+/*
+ * Work around broken floating point limits on some systems.
+ *
+ * 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_next <float.h>
+
+#ifdef FLT_MAX
+#undef  FLT_MAX
+#define FLT_MAX 3.40282346638528859812e+38F
+
+#undef  FLT_MIN
+#define FLT_MIN 1.17549435082228750797e-38F
+
+#undef  DBL_MAX
+#define DBL_MAX ((double)1.79769313486231570815e+308L)
+
+#undef  DBL_MIN
+#define DBL_MIN ((double)2.22507385850720138309e-308L)
+#endif

ffmpeg/compat/float/limits.h

@@ -0,0 +1,22 @@
+/*
+ * Work around broken floating point limits on some systems.
+ *
+ * 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_next <limits.h>
+#include <float.h>

ffmpeg/compat/getopt.c

@@ -0,0 +1,84 @@
+/*
+ * 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
+ */
+
+/*
+ * This file was copied from the following newsgroup posting:
+ *
+ * Newsgroups: mod.std.unix
+ * Subject: public domain AT&T getopt source
+ * Date: 3 Nov 85 19:34:15 GMT
+ *
+ * Here's something you've all been waiting for:  the AT&T public domain
+ * source for getopt(3).  It is the code which was given out at the 1985
+ * UNIFORUM conference in Dallas.  I obtained it by electronic mail
+ * directly from AT&T.  The people there assure me that it is indeed
+ * in the public domain.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+static int opterr = 1;
+static int optind = 1;
+static int optopt;
+static char *optarg;
+
+static int getopt(int argc, char *argv[], char *opts)
+{
+    static int sp = 1;
+    int c;
+    char *cp;
+
+    if (sp == 1) {
+        if (optind >= argc ||
+            argv[optind][0] != '-' || argv[optind][1] == '\0')
+            return EOF;
+        else if (!strcmp(argv[optind], "--")) {
+            optind++;
+            return EOF;
+        }
+    }
+    optopt = c = argv[optind][sp];
+    if (c == ':' || !(cp = strchr(opts, c))) {
+        fprintf(stderr, ": illegal option -- %c\n", c);
+        if (argv[optind][++sp] == '\0') {
+            optind++;
+            sp = 1;
+        }
+        return '?';
+    }
+    if (*++cp == ':') {
+        if (argv[optind][sp+1] != '\0')
+            optarg = &argv[optind++][sp+1];
+        else if(++optind >= argc) {
+            fprintf(stderr, ": option requires an argument -- %c\n", c);
+            sp = 1;
+            return '?';
+        } else
+            optarg = argv[optind++];
+        sp = 1;
+    } else {
+        if (argv[optind][++sp] == '\0') {
+            sp = 1;
+            optind++;
+        }
+        optarg = NULL;
+    }
+
+    return c;
+}

ffmpeg/compat/msvcrt/snprintf.c

@@ -0,0 +1,71 @@
+/*
+ * C99-compatible snprintf() and vsnprintf() implementations
+ * Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.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 <stdio.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <string.h>
+
+#include "compat/va_copy.h"
+#include "libavutil/error.h"
+
+#if defined(__MINGW32__)
+#define EOVERFLOW EFBIG
+#endif
+
+int avpriv_snprintf(char *s, size_t n, const char *fmt, ...)
+{
+    va_list ap;
+    int ret;
+
+    va_start(ap, fmt);
+    ret = avpriv_vsnprintf(s, n, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+int avpriv_vsnprintf(char *s, size_t n, const char *fmt,
+                     va_list ap)
+{
+    int ret;
+    va_list ap_copy;
+
+    if (n == 0)
+        return _vscprintf(fmt, ap);
+    else if (n > INT_MAX)
+        return AVERROR(EOVERFLOW);
+
+    /* we use n - 1 here because if the buffer is not big enough, the MS
+     * runtime libraries don't add a terminating zero at the end. MSDN
+     * recommends to provide _snprintf/_vsnprintf() a buffer size that
+     * is one less than the actual buffer, and zero it before calling
+     * _snprintf/_vsnprintf() to workaround this problem.
+     * See https://web.archive.org/web/20151214111935/http://msdn.microsoft.com/en-us/library/1kt27hek(v=vs.80).aspx */
+    memset(s, 0, n);
+    va_copy(ap_copy, ap);
+    ret = _vsnprintf(s, n - 1, fmt, ap_copy);
+    va_end(ap_copy);
+    if (ret == -1)
+        ret = _vscprintf(fmt, ap);
+
+    return ret;
+}

ffmpeg/compat/msvcrt/snprintf.h

@@ -0,0 +1,38 @@
+/*
+ * C99-compatible snprintf() and vsnprintf() implementations
+ * Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.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
+ */
+
+#ifndef COMPAT_MSVCRT_SNPRINTF_H
+#define COMPAT_MSVCRT_SNPRINTF_H
+
+#include <stdarg.h>
+#include <stdio.h>
+
+int avpriv_snprintf(char *s, size_t n, const char *fmt, ...);
+int avpriv_vsnprintf(char *s, size_t n, const char *fmt, va_list ap);
+
+#undef snprintf
+#undef _snprintf
+#undef vsnprintf
+#define snprintf avpriv_snprintf
+#define _snprintf avpriv_snprintf
+#define vsnprintf avpriv_vsnprintf
+
+#endif /* COMPAT_MSVCRT_SNPRINTF_H */

ffmpeg/compat/os2threads.h

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2011-2017 KO Myung-Hun <komh@chollian.net>
+ *
+ * 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
+ */
+
+/**
+ * @file
+ * os2threads to pthreads wrapper
+ */
+
+#ifndef COMPAT_OS2THREADS_H
+#define COMPAT_OS2THREADS_H
+
+#define INCL_DOS
+#define INCL_DOSERRORS
+#include <os2.h>
+
+#undef __STRICT_ANSI__          /* for _beginthread() */
+#include <stdlib.h>
+#include <time.h>
+
+#include <sys/builtin.h>
+#include <sys/fmutex.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/common.h"
+#include "libavutil/time.h"
+
+typedef struct {
+    TID tid;
+    void *(*start_routine)(void *);
+    void *arg;
+    void *result;
+} pthread_t;
+
+typedef void pthread_attr_t;
+
+typedef _fmutex pthread_mutex_t;
+typedef void pthread_mutexattr_t;
+
+#define PTHREAD_MUTEX_INITIALIZER _FMUTEX_INITIALIZER
+
+typedef struct {
+    HEV event_sem;
+    HEV ack_sem;
+    volatile unsigned  wait_count;
+} pthread_cond_t;
+
+typedef void pthread_condattr_t;
+
+typedef struct {
+    volatile int done;
+    _fmutex mtx;
+} pthread_once_t;
+
+#define PTHREAD_ONCE_INIT {0, _FMUTEX_INITIALIZER}
+
+static void thread_entry(void *arg)
+{
+    pthread_t *thread = arg;
+
+    thread->result = thread->start_routine(thread->arg);
+}
+
+static av_always_inline int pthread_create(pthread_t *thread,
+                                           const pthread_attr_t *attr,
+                                           void *(*start_routine)(void*),
+                                           void *arg)
+{
+    thread->start_routine = start_routine;
+    thread->arg = arg;
+    thread->result = NULL;
+
+    thread->tid = _beginthread(thread_entry, NULL, 1024 * 1024, thread);
+
+    return 0;
+}
+
+static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
+{
+    DosWaitThread(&thread.tid, DCWW_WAIT);
+
+    if (value_ptr)
+        *value_ptr = thread.result;
+
+    return 0;
+}
+
+static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex,
+                                               const pthread_mutexattr_t *attr)
+{
+    _fmutex_create(mutex, 0);
+
+    return 0;
+}
+
+static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+    _fmutex_close(mutex);
+
+    return 0;
+}
+
+static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+    _fmutex_request(mutex, 0);
+
+    return 0;
+}
+
+static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+    _fmutex_release(mutex);
+
+    return 0;
+}
+
+static av_always_inline int pthread_cond_init(pthread_cond_t *cond,
+                                              const pthread_condattr_t *attr)
+{
+    DosCreateEventSem(NULL, &cond->event_sem, DCE_POSTONE, FALSE);
+    DosCreateEventSem(NULL, &cond->ack_sem, DCE_POSTONE, FALSE);
+
+    cond->wait_count = 0;
+
+    return 0;
+}
+
+static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
+{
+    DosCloseEventSem(cond->event_sem);
+    DosCloseEventSem(cond->ack_sem);
+
+    return 0;
+}
+
+static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
+{
+    if (!__atomic_cmpxchg32(&cond->wait_count, 0, 0)) {
+        DosPostEventSem(cond->event_sem);
+        DosWaitEventSem(cond->ack_sem, SEM_INDEFINITE_WAIT);
+    }
+
+    return 0;
+}
+
+static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+    while (!__atomic_cmpxchg32(&cond->wait_count, 0, 0))
+        pthread_cond_signal(cond);
+
+    return 0;
+}
+
+static av_always_inline int pthread_cond_timedwait(pthread_cond_t *cond,
+                                                   pthread_mutex_t *mutex,
+                                                   const struct timespec *abstime)
+{
+    int64_t abs_milli = abstime->tv_sec * 1000LL + abstime->tv_nsec / 1000000;
+    ULONG t = av_clip64(abs_milli - av_gettime() / 1000, 0, ULONG_MAX);
+
+    __atomic_increment(&cond->wait_count);
+
+    pthread_mutex_unlock(mutex);
+
+    APIRET ret = DosWaitEventSem(cond->event_sem, t);
+
+    __atomic_decrement(&cond->wait_count);
+
+    DosPostEventSem(cond->ack_sem);
+
+    pthread_mutex_lock(mutex);
+
+    return (ret == ERROR_TIMEOUT) ? ETIMEDOUT : 0;
+}
+
+static av_always_inline int pthread_cond_wait(pthread_cond_t *cond,
+                                              pthread_mutex_t *mutex)
+{
+    __atomic_increment(&cond->wait_count);
+
+    pthread_mutex_unlock(mutex);
+
+    DosWaitEventSem(cond->event_sem, SEM_INDEFINITE_WAIT);
+
+    __atomic_decrement(&cond->wait_count);
+
+    DosPostEventSem(cond->ack_sem);
+
+    pthread_mutex_lock(mutex);
+
+    return 0;
+}
+
+static av_always_inline int pthread_once(pthread_once_t *once_control,
+                                         void (*init_routine)(void))
+{
+    if (!once_control->done)
+    {
+        _fmutex_request(&once_control->mtx, 0);
+
+        if (!once_control->done)
+        {
+            init_routine();
+
+            once_control->done = 1;
+        }
+
+        _fmutex_release(&once_control->mtx);
+    }
+
+    return 0;
+}
+#endif /* COMPAT_OS2THREADS_H */

ffmpeg/compat/solaris/make_sunver.pl

@@ -0,0 +1,352 @@
+#!/usr/bin/env perl
+
+# make_sunver.pl
+#
+#   Copyright (C) 2010, 2011, 2012, 2013
+#   Free Software Foundation, Inc.
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING.GPLv3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# This script takes at least two arguments, a GNU style version script and
+# a list of object and archive files, and generates a corresponding Sun
+# style version script as follows:
+#
+# Each glob pattern, C++ mangled pattern or literal in the input script is
+# matched against all global symbols in the input objects, emitting those
+# that matched (or nothing if no match was found).
+# A comment with the original pattern and its type is left in the output
+# file to make it easy to understand the matches.
+#
+# It uses elfdump when present (native), GNU readelf otherwise.
+# It depends on the GNU version of c++filt, since it must understand the
+# GNU mangling style.
+
+use FileHandle;
+use IPC::Open2;
+
+# Enforce C locale.
+$ENV{'LC_ALL'} = "C";
+$ENV{'LANG'} = "C";
+
+# Input version script, GNU style.
+my $symvers = shift;
+
+##########
+# Get all the symbols from the library, match them, and add them to a hash.
+
+my %sym_hash = ();
+
+# List of objects and archives to process.
+my @OBJECTS = ();
+
+# List of shared objects to omit from processing.
+my @SHAREDOBJS = ();
+
+# Filter out those input archives that have corresponding shared objects to
+# avoid adding all symbols matched in the archive to the output map.
+foreach $file (@ARGV) {
+    if (($so = $file) =~ s/\.a$/.so/ && -e $so) {
+    printf STDERR "omitted $file -> $so\n";
+    push (@SHAREDOBJS, $so);
+    } else {
+    push (@OBJECTS, $file);
+    }
+}
+
+# We need to detect and ignore hidden symbols.  Solaris nm can only detect
+# this in the harder to parse default output format, and GNU nm not at all,
+# so use elfdump -s in the native case and GNU readelf -s otherwise.
+# GNU objdump -t cannot be used since it produces a variable number of
+# columns.
+
+# The path to elfdump.
+my $elfdump = "/usr/ccs/bin/elfdump";
+
+if (-f $elfdump) {
+    open ELFDUMP,$elfdump.' -s '.(join ' ',@OBJECTS).'|' or die $!;
+    my $skip_arsym = 0;
+
+    while (<ELFDUMP>) {
+    chomp;
+
+    # Ignore empty lines.
+    if (/^$/) {
+        # End of archive symbol table, stop skipping.
+        $skip_arsym = 0 if $skip_arsym;
+        next;
+    }
+
+    # Keep skipping until end of archive symbol table.
+    next if ($skip_arsym);
+
+    # Ignore object name header for individual objects and archives.
+    next if (/:$/);
+
+    # Ignore table header lines.
+    next if (/^Symbol Table Section:/);
+    next if (/index.*value.*size/);
+
+    # Start of archive symbol table: start skipping.
+    if (/^Symbol Table: \(archive/) {
+        $skip_arsym = 1;
+        next;
+    }
+
+    # Split table.
+    (undef, undef, undef, undef, $bind, $oth, undef, $shndx, $name) = split;
+
+    # Error out for unknown input.
+    die "unknown input line:\n$_" unless defined($bind);
+
+    # Ignore local symbols.
+    next if ($bind eq "LOCL");
+    # Ignore hidden symbols.
+    next if ($oth eq "H");
+    # Ignore undefined symbols.
+    next if ($shndx eq "UNDEF");
+    # Error out for unhandled cases.
+    if ($bind !~ /^(GLOB|WEAK)/ or $oth ne "D") {
+        die "unhandled symbol:\n$_";
+    }
+
+    # Remember symbol.
+    $sym_hash{$name}++;
+    }
+    close ELFDUMP or die "$elfdump error";
+} else {
+    open READELF, 'readelf -s -W '.(join ' ',@OBJECTS).'|' or die $!;
+    # Process each symbol.
+    while (<READELF>) {
+    chomp;
+
+    # Ignore empty lines.
+    next if (/^$/);
+
+    # Ignore object name header.
+    next if (/^File: .*$/);
+
+    # Ignore table header lines.
+    next if (/^Symbol table.*contains.*:/);
+    next if (/Num:.*Value.*Size/);
+
+    # Split table.
+    (undef, undef, undef, undef, $bind, $vis, $ndx, $name) = split;
+
+    # Error out for unknown input.
+    die "unknown input line:\n$_" unless defined($bind);
+
+    # Ignore local symbols.
+    next if ($bind eq "LOCAL");
+    # Ignore hidden symbols.
+    next if ($vis eq "HIDDEN");
+    # Ignore undefined symbols.
+    next if ($ndx eq "UND");
+    # Error out for unhandled cases.
+    if ($bind !~ /^(GLOBAL|WEAK)/ or $vis ne "DEFAULT") {
+        die "unhandled symbol:\n$_";
+    }
+
+    # Remember symbol.
+    $sym_hash{$name}++;
+    }
+    close READELF or die "readelf error";
+}
+
+##########
+# The various types of glob patterns.
+#
+# A glob pattern that is to be applied to the demangled name: 'cxx'.
+# A glob patterns that applies directly to the name in the .o files: 'glob'.
+# This pattern is ignored; used for local variables (usually just '*'): 'ign'.
+
+# The type of the current pattern.
+my $glob = 'glob';
+
+# We're currently inside `extern "C++"', which Sun ld doesn't understand.
+my $in_extern = 0;
+
+# The c++filt command to use.  This *must* be GNU c++filt; the Sun Studio
+# c++filt doesn't handle the GNU mangling style.
+my $cxxfilt = $ENV{'CXXFILT'} || "c++filt";
+
+# The current version name.
+my $current_version = "";
+
+# Was there any attempt to match a symbol to this version?
+my $matches_attempted;
+
+# The number of versions which matched this symbol.
+my $matched_symbols;
+
+open F,$symvers or die $!;
+
+# Print information about generating this file
+print "# This file was generated by make_sunver.pl.  DO NOT EDIT!\n";
+print "# It was generated by:\n";
+printf "# %s %s %s\n", $0, $symvers, (join ' ',@ARGV);
+printf "# Omitted archives with corresponding shared libraries: %s\n",
+    (join ' ', @SHAREDOBJS) if $#SHAREDOBJS >= 0;
+print "#\n\n";
+
+print "\$mapfile_version 2\n";
+
+while (<F>) {
+    # Lines of the form '};'
+    if (/^([ \t]*)(\}[ \t]*;[ \t]*)$/) {
+    $glob = 'glob';
+    if ($in_extern) {
+        $in_extern--;
+        print "$1##$2\n";
+    } else {
+        print;
+    }
+    next;
+    }
+
+    # Lines of the form '} SOME_VERSION_NAME_1.0;'
+    if (/^[ \t]*\}[ \tA-Z0-9_.a-z]+;[ \t]*$/) {
+    $glob = 'glob';
+    # We tried to match symbols against this version, but none matched.
+    # Emit dummy hidden symbol to avoid marking this version WEAK.
+    if ($matches_attempted && $matched_symbols == 0) {
+        print "  hidden:\n";
+        print "    .force_WEAK_off_$current_version = DATA S0x0 V0x0;\n";
+    }
+    print; next;
+    }
+
+    # Comment and blank lines
+    if (/^[ \t]*\#/) { print; next; }
+    if (/^[ \t]*$/) { print; next; }
+
+    # Lines of the form '{'
+    if (/^([ \t]*){$/) {
+    if ($in_extern) {
+        print "$1##{\n";
+    } else {
+        print;
+    }
+    next;
+    }
+
+    # Lines of the form 'SOME_VERSION_NAME_1.1 {'
+    if (/^([A-Z0-9_.]+)[ \t]+{$/) {
+    # Record version name.
+    $current_version = $1;
+    # Reset match attempts, #matched symbols for this version.
+    $matches_attempted = 0;
+    $matched_symbols = 0;
+    print "SYMBOL_VERSION $1 {\n";
+    next;
+    }
+
+    # Ignore 'global:'
+    if (/^[ \t]*global:$/) { print; next; }
+
+    # After 'local:', globs should be ignored, they won't be exported.
+    if (/^[ \t]*local:$/) {
+    $glob = 'ign';
+    print;
+    next;
+    }
+
+    # After 'extern "C++"', globs are C++ patterns
+    if (/^([ \t]*)(extern \"C\+\+\"[ \t]*)$/) {
+    $in_extern++;
+    $glob = 'cxx';
+    # Need to comment, Sun ld cannot handle this.
+    print "$1##$2\n"; next;
+    }
+
+    # Chomp newline now we're done with passing through the input file.
+    chomp;
+
+    # Catch globs.  Note that '{}' is not allowed in globs by this script,
+    # so only '*' and '[]' are available.
+    if (/^([ \t]*)([^ \t;{}#]+);?[ \t]*$/) {
+    my $ws = $1;
+    my $ptn = $2;
+    # Turn the glob into a regex by replacing '*' with '.*', '?' with '.'.
+    # Keep $ptn so we can still print the original form.
+    ($pattern = $ptn) =~ s/\*/\.\*/g;
+    $pattern =~ s/\?/\./g;
+
+    if ($glob eq 'ign') {
+        # We're in a local: * section; just continue.
+        print "$_\n";
+        next;
+    }
+
+    # Print the glob commented for human readers.
+    print "$ws##$ptn ($glob)\n";
+    # We tried to match a symbol to this version.
+    $matches_attempted++;
+
+    if ($glob eq 'glob') {
+        my %ptn_syms = ();
+
+        # Match ptn against symbols in %sym_hash.
+        foreach my $sym (keys %sym_hash) {
+        # Maybe it matches one of the patterns based on the symbol in
+        # the .o file.
+        $ptn_syms{$sym}++ if ($sym =~ /^$pattern$/);
+        }
+
+        foreach my $sym (sort keys(%ptn_syms)) {
+        $matched_symbols++;
+        print "$ws$sym;\n";
+        }
+    } elsif ($glob eq 'cxx') {
+        my %dem_syms = ();
+
+        # Verify that we're actually using GNU c++filt.  Other versions
+        # most likely cannot handle GNU style symbol mangling.
+        my $cxxout = `$cxxfilt --version 2>&1`;
+        $cxxout =~ m/GNU/ or die "$0 requires GNU c++filt to function";
+
+        # Talk to c++filt through a pair of file descriptors.
+        # Need to start a fresh instance per pattern, otherwise the
+        # process grows to 500+ MB.
+        my $pid = open2(*FILTIN, *FILTOUT, $cxxfilt) or die $!;
+
+        # Match ptn against symbols in %sym_hash.
+        foreach my $sym (keys %sym_hash) {
+        # No?  Well, maybe its demangled form matches one of those
+        # patterns.
+        printf FILTOUT "%s\n",$sym;
+        my $dem = <FILTIN>;
+        chomp $dem;
+        $dem_syms{$sym}++ if ($dem =~ /^$pattern$/);
+        }
+
+        close FILTOUT or die "c++filt error";
+        close FILTIN or die "c++filt error";
+        # Need to wait for the c++filt process to avoid lots of zombies.
+        waitpid $pid, 0;
+
+        foreach my $sym (sort keys(%dem_syms)) {
+        $matched_symbols++;
+        print "$ws$sym;\n";
+        }
+    } else {
+        # No?  Well, then ignore it.
+    }
+    next;
+    }
+    # Important sanity check.  This script can't handle lots of formats
+    # that GNU ld can, so be sure to error out if one is seen!
+    die "strange line `$_'";
+}
+close F;

ffmpeg/compat/stdbit/stdbit.h

@@ -0,0 +1,599 @@
+/*
+ * Copyright (C) 2023 Rémi Denis-Courmont
+ *
+ * This program 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.
+ *
+ * This program 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 this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+
+#ifndef __STDC_VERSION_STDBIT_H__
+#define __STDC_VERSION_STDBIT_H__ 202311L
+
+#include <stdbool.h>
+#include <limits.h> /* CHAR_BIT */
+
+#define __STDC_ENDIAN_LITTLE__ 1234
+#define __STDC_ENDIAN_BIG__    4321
+
+#ifdef __BYTE_ORDER__
+# if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#  define __STDC_ENDIAN_NATIVE__ __STDC_ENDIAN_LITTLE__
+# elif (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#  define __STDC_ENDIAN_NATIVE__ __STDC_ENDIAN_BIG__
+# else
+#  define __STDC_ENDIAN_NATIVE__ 3412
+# endif
+#elif defined(_MSC_VER)
+#  define __STDC_ENDIAN_NATIVE__ __STDC_ENDIAN_LITTLE__
+#else
+# error Not implemented.
+#endif
+
+#define __stdbit_generic_type_func(func, value) \
+    _Generic (value, \
+        unsigned long long: stdc_##func##_ull((unsigned long long)(value)), \
+        unsigned long:      stdc_##func##_ul((unsigned long)(value)), \
+        unsigned int:       stdc_##func##_ui((unsigned int)(value)), \
+        unsigned short:     stdc_##func##_us((unsigned short)(value)), \
+        unsigned char:      stdc_##func##_uc((unsigned char)(value)))
+
+#if defined (__GNUC__) || defined (__clang__)
+static inline unsigned int stdc_leading_zeros_ull(unsigned long long value)
+{
+    return value ? __builtin_clzll(value) : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_ul(unsigned long value)
+{
+    return value ? __builtin_clzl(value) : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_ui(unsigned int value)
+{
+    return value ? __builtin_clz(value) : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_us(unsigned short value)
+{
+    return stdc_leading_zeros_ui(value)
+           - CHAR_BIT * (sizeof (int) - sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_uc(unsigned char value)
+{
+    return stdc_leading_zeros_ui(value) - (CHAR_BIT * (sizeof (int) - 1));
+}
+#else
+static inline unsigned int __stdc_leading_zeros(unsigned long long value,
+                                                unsigned int size)
+{
+    unsigned int zeros = size * CHAR_BIT;
+
+    while (value != 0) {
+        value >>= 1;
+        zeros--;
+    }
+
+    return zeros;
+}
+
+static inline unsigned int stdc_leading_zeros_ull(unsigned long long value)
+{
+    return __stdc_leading_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_ul(unsigned long value)
+{
+    return __stdc_leading_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_ui(unsigned int value)
+{
+    return __stdc_leading_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_us(unsigned short value)
+{
+    return __stdc_leading_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_leading_zeros_uc(unsigned char value)
+{
+    return __stdc_leading_zeros(value, sizeof (value));
+}
+#endif
+
+#define stdc_leading_zeros(value) \
+        __stdbit_generic_type_func(leading_zeros, value)
+
+static inline unsigned int stdc_leading_ones_ull(unsigned long long value)
+{
+    return stdc_leading_zeros_ull(~value);
+}
+
+static inline unsigned int stdc_leading_ones_ul(unsigned long value)
+{
+    return stdc_leading_zeros_ul(~value);
+}
+
+static inline unsigned int stdc_leading_ones_ui(unsigned int value)
+{
+    return stdc_leading_zeros_ui(~value);
+}
+
+static inline unsigned int stdc_leading_ones_us(unsigned short value)
+{
+    return stdc_leading_zeros_us(~value);
+}
+
+static inline unsigned int stdc_leading_ones_uc(unsigned char value)
+{
+    return stdc_leading_zeros_uc(~value);
+}
+
+#define stdc_leading_ones(value) \
+        __stdbit_generic_type_func(leading_ones, value)
+
+#if defined (__GNUC__) || defined (__clang__)
+static inline unsigned int stdc_trailing_zeros_ull(unsigned long long value)
+{
+    return value ? (unsigned int)__builtin_ctzll(value)
+                 : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_ul(unsigned long value)
+{
+    return value ? (unsigned int)__builtin_ctzl(value)
+                 : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_ui(unsigned int value)
+{
+    return value ? (unsigned int)__builtin_ctz(value)
+                 : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_us(unsigned short value)
+{
+    return value ? (unsigned int)__builtin_ctz(value)
+                 : (CHAR_BIT * sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_uc(unsigned char value)
+{
+    return value ? (unsigned int)__builtin_ctz(value)
+                 : (CHAR_BIT * sizeof (value));
+}
+#else
+static inline unsigned int __stdc_trailing_zeros(unsigned long long value,
+                                                 unsigned int size)
+{
+    unsigned int zeros = 0;
+
+    if (!value)
+        return size * CHAR_BIT;
+
+    while ((value & 1) == 0) {
+        value >>= 1;
+        zeros++;
+    }
+
+    return zeros;
+}
+
+static inline unsigned int stdc_trailing_zeros_ull(unsigned long long value)
+{
+    return __stdc_trailing_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_ul(unsigned long value)
+{
+    return __stdc_trailing_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_ui(unsigned int value)
+{
+    return __stdc_trailing_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_us(unsigned short value)
+{
+    return __stdc_trailing_zeros(value, sizeof (value));
+}
+
+static inline unsigned int stdc_trailing_zeros_uc(unsigned char value)
+{
+    return __stdc_trailing_zeros(value, sizeof (value));
+}
+#endif
+
+#define stdc_trailing_zeros(value) \
+        __stdbit_generic_type_func(trailing_zeros, value)
+
+static inline unsigned int stdc_trailing_ones_ull(unsigned long long value)
+{
+    return stdc_trailing_zeros_ull(~value);
+}
+
+static inline unsigned int stdc_trailing_ones_ul(unsigned long value)
+{
+    return stdc_trailing_zeros_ul(~value);
+}
+
+static inline unsigned int stdc_trailing_ones_ui(unsigned int value)
+{
+    return stdc_trailing_zeros_ui(~value);
+}
+
+static inline unsigned int stdc_trailing_ones_us(unsigned short value)
+{
+    return stdc_trailing_zeros_us(~value);
+}
+
+static inline unsigned int stdc_trailing_ones_uc(unsigned char value)
+{
+    return stdc_trailing_zeros_uc(~value);
+}
+
+#define stdc_trailing_ones(value) \
+        __stdbit_generic_type_func(trailing_ones, value)
+
+static inline unsigned int stdc_first_leading_one_ull(unsigned long long value)
+{
+    return value ? (stdc_leading_zeros_ull(value) + 1) : 0;
+}
+
+static inline unsigned int stdc_first_leading_one_ul(unsigned long value)
+{
+    return value ? (stdc_leading_zeros_ul(value) + 1) : 0;
+}
+
+static inline unsigned int stdc_first_leading_one_ui(unsigned int value)
+{
+    return value ? (stdc_leading_zeros_ui(value) + 1) : 0;
+}
+
+static inline unsigned int stdc_first_leading_one_us(unsigned short value)
+{
+    return value ? (stdc_leading_zeros_us(value) + 1) : 0;
+}
+
+static inline unsigned int stdc_first_leading_one_uc(unsigned char value)
+{
+    return value ? (stdc_leading_zeros_uc(value) + 1) : 0;
+}
+
+#define stdc_first_leading_one(value) \
+        __stdbit_generic_type_func(first_leading_one, value)
+
+static inline unsigned int stdc_first_leading_zero_ull(unsigned long long value)
+{
+    return stdc_leading_ones_ull(~value);
+}
+
+static inline unsigned int stdc_first_leading_zero_ul(unsigned long value)
+{
+    return stdc_leading_ones_ul(~value);
+}
+
+static inline unsigned int stdc_first_leading_zero_ui(unsigned int value)
+{
+    return stdc_leading_ones_ui(~value);
+}
+
+static inline unsigned int stdc_first_leading_zero_us(unsigned short value)
+{
+    return stdc_leading_ones_us(~value);
+}
+
+static inline unsigned int stdc_first_leading_zero_uc(unsigned char value)
+{
+    return stdc_leading_ones_uc(~value);
+}
+
+#define stdc_first_leading_zero(value) \
+        __stdbit_generic_type_func(first_leading_zero, value)
+
+#if defined (__GNUC__) || defined (__clang__)
+static inline unsigned int stdc_first_trailing_one_ull(unsigned long long value)
+{
+    return __builtin_ffsll(value);
+}
+
+static inline unsigned int stdc_first_trailing_one_ul(unsigned long value)
+{
+    return __builtin_ffsl(value);
+}
+
+static inline unsigned int stdc_first_trailing_one_ui(unsigned int value)
+{
+    return __builtin_ffs(value);
+}
+
+static inline unsigned int stdc_first_trailing_one_us(unsigned short value)
+{
+    return __builtin_ffs(value);
+}
+
+static inline unsigned int stdc_first_trailing_one_uc(unsigned char value)
+{
+    return __builtin_ffs(value);
+}
+#else
+static inline unsigned int stdc_first_trailing_one_ull(unsigned long long value)
+{
+    return value ? (1 + stdc_trailing_zeros_ull(value)) : 0;
+}
+
+static inline unsigned int stdc_first_trailing_one_ul(unsigned long value)
+{
+    return value ? (1 + stdc_trailing_zeros_ul(value)) : 0;
+}
+
+static inline unsigned int stdc_first_trailing_one_ui(unsigned int value)
+{
+    return value ? (1 + stdc_trailing_zeros_ui(value)) : 0;
+}
+
+static inline unsigned int stdc_first_trailing_one_us(unsigned short value)
+{
+    return value ? (1 + stdc_trailing_zeros_us(value)) : 0;
+}
+
+static inline unsigned int stdc_first_trailing_one_uc(unsigned char value)
+{
+    return value ? (1 + stdc_trailing_zeros_uc(value)) : 0;
+}
+#endif
+
+#define stdc_first_trailing_one(value) \
+        __stdbit_generic_type_func(first_trailing_one, value)
+
+static inline unsigned int stdc_first_trailing_zero_ull(unsigned long long value)
+{
+    return stdc_first_trailing_one_ull(~value);
+}
+
+static inline unsigned int stdc_first_trailing_zero_ul(unsigned long value)
+{
+    return stdc_first_trailing_one_ul(~value);
+}
+
+static inline unsigned int stdc_first_trailing_zero_ui(unsigned int value)
+{
+    return stdc_first_trailing_one_ui(~value);
+}
+
+static inline unsigned int stdc_first_trailing_zero_us(unsigned short value)
+{
+    return stdc_first_trailing_one_us(~value);
+}
+
+static inline unsigned int stdc_first_trailing_zero_uc(unsigned char value)
+{
+    return stdc_first_trailing_one_uc(~value);
+}
+
+#define stdc_first_trailing_zero(value) \
+        __stdbit_generic_type_func(first_trailing_zero, value)
+
+#if defined (__GNUC__) || defined (__clang__)
+static inline unsigned int stdc_count_ones_ull(unsigned long long value)
+{
+    return __builtin_popcountll(value);
+}
+
+static inline unsigned int stdc_count_ones_ul(unsigned long value)
+{
+    return __builtin_popcountl(value);
+}
+
+static inline unsigned int stdc_count_ones_ui(unsigned int value)
+{
+    return __builtin_popcount(value);
+}
+
+static inline unsigned int stdc_count_ones_us(unsigned short value)
+{
+    return __builtin_popcount(value);
+}
+
+static inline unsigned int stdc_count_ones_uc(unsigned char value)
+{
+    return __builtin_popcount(value);
+}
+#else
+static inline unsigned int __stdc_count_ones(unsigned long long value,
+                                             unsigned int size)
+{
+    unsigned int ones = 0;
+
+    for (unsigned int c = 0; c < (size * CHAR_BIT); c++) {
+         ones += value & 1;
+         value >>= 1;
+    }
+
+    return ones;
+}
+
+static inline unsigned int stdc_count_ones_ull(unsigned long long value)
+{
+    return __stdc_count_ones(value, sizeof (value));
+}
+
+static inline unsigned int stdc_count_ones_ul(unsigned long value)
+{
+    return __stdc_count_ones(value, sizeof (value));
+}
+
+static inline unsigned int stdc_count_ones_ui(unsigned int value)
+{
+    return __stdc_count_ones(value, sizeof (value));
+}
+
+static inline unsigned int stdc_count_ones_us(unsigned short value)
+{
+    return __stdc_count_ones(value, sizeof (value));
+}
+
+static inline unsigned int stdc_count_ones_uc(unsigned char value)
+{
+    return __stdc_count_ones(value, sizeof (value));
+}
+#endif
+
+#define stdc_count_ones(value) \
+        __stdbit_generic_type_func(count_ones, value)
+
+static inline unsigned int stdc_count_zeros_ull(unsigned long long value)
+{
+    return stdc_count_ones_ull(~value);
+}
+
+static inline unsigned int stdc_count_zeros_ul(unsigned long value)
+{
+    return stdc_count_ones_ul(~value);
+}
+
+static inline unsigned int stdc_count_zeros_ui(unsigned int value)
+{
+    return stdc_count_ones_ui(~value);
+}
+
+static inline unsigned int stdc_count_zeros_us(unsigned short value)
+{
+    return stdc_count_ones_us(~value);
+}
+
+static inline unsigned int stdc_count_zeros_uc(unsigned char value)
+{
+    return stdc_count_ones_uc(~value);
+}
+
+#define stdc_count_zeros(value) \
+        __stdbit_generic_type_func(count_zeros, value)
+
+static inline bool stdc_has_single_bit_ull(unsigned long long value)
+{
+    return value && (value & (value - 1)) == 0;
+}
+
+static inline bool stdc_has_single_bit_ul(unsigned long value)
+{
+    return value && (value & (value - 1)) == 0;
+}
+
+static inline bool stdc_has_single_bit_ui(unsigned int value)
+{
+    return value && (value & (value - 1)) == 0;
+}
+
+static inline bool stdc_has_single_bit_us(unsigned short value)
+{
+    return value && (value & (value - 1)) == 0;
+}
+
+static inline bool stdc_has_single_bit_uc(unsigned char value)
+{
+    return value && (value & (value - 1)) == 0;
+}
+
+#define stdc_has_single_bit(value) \
+        __stdbit_generic_type_func(has_single_bit, value)
+
+static inline unsigned int stdc_bit_width_ull(unsigned long long value)
+{
+    return (CHAR_BIT * sizeof (value)) - stdc_leading_zeros_ull(value);
+}
+
+static inline unsigned int stdc_bit_width_ul(unsigned long value)
+{
+    return (CHAR_BIT * sizeof (value)) - stdc_leading_zeros_ul(value);
+}
+
+static inline unsigned int stdc_bit_width_ui(unsigned int value)
+{
+    return (CHAR_BIT * sizeof (value)) - stdc_leading_zeros_ui(value);
+}
+
+static inline unsigned int stdc_bit_width_us(unsigned short value)
+{
+    return (CHAR_BIT * sizeof (value)) - stdc_leading_zeros_us(value);
+}
+
+static inline unsigned int stdc_bit_width_uc(unsigned char value)
+{
+    return (CHAR_BIT * sizeof (value)) - stdc_leading_zeros_uc(value);
+}
+
+#define stdc_bit_width(value) \
+        __stdbit_generic_type_func(bit_width, value)
+
+static inline unsigned long long stdc_bit_floor_ull(unsigned long long value)
+{
+    return value ? (1ULL << (stdc_bit_width_ull(value) - 1)) : 0ULL;
+}
+
+static inline unsigned long stdc_bit_floor_ul(unsigned long value)
+{
+    return value ? (1UL << (stdc_bit_width_ul(value) - 1)) : 0UL;
+}
+
+static inline unsigned int stdc_bit_floor_ui(unsigned int value)
+{
+    return value ? (1U << (stdc_bit_width_ui(value) - 1)) : 0U;
+}
+
+static inline unsigned short stdc_bit_floor_us(unsigned short value)
+{
+    return value ? (1U << (stdc_bit_width_us(value) - 1)) : 0U;
+}
+
+static inline unsigned int stdc_bit_floor_uc(unsigned char value)
+{
+    return value ? (1U << (stdc_bit_width_uc(value) - 1)) : 0U;
+}
+
+#define stdc_bit_floor(value) \
+        __stdbit_generic_type_func(bit_floor, value)
+
+/* NOTE: Bit ceiling undefines overflow. */
+static inline unsigned long long stdc_bit_ceil_ull(unsigned long long value)
+{
+    return 1ULL << (value ? stdc_bit_width_ull(value - 1) : 0);
+}
+
+static inline unsigned long stdc_bit_ceil_ul(unsigned long value)
+{
+    return 1UL << (value ? stdc_bit_width_ul(value - 1) : 0);
+}
+
+static inline unsigned int stdc_bit_ceil_ui(unsigned int value)
+{
+    return 1U << (value ? stdc_bit_width_ui(value - 1) : 0);
+}
+
+static inline unsigned short stdc_bit_ceil_us(unsigned short value)
+{
+    return 1U << (value ? stdc_bit_width_us(value - 1) : 0);
+}
+
+static inline unsigned int stdc_bit_ceil_uc(unsigned char value)
+{
+    return 1U << (value ? stdc_bit_width_uc(value - 1) : 0);
+}
+
+#define stdc_bit_ceil(value) \
+        __stdbit_generic_type_func(bit_ceil, value)
+
+#endif /* __STDC_VERSION_STDBIT_H__ */

ffmpeg/compat/strtod.c

@@ -0,0 +1,93 @@
+/*
+ * C99-compatible strtod() implementation
+ * Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.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 <stdlib.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/mathematics.h"
+
+static const char *check_nan_suffix(const char *s)
+{
+    const char *start = s;
+
+    if (*s++ != '(')
+        return start;
+
+    while ((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
+           (*s >= '0' && *s <= '9') ||  *s == '_')
+        s++;
+
+    return *s == ')' ? s + 1 : start;
+}
+
+#undef strtod
+double strtod(const char *, char **);
+
+double avpriv_strtod(const char *nptr, char **endptr)
+{
+    const char *end;
+    double res;
+
+    /* Skip leading spaces */
+    while (av_isspace(*nptr))
+        nptr++;
+
+    if (!av_strncasecmp(nptr, "infinity", 8)) {
+        end = nptr + 8;
+        res = INFINITY;
+    } else if (!av_strncasecmp(nptr, "inf", 3)) {
+        end = nptr + 3;
+        res = INFINITY;
+    } else if (!av_strncasecmp(nptr, "+infinity", 9)) {
+        end = nptr + 9;
+        res = INFINITY;
+    } else if (!av_strncasecmp(nptr, "+inf", 4)) {
+        end = nptr + 4;
+        res = INFINITY;
+    } else if (!av_strncasecmp(nptr, "-infinity", 9)) {
+        end = nptr + 9;
+        res = -INFINITY;
+    } else if (!av_strncasecmp(nptr, "-inf", 4)) {
+        end = nptr + 4;
+        res = -INFINITY;
+    } else if (!av_strncasecmp(nptr, "nan", 3)) {
+        end = check_nan_suffix(nptr + 3);
+        res = NAN;
+    } else if (!av_strncasecmp(nptr, "+nan", 4) ||
+               !av_strncasecmp(nptr, "-nan", 4)) {
+        end = check_nan_suffix(nptr + 4);
+        res = NAN;
+    } else if (!av_strncasecmp(nptr, "0x", 2) ||
+               !av_strncasecmp(nptr, "-0x", 3) ||
+               !av_strncasecmp(nptr, "+0x", 3)) {
+        /* FIXME this doesn't handle exponents, non-integers (float/double)
+         * and numbers too large for long long */
+        res = strtoll(nptr, (char **)&end, 16);
+    } else {
+        res = strtod(nptr, (char **)&end);
+    }
+
+    if (endptr)
+        *endptr = (char *)end;
+
+    return res;
+}

ffmpeg/compat/va_copy.h

@@ -0,0 +1,34 @@
+/*
+ * MSVC Compatible va_copy macro
+ * Copyright (c) 2012 Derek Buitenhuis
+ *
+ * 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_VA_COPY_H
+#define COMPAT_VA_COPY_H
+
+#include <stdarg.h>
+
+#if !defined(va_copy) && defined(_MSC_VER)
+#define va_copy(dst, src) ((dst) = (src))
+#endif
+#if !defined(va_copy) && defined(__GNUC__) && __GNUC__ < 3
+#define va_copy(dst, src) __va_copy(dst, src)
+#endif
+
+#endif /* COMPAT_VA_COPY_H */

ffmpeg/compat/w32dlfcn.h

@@ -0,0 +1,151 @@
+/*
+ * 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_W32DLFCN_H
+#define COMPAT_W32DLFCN_H
+
+#ifdef _WIN32
+#include <stdint.h>
+
+#include <windows.h>
+
+#include "config.h"
+#include "libavutil/macros.h"
+#include "libavutil/mem.h"
+#include "libavutil/wchar_filename.h"
+
+static inline wchar_t *get_module_filename(HMODULE module)
+{
+    wchar_t *path = NULL, *new_path;
+    DWORD path_size = 0, path_len;
+
+    do {
+        path_size = path_size ? FFMIN(2 * path_size, INT16_MAX + 1) : MAX_PATH;
+        new_path = av_realloc_array(path, path_size, sizeof *path);
+        if (!new_path) {
+            av_free(path);
+            return NULL;
+        }
+        path = new_path;
+        // Returns path_size in case of insufficient buffer.
+        // Whether the error is set or not and whether the output
+        // is null-terminated or not depends on the version of Windows.
+        path_len = GetModuleFileNameW(module, path, path_size);
+    } while (path_len && path_size <= INT16_MAX && path_size <= path_len);
+
+    if (!path_len) {
+        av_free(path);
+        return NULL;
+    }
+    return path;
+}
+
+/**
+ * Safe function used to open dynamic libs. This attempts to improve program security
+ * by removing the current directory from the dll search path. Only dll's found in the
+ * executable or system directory are allowed to be loaded.
+ * @param name  The dynamic lib name.
+ * @return A handle to the opened lib.
+ */
+static inline HMODULE win32_dlopen(const char *name)
+{
+    wchar_t *name_w;
+    HMODULE module = NULL;
+    if (utf8towchar(name, &name_w))
+        name_w = NULL;
+#if _WIN32_WINNT < 0x0602
+    // On Win7 and earlier we check if KB2533623 is available
+    if (!GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "SetDefaultDllDirectories")) {
+        wchar_t *path = NULL, *new_path;
+        DWORD pathlen, pathsize, namelen;
+        if (!name_w)
+            goto exit;
+        namelen = wcslen(name_w);
+        // Try local directory first
+        path = get_module_filename(NULL);
+        if (!path)
+            goto exit;
+        new_path = wcsrchr(path, '\\');
+        if (!new_path)
+            goto exit;
+        pathlen = new_path - path;
+        pathsize = pathlen + namelen + 2;
+        new_path = av_realloc_array(path, pathsize, sizeof *path);
+        if (!new_path)
+            goto exit;
+        path = new_path;
+        wcscpy(path + pathlen + 1, name_w);
+        module = LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+        if (module == NULL) {
+            // Next try System32 directory
+            pathlen = GetSystemDirectoryW(path, pathsize);
+            if (!pathlen)
+                goto exit;
+            // Buffer is not enough in two cases:
+            // 1. system directory + \ + module name
+            // 2. system directory even without the module name.
+            if (pathlen + namelen + 2 > pathsize) {
+                pathsize = pathlen + namelen + 2;
+                new_path = av_realloc_array(path, pathsize, sizeof *path);
+                if (!new_path)
+                    goto exit;
+                path = new_path;
+                // Query again to handle the case #2.
+                pathlen = GetSystemDirectoryW(path, pathsize);
+                if (!pathlen)
+                    goto exit;
+            }
+            path[pathlen] = L'\\';
+            wcscpy(path + pathlen + 1, name_w);
+            module = LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+        }
+exit:
+        av_free(path);
+        av_free(name_w);
+        return module;
+    }
+#endif
+#ifndef LOAD_LIBRARY_SEARCH_APPLICATION_DIR
+#   define LOAD_LIBRARY_SEARCH_APPLICATION_DIR 0x00000200
+#endif
+#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32
+#   define LOAD_LIBRARY_SEARCH_SYSTEM32        0x00000800
+#endif
+#if HAVE_WINRT
+    if (!name_w)
+        return NULL;
+    module = LoadPackagedLibrary(name_w, 0);
+#else
+#define LOAD_FLAGS (LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32)
+    /* filename may be be in CP_ACP */
+    if (!name_w)
+        return LoadLibraryExA(name, NULL, LOAD_FLAGS);
+    module = LoadLibraryExW(name_w, NULL, LOAD_FLAGS);
+#undef LOAD_FLAGS
+#endif
+    av_free(name_w);
+    return module;
+}
+#define dlopen(name, flags) win32_dlopen(name)
+#define dlclose FreeLibrary
+#define dlsym GetProcAddress
+#else
+#include <dlfcn.h>
+#endif
+
+#endif /* COMPAT_W32DLFCN_H */

ffmpeg/compat/w32pthreads.h

@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2010-2011 x264 project
+ *
+ * Authors: Steven Walters <kemuri9@gmail.com>
+ *          Pegasys Inc. <http://www.pegasys-inc.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
+ */
+
+/**
+ * @file
+ * w32threads to pthreads wrapper
+ */
+
+#ifndef COMPAT_W32PTHREADS_H
+#define COMPAT_W32PTHREADS_H
+
+/* Build up a pthread-like API using underlying Windows API. Have only static
+ * methods so as to not conflict with a potentially linked in pthread-win32
+ * library.
+ * As most functions here are used without checking return values,
+ * only implement return values as necessary. */
+
+#include <windows.h>
+#include <process.h>
+#include <time.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "libavutil/mem.h"
+#include "libavutil/time.h"
+
+typedef struct pthread_t {
+    void *handle;
+    void *(*func)(void* arg);
+    void *arg;
+    void *ret;
+} *pthread_t;
+
+/* use light weight mutex/condition variable API for Windows Vista and later */
+typedef SRWLOCK pthread_mutex_t;
+typedef CONDITION_VARIABLE pthread_cond_t;
+
+#define PTHREAD_MUTEX_INITIALIZER SRWLOCK_INIT
+#define PTHREAD_COND_INITIALIZER CONDITION_VARIABLE_INIT
+
+#define InitializeCriticalSection(x) InitializeCriticalSectionEx(x, 0, 0)
+#define WaitForSingleObject(a, b) WaitForSingleObjectEx(a, b, FALSE)
+
+#define PTHREAD_CANCEL_ENABLE 1
+#define PTHREAD_CANCEL_DISABLE 0
+
+#if HAVE_WINRT
+#define THREADFUNC_RETTYPE DWORD
+#else
+#define THREADFUNC_RETTYPE unsigned
+#endif
+
+static av_unused THREADFUNC_RETTYPE
+__stdcall attribute_align_arg win32thread_worker(void *arg)
+{
+    pthread_t h = (pthread_t)arg;
+    h->ret = h->func(h->arg);
+    return 0;
+}
+
+static av_unused int pthread_create(pthread_t *thread, const void *unused_attr,
+                                    void *(*start_routine)(void*), void *arg)
+{
+    pthread_t ret;
+
+    ret = av_mallocz(sizeof(*ret));
+    if (!ret)
+        return EAGAIN;
+
+    ret->func   = start_routine;
+    ret->arg    = arg;
+#if HAVE_WINRT
+    ret->handle = (void*)CreateThread(NULL, 0, win32thread_worker, ret,
+                                      0, NULL);
+#else
+    ret->handle = (void*)_beginthreadex(NULL, 0, win32thread_worker, ret,
+                                        0, NULL);
+#endif
+
+    if (!ret->handle) {
+        av_free(ret);
+        return EAGAIN;
+    }
+
+    *thread = ret;
+
+    return 0;
+}
+
+static av_unused int pthread_join(pthread_t thread, void **value_ptr)
+{
+    DWORD ret = WaitForSingleObject(thread->handle, INFINITE);
+    if (ret != WAIT_OBJECT_0) {
+        if (ret == WAIT_ABANDONED)
+            return EINVAL;
+        else
+            return EDEADLK;
+    }
+    if (value_ptr)
+        *value_ptr = thread->ret;
+    CloseHandle(thread->handle);
+    av_free(thread);
+    return 0;
+}
+
+static inline int pthread_mutex_init(pthread_mutex_t *m, void* attr)
+{
+    InitializeSRWLock(m);
+    return 0;
+}
+static inline int pthread_mutex_destroy(pthread_mutex_t *m)
+{
+    /* Unlocked SWR locks use no resources */
+    return 0;
+}
+static inline int pthread_mutex_lock(pthread_mutex_t *m)
+{
+    AcquireSRWLockExclusive(m);
+    return 0;
+}
+static inline int pthread_mutex_unlock(pthread_mutex_t *m)
+{
+    ReleaseSRWLockExclusive(m);
+    return 0;
+}
+
+typedef INIT_ONCE pthread_once_t;
+#define PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT
+
+static av_unused int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
+{
+    BOOL pending = FALSE;
+    InitOnceBeginInitialize(once_control, 0, &pending, NULL);
+    if (pending)
+        init_routine();
+    InitOnceComplete(once_control, 0, NULL);
+    return 0;
+}
+
+static inline int pthread_cond_init(pthread_cond_t *cond, const void *unused_attr)
+{
+    InitializeConditionVariable(cond);
+    return 0;
+}
+
+/* native condition variables do not destroy */
+static inline int pthread_cond_destroy(pthread_cond_t *cond)
+{
+    return 0;
+}
+
+static inline int pthread_cond_broadcast(pthread_cond_t *cond)
+{
+    WakeAllConditionVariable(cond);
+    return 0;
+}
+
+static inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+    SleepConditionVariableSRW(cond, mutex, INFINITE, 0);
+    return 0;
+}
+
+static inline int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
+                                         const struct timespec *abstime)
+{
+    int64_t abs_milli = abstime->tv_sec * 1000LL + abstime->tv_nsec / 1000000;
+    DWORD t = av_clip64(abs_milli - av_gettime() / 1000, 0, UINT32_MAX);
+
+    if (!SleepConditionVariableSRW(cond, mutex, t, 0)) {
+        DWORD err = GetLastError();
+        if (err == ERROR_TIMEOUT)
+            return ETIMEDOUT;
+        else
+            return EINVAL;
+    }
+    return 0;
+}
+
+static inline int pthread_cond_signal(pthread_cond_t *cond)
+{
+    WakeConditionVariable(cond);
+    return 0;
+}
+
+static inline int pthread_setcancelstate(int state, int *oldstate)
+{
+    return 0;
+}
+
+#endif /* COMPAT_W32PTHREADS_H */

ffmpeg/compat/windows/makedef

@@ -0,0 +1,129 @@
+#!/bin/sh
+
+# Copyright (c) 2013, Derek Buitenhuis
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# mktemp isn't POSIX, so supply an implementation
+mktemp() {
+    echo "${2%%XXX*}.${HOSTNAME}.${UID}.$$"
+}
+
+if [ $# -lt 2 ]; then
+    echo "Usage: makedef <version_script> <objects>" >&2
+    exit 0
+fi
+
+vscript=$1
+shift
+
+if [ ! -f "$vscript" ]; then
+    echo "Version script does not exist" >&2
+    exit 1
+fi
+
+for object in "$@"; do
+    if [ ! -f "$object" ]; then
+        echo "Object does not exist: ${object}" >&2
+        exit 1
+    fi
+done
+
+# Create a lib temporarily to dump symbols from.
+# It's just much easier to do it this way
+libname=$(mktemp -u "library").lib
+
+trap 'rm -f -- $libname' EXIT
+
+if [ -n "$AR" ]; then
+    $AR rcs ${libname} $@ >/dev/null
+else
+    lib.exe -out:${libname} $@ >/dev/null
+fi
+if [ $? != 0 ]; then
+    echo "Could not create temporary library." >&2
+    exit 1
+fi
+
+IFS='
+'
+
+prefix="$EXTERN_PREFIX"
+
+started=0
+regex="none"
+
+for line in $(cat ${vscript} | tr '\t' ' '); do
+    # We only care about global symbols
+    echo "${line}" | grep -q '^ \+global:'
+    if [ $? = 0 ]; then
+        started=1
+        line=$(echo "${line}" | sed -e 's/^ \{1,\}global: *//')
+    else
+        echo "${line}" | grep -q '^ \+local:'
+        if [ $? = 0 ]; then
+            started=0
+        fi
+    fi
+
+    if [ ${started} = 0 ]; then
+        continue
+    fi
+
+    # Handle multiple symbols on one line
+    IFS=';'
+
+    # Work around stupid expansion to filenames
+    line=$(echo "${line}" | sed -e 's/\*/.\\+/g')
+    for exp in ${line}; do
+        # Remove leading and trailing whitespace
+        exp=$(echo "${exp}" | sed -e 's/^ *//' -e 's/ *$//')
+
+        if [ "${regex}" = "none" ]; then
+            regex="${exp}"
+        else
+            regex="${regex};${exp}"
+        fi
+    done
+
+    IFS='
+'
+done
+
+if [ -n "$NM" ]; then
+    # Use eval, since NM="nm -g"
+    dump=$(eval "$NM --defined-only -g ${libname}" |
+              grep -v : |
+              grep -v ^$ |
+              cut -d' ' -f3 |
+              sed -e "s/^${prefix}//")
+else
+    dump=$(dumpbin.exe -linkermember:1 ${libname} |
+              sed -e '/public symbols/,$!d' -e '/^ \{1,\}Summary/,$d' -e "s/ \{1,\}${prefix}/ /" -e 's/ \{1,\}/ /g' |
+              tail -n +2 |
+              cut -d' ' -f3)
+fi
+
+rm ${libname}
+
+IFS=';'
+list=""
+for exp in ${regex}; do
+    list="${list}"'
+'$(echo "${dump}" |
+          grep "^${exp}" |
+          sed -e 's/^/    /')
+done
+
+echo "EXPORTS"
+echo "${list}" | sort | uniq | tail -n +2

ffmpeg/compat/windows/mslink

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+LINK_EXE_PATH=$(dirname "$(command -v cl)")/link
+if [ -x "$LINK_EXE_PATH" ]; then
+    "$LINK_EXE_PATH" $@
+else
+    link.exe $@
+fi
+exit $?

ffmpeg/compat/windows/mswindres

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+if [ "$1" = "--version" ]; then
+    rc.exe -?
+    exit $?
+fi
+
+if [ $# -lt 2 ]; then
+    echo "Usage: mswindres [-I/include/path ...] [-DSOME_DEFINE ...] [-o output.o] input.rc [output.o]" >&2
+    exit 0
+fi
+
+EXTRA_OPTS="-nologo"
+
+while [ $# -gt 2 ]; do
+    case $1 in
+    -D*) EXTRA_OPTS="$EXTRA_OPTS -d$(echo $1 | sed -e "s/^..//" -e "s/ /\\\\ /g")" ;;
+    -I*) EXTRA_OPTS="$EXTRA_OPTS -i$(echo $1 | sed -e "s/^..//" -e "s/ /\\\\ /g")" ;;
+    -o)  OPT_OUT="$2"; shift ;;
+    esac
+    shift
+done
+
+IN="$1"
+if [ -z "$OPT_OUT" ]; then
+    OUT="$2"
+else
+    OUT="$OPT_OUT"
+fi
+
+eval set -- $EXTRA_OPTS
+rc.exe "$@" -fo "$OUT" "$IN"