early-access version 1432

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

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

externals/ffmpeg/compat/atomics/gcc/stdatomic.h

@@ -0,0 +1,173 @@
+/*
+ * 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_GCC_STDATOMIC_H
+#define COMPAT_ATOMICS_GCC_STDATOMIC_H
+
+#include <stddef.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) \
+    __sync_synchronize()
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef         _Bool      atomic_flag;
+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          long long atomic_llong;
+typedef unsigned long long atomic_ullong;
+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      int_least64_t atomic_int_least64_t;
+typedef     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      int_fast64_t atomic_int_fast64_t;
+typedef     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          intmax_t atomic_intmax_t;
+typedef         uintmax_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+    __sync_synchronize();               \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (__sync_synchronize(), *(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired)                            \
+({                                                                  \
+    __typeof__(object) _obj = (object);                             \
+    __typeof__(*object) _old;                                       \
+    do                                                              \
+        _old = atomic_load(_obj);                                   \
+    while (!__sync_bool_compare_and_swap(_obj, _old, (desired)));   \
+    _old;                                                           \
+})
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+#define atomic_compare_exchange_strong(object, expected, desired)   \
+({                                                                  \
+    __typeof__(object) _exp = (expected);                           \
+    __typeof__(*object) _old = *_exp;                               \
+    *_exp = __sync_val_compare_and_swap((object), _old, (desired)); \
+    *_exp == _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)
+
+#define atomic_fetch_add(object, operand) \
+    __sync_fetch_and_add(object, operand)
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    __sync_fetch_and_sub(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or(object, operand) \
+    __sync_fetch_and_or(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    __sync_fetch_and_xor(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    __sync_fetch_and_and(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_GCC_STDATOMIC_H */

externals/ffmpeg/compat/atomics/pthread/stdatomic.c

@@ -0,0 +1,39 @@
+/*
+ * 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
+ */
+
+#include <pthread.h>
+#include <stdint.h>
+
+#include "stdatomic.h"
+
+static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER;
+
+void avpriv_atomic_lock(void)
+{
+    pthread_mutex_lock(&atomic_lock);
+}
+
+void avpriv_atomic_unlock(void)
+{
+    pthread_mutex_unlock(&atomic_lock);
+}

externals/ffmpeg/compat/atomics/pthread/stdatomic.h

@@ -0,0 +1,197 @@
+/*
+ * 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_PTHREAD_STDATOMIC_H
+#define COMPAT_ATOMICS_PTHREAD_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_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;
+
+void avpriv_atomic_lock(void);
+void avpriv_atomic_unlock(void);
+
+static inline void atomic_thread_fence(int order)
+{
+    avpriv_atomic_lock();
+    avpriv_atomic_unlock();
+}
+
+static inline void atomic_store(intptr_t *object, intptr_t desired)
+{
+    avpriv_atomic_lock();
+    *object = desired;
+    avpriv_atomic_unlock();
+}
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+static inline intptr_t atomic_load(intptr_t *object)
+{
+    intptr_t ret;
+    avpriv_atomic_lock();
+    ret = *object;
+    avpriv_atomic_unlock();
+    return ret;
+}
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+static inline intptr_t atomic_exchange(intptr_t *object, intptr_t desired)
+{
+    intptr_t ret;
+    avpriv_atomic_lock();
+    ret     = *object;
+    *object = desired;
+    avpriv_atomic_unlock();
+    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;
+    avpriv_atomic_lock();
+    if (*object == *expected) {
+        ret     = 1;
+        *object = desired;
+    } else {
+        ret = 0;
+        *expected = *object;
+    }
+    avpriv_atomic_unlock();
+    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;                                                                  \
+    avpriv_atomic_lock();                                                          \
+    ret = *object;                                                                 \
+    *object = *object op operand;                                                  \
+    avpriv_atomic_unlock();                                                        \
+    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_PTHREAD_STDATOMIC_H */

externals/ffmpeg/compat/atomics/suncc/stdatomic.h

@@ -0,0 +1,186 @@
+/*
+ * 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_SUNCC_STDATOMIC_H
+#define COMPAT_ATOMICS_SUNCC_STDATOMIC_H
+
+#include <atomic.h>
+#include <mbarrier.h>
+#include <stddef.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) \
+    __machine_rw_barrier();
+
+#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;
+
+static inline void atomic_store(intptr_t *object, intptr_t desired)
+{
+    *object = desired;
+    __machine_rw_barrier();
+}
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+static inline intptr_t atomic_load(intptr_t *object)
+{
+    __machine_rw_barrier();
+    return *object;
+}
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired) \
+    atomic_swap_ptr(object, 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)atomic_cas_ptr(object, (void *)old, (void *)desired);
+    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)
+
+static inline intptr_t atomic_fetch_add(intptr_t *object, intptr_t operand)
+{
+    return atomic_add_ptr_nv(object, operand) - operand;
+}
+
+#define atomic_fetch_sub(object, operand) \
+    atomic_fetch_add(object, -(operand))
+
+static inline intptr_t atomic_fetch_or(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old | operand));
+    return old;
+}
+
+static inline intptr_t atomic_fetch_xor(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old ^ operand));
+    return old;
+}
+
+static inline intptr_t atomic_fetch_and(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old & operand));
+    return old;
+}
+
+#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_SUNCC_STDATOMIC_H */

externals/ffmpeg/compat/atomics/win32/stdatomic.h

@@ -0,0 +1,181 @@
+/*
+ * 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
+
+#define WIN32_LEAN_AND_MEAN
+#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(object, 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 */

externals/ffmpeg/compat/cuda/cuda_runtime.h

@@ -0,0 +1,131 @@
+/*
+ * Minimum CUDA compatibility definitions header
+ *
+ * Copyright (c) 2019 Rodger Combs
+ *
+ * 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__ uint3
+{
+    unsigned int x, y, z;
+} uint3;
+
+typedef struct uint3 dim3;
+
+typedef struct __device_builtin__ __align__(8) int2
+{
+    int x, y;
+} int2;
+
+typedef struct __device_builtin__ __align__(4) uchar4
+{
+    unsigned char x, y, z, w;
+} uchar4;
+
+typedef struct __device_builtin__ __align__(8) ushort4
+{
+    unsigned char x, y, z, w;
+} ushort4;
+
+typedef struct __device_builtin__ __align__(16) int4
+{
+    int x, y, z, w;
+} int4;
+
+// 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_uchar2(a, b) ((uchar2){.x = a, .y = b})
+#define make_ushort2(a, b) ((ushort2){.x = a, .y = b})
+#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})
+
+// 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(uchar2, make_uchar2(a & 0xFF, b & 0xFF))
+TEX2D(ushort2, make_ushort2(a & 0xFFFF, b & 0xFFFF))
+TEX2D(uchar4, make_uchar4(a & 0xFF, b & 0xFF, c & 0xFF, d & 0xFF))
+TEX2D(ushort4, make_ushort4(a & 0xFFFF, b & 0xFFFF, c & 0xFFFF, d & 0xFFFF))
+
+// Template calling tex instruction and converting the output to the selected type
+template <class T>
+static 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;
+}
+
+#endif /* COMPAT_CUDA_CUDA_RUNTIME_H */

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

externals/ffmpeg/compat/cuda/ptx2c.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+
+# Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+set -e
+
+OUT="$1"
+IN="$2"
+NAME="$(basename "$IN" | sed 's/\..*//')"
+
+printf "const char %s_ptx[] = \\" "$NAME" > "$OUT"
+echo >> "$OUT"
+sed -e "$(printf 's/\r//g')" -e 's/["\\]/\\&/g' -e "$(printf 's/^/\t"/')" -e 's/$/\\n"/' < "$IN" >> "$OUT"
+echo ";" >> "$OUT"
+
+exit 0

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

externals/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);
+}

externals/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);

externals/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

externals/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>

externals/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;
+}

externals/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 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;
+}

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

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

externals/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 agains 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;

externals/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;
+}

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

externals/ffmpeg/compat/w32dlfcn.h

@@ -0,0 +1,94 @@
+/*
+ * 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 <windows.h>
+#include "config.h"
+#if (_WIN32_WINNT < 0x0602) || HAVE_WINRT
+#include "libavutil/wchar_filename.h"
+#endif
+/**
+ * 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)
+{
+#if _WIN32_WINNT < 0x0602
+    // Need to check if KB2533623 is available
+    if (!GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "SetDefaultDllDirectories")) {
+        HMODULE module = NULL;
+        wchar_t *path = NULL, *name_w = NULL;
+        DWORD pathlen;
+        if (utf8towchar(name, &name_w))
+            goto exit;
+        path = (wchar_t *)av_mallocz_array(MAX_PATH, sizeof(wchar_t));
+        // Try local directory first
+        pathlen = GetModuleFileNameW(NULL, path, MAX_PATH);
+        pathlen = wcsrchr(path, '\\') - path;
+        if (pathlen == 0 || pathlen + wcslen(name_w) + 2 > MAX_PATH)
+            goto exit;
+        path[pathlen] = '\\';
+        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, MAX_PATH);
+            if (pathlen == 0 || pathlen + wcslen(name_w) + 2 > MAX_PATH)
+                goto exit;
+            path[pathlen] = '\\';
+            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
+    wchar_t *name_w = NULL;
+    int ret;
+    if (utf8towchar(name, &name_w))
+        return NULL;
+    ret = LoadPackagedLibrary(name_w, 0);
+    av_free(name_w);
+    return ret;
+#else
+    return LoadLibraryExA(name, NULL, LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32);
+#endif
+}
+#define dlopen(name, flags) win32_dlopen(name)
+#define dlclose FreeLibrary
+#define dlsym GetProcAddress
+#else
+#include <dlfcn.h>
+#endif
+
+#endif /* COMPAT_W32DLFCN_H */

externals/ffmpeg/compat/w32pthreads.h

@@ -0,0 +1,191 @@
+/*
+ * 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. */
+
+#define WIN32_LEAN_AND_MEAN
+#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
+
+static av_unused unsigned __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)
+{
+    thread->func   = start_routine;
+    thread->arg    = arg;
+#if HAVE_WINRT
+    thread->handle = (void*)CreateThread(NULL, 0, win32thread_worker, thread,
+                                           0, NULL);
+#else
+    thread->handle = (void*)_beginthreadex(NULL, 0, win32thread_worker, thread,
+                                           0, NULL);
+#endif
+    return !thread->handle;
+}
+
+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);
+    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 */

externals/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

externals/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 $?