@scrypted/libav 1.0.179 → 1.0.181

package/openh264/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

package/openh264/meson.build

@@ -0,0 +1,218 @@
+project('openh264', ['c', 'cpp'],
+  version : '2.6.0',
+  meson_version : '>= 0.52',
+  default_options : [ 'warning_level=1',
+                      'buildtype=debugoptimized' ])
+
+major_version = '8'
+
+cpp = meson.get_compiler('cpp')
+
+inc = include_directories([
+  join_paths('codec', 'api', 'wels'),
+  join_paths('codec', 'common', 'inc'),
+])
+
+processing_inc = include_directories([
+  join_paths('codec', 'processing', 'interface'),
+  join_paths('codec', 'processing', 'src', 'common'),
+  join_paths('codec', 'processing', 'src', 'adaptivequantization'),
+  join_paths('codec', 'processing', 'src', 'downsample'),
+  join_paths('codec', 'processing', 'src', 'scrolldetection'),
+  join_paths('codec', 'processing', 'src', 'vaacalc'),
+])
+
+console_common_inc = include_directories([
+  join_paths('codec', 'console', 'common', 'inc')
+])
+
+decoder_inc = include_directories([
+  join_paths('codec', 'decoder', 'core', 'inc'),
+  join_paths('codec', 'decoder', 'plus', 'inc'),
+])
+
+encoder_inc = include_directories([
+  join_paths('codec', 'encoder', 'core', 'inc'),
+  join_paths('codec', 'encoder', 'plus', 'inc'),
+])
+
+system = host_machine.system()
+cpu_family = host_machine.cpu_family()
+
+supported_arguments = cpp.get_supported_arguments([
+  '-Wno-non-virtual-dtor',
+  '-Wunused-but-set-variable',
+  '-Wno-strict-aliasing'])
+
+add_project_arguments(supported_arguments, language: 'cpp')
+
+deps = [dependency('threads')]
+c_args = []
+cpp_args = []
+asm_args = []
+asm_inc = []
+casm_inc = []
+cpp_lib = '-lstdc++'
+
+libm_dep = cpp.find_library('m', required : false)
+deps += [libm_dep]
+
+if ['linux', 'android', 'ios', 'darwin'].contains(system)
+  asm_format32 = 'elf'
+  asm_format64 = 'elf64'
+  if ['ios', 'darwin'].contains(system)
+    asm_format32 = 'macho32'
+    asm_format64 = 'macho64'
+  endif
+  if cpu_family == 'x86'
+    asm_format = asm_format32
+    asm_args += ['-DX86_32', '-DX86_32_PICASM', '-DHAVE_AVX2']
+    add_project_arguments('-DHAVE_AVX2', language: 'cpp')
+    add_project_arguments('-DHAVE_AVX2', '-DX86_ASM', '-DX86_32_ASM', language: 'c')
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'x86', '')
+  elif cpu_family == 'x86_64'
+    asm_format = asm_format64
+    asm_args += ['-DUNIX64', '-DHAVE_AVX2']
+    add_project_arguments('-DHAVE_AVX2', language: 'cpp')
+    add_project_arguments('-DHAVE_AVX2', '-DX86_ASM', language: 'c')
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'x86', '')
+  elif cpu_family == 'arm'
+    asm_format = asm_format32
+    add_project_arguments('-DHAVE_NEON', language: 'c')
+    add_project_arguments('-DHAVE_NEON', language: 'c')
+    casm_inc = include_directories(join_paths('codec', 'common', 'arm'))
+  elif cpu_family == 'aarch64'
+    asm_format = asm_format64
+    add_project_arguments('-DHAVE_NEON_AARCH64', language: 'c')
+    add_project_arguments('-DHAVE_NEON_AARCH64', language: 'cpp')
+    casm_inc = include_directories(join_paths('codec', 'common', 'arm64'))
+  elif cpu_family == 'loongarch32'
+    asm_format = asm_format32
+    add_project_arguments('-mlsx', '-DHAVE_LSX', '-mlasx', '-DHAVE_LASX', language: 'c')
+    add_project_arguments('-DHAVE_LSX', '-DHAVE_LASX', language: 'cpp')
+    casm_inc = include_directories(join_paths('codec', 'common', 'loongarch'))
+  elif cpu_family == 'loongarch64'
+    asm_format = asm_format64
+    add_project_arguments('-mlsx', '-DHAVE_LSX', '-mlasx', '-DHAVE_LASX', language: 'c')
+    add_project_arguments('-DHAVE_LSX', '-DHAVE_LASX', language: 'cpp')
+    casm_inc = include_directories(join_paths('codec', 'common', 'loongarch'))
+  elif cpu_family == 'riscv64'
+    # We don't have riscv64-specific optimization for now.
+    asm_format = asm_format64
+  elif cpu_family == 'ppc'
+    # We don't have powerpc-specific optimization for now.
+    asm_format = asm_format32
+  elif cpu_family == 'ppc64'
+    # We don't have powerpc64-specific optimization for now.
+    asm_format = asm_format64
+  else
+    error('FIXME: unhandled CPU family @0@ for @1@'.format(cpu_family, system))
+  endif
+
+  if ['ios', 'darwin', 'android'].contains(system)
+    cpp_lib = '-lc++'
+  endif
+elif system == 'windows'
+  if cpu_family == 'x86'
+    asm_format = 'win32'
+    asm_args += ['-DPREFIX', '-DX86_32']
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'x86', '')
+  elif cpu_family == 'x86_64'
+    asm_format = 'win64'
+    asm_args += ['-DWIN64']
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'x86', '')
+  elif cpu_family == 'arm'
+    if cpp.get_argument_syntax() == 'msvc'
+      asm_format = 'armasm'
+      asm_args += ['-nologo', '-DHAVE_NEON', '-ignore', '4509']
+      asm_cmds = ['armasm']
+    else
+      asm_format = 'clang'
+      asm_args += ['-DHAVE_NEON', '-mimplicit-it=always']
+      asm_cmds = cpp.cmd_array()
+    endif
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'arm', '')
+  elif cpu_family == 'aarch64'
+    asm_format = 'armasm'
+    asm_args += ['-nologo', '-DHAVE_NEON_AARCH64']
+    asm_inc = join_paths(meson.current_source_dir(), 'codec', 'common', 'arm64', '')
+  else
+    error('FIXME: unhandled CPU family @0@ for Windows'.format(cpu_family))
+  endif
+else
+  error('FIXME: Unhandled system @0@'.format(system))
+endif
+
+use_asm_gen = false
+if cpu_family in ['x86', 'x86_64']
+  nasm = find_program('nasm')
+
+  use_asm_gen = true
+  asm_gen = generator(nasm,
+    output : '@BASENAME@.o',
+    arguments : [
+      '-f', asm_format,
+      '-i', asm_inc,
+      '@INPUT@',
+      '-o', '@OUTPUT@'] + asm_args)
+elif system == 'windows'
+  if  cpu_family == 'arm'
+    # For ARM, gas-preprocessor is needed for converting the asm to be
+    # buildable as thumb even with Clang.
+    use_asm_gen = true
+    gasprep = find_program('gas-preprocessor.pl')
+    asm_gen = generator(gasprep,
+      output : '@BASENAME@.obj',
+      arguments : [
+        '-as-type', asm_format,
+        '-force-thumb',
+        '--'
+        ] + asm_cmds + [
+        '-I' + asm_inc] + asm_args + [
+        '@INPUT@',
+        '-c', '-o', '@OUTPUT@'])
+  elif cpu_family == 'aarch64'
+    # For ARM64, Clang can build the assembly as-is without needing to use
+    # either gas-preprocessor or armasm64.
+    if cpp.get_argument_syntax() == 'msvc' and (cpp.get_id() != 'clang-cl' or meson.version().version_compare('<0.58.0'))
+      use_asm_gen = true
+      gasprep = find_program('gas-preprocessor.pl')
+      asm_gen = generator(gasprep,
+        output : '@BASENAME@.obj',
+        arguments : [
+          '-as-type', asm_format,
+          '-arch', 'aarch64',
+          '--',
+          'armasm64',
+          '-I' + asm_inc] + asm_args + [
+          '@INPUT@',
+          '-c', '-o', '@OUTPUT@'])
+    endif
+  else
+    # Windows only supports x86, x86_64, arm, arm64
+    error('unreachable code')
+  endif
+endif
+
+subdir ('codec')
+subdir ('test')
+
+libopenh264 = library('openh264',
+  link_whole: [libcommon, libprocessing, libencoder, libdecoder],
+  install: true,
+  soversion: major_version,
+  version: meson.project_version(),
+  vs_module_defs: 'openh264.def',
+  dependencies: deps)
+
+openh264_dep = declare_dependency(
+  link_with: libopenh264,
+  include_directories: include_directories('codec/api'),
+  dependencies: deps)
+
+pkg = import('pkgconfig')
+pkg.generate(libopenh264,
+  description: 'OpenH264 is a codec library which supports H.264 encoding ' +
+               'and decoding. It is suitable for use in real time ' +
+               'applications such as WebRTC.',
+)

package/openh264/meson_options.txt

@@ -0,0 +1 @@
+option('tests', type : 'feature', value : 'auto', yield : true)

package/openh264/module/RefCounted.h

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2015, Mozilla Foundation and contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __RefCount_h__
+#define __RefCount_h__
+
+#include <stdint.h>
+#include <assert.h>
+
+extern GMPPlatformAPI* g_platform_api;
+
+inline GMPMutex* GMPCreateMutex() {
+  GMPMutex* mutex;
+  if (!g_platform_api) {
+    return nullptr;
+  }
+  GMPErr err = g_platform_api->createmutex(&mutex);
+  assert(mutex);
+  return GMP_FAILED(err) ? nullptr : mutex;
+}
+
+class AutoLock {
+public:
+  explicit AutoLock(GMPMutex* aMutex)
+    : mMutex(aMutex)
+  {
+    assert(aMutex);
+    if (mMutex) {
+      mMutex->Acquire();
+    }
+  }
+  ~AutoLock() {
+    if (mMutex) {
+      mMutex->Release();
+    }
+  }
+private:
+  GMPMutex* mMutex;
+};
+
+class AtomicRefCount {
+public:
+  explicit AtomicRefCount(uint32_t aValue)
+    : mCount(aValue)
+    , mMutex(GMPCreateMutex())
+  {
+    assert(mMutex);
+  }
+  ~AtomicRefCount()
+  {
+    if (mMutex) {
+      mMutex->Destroy();
+    }
+  }
+  uint32_t operator--() {
+    AutoLock lock(mMutex);
+    return --mCount;
+  }
+  uint32_t operator++() {
+    AutoLock lock(mMutex);
+    return ++mCount;
+  }
+  operator uint32_t() {
+    AutoLock lock(mMutex);
+    return mCount;
+  }
+private:
+  uint32_t mCount;
+  GMPMutex* mMutex;
+};
+
+// Note: Thread safe.
+class RefCounted {
+public:
+  void AddRef() {
+    ++mRefCount;
+  }
+
+  uint32_t Release() {
+    uint32_t newCount = --mRefCount;
+    if (!newCount) {
+      delete this;
+    }
+    return newCount;
+  }
+
+protected:
+  RefCounted()
+    : mRefCount(0)
+  {
+  }
+  virtual ~RefCounted()
+  {
+    assert(!mRefCount);
+  }
+  AtomicRefCount mRefCount;
+};
+
+template<class T>
+class RefPtr {
+public:
+  explicit RefPtr(T* aPtr) : mPtr(nullptr) {
+    Assign(aPtr);
+  }
+  ~RefPtr() {
+    Assign(nullptr);
+  }
+  T* operator->() const { return mPtr; }
+
+  RefPtr& operator=(T* aVal) {
+    Assign(aVal);
+    return *this;
+  }
+
+private:
+  void Assign(T* aPtr) {
+    if (mPtr) {
+      mPtr->Release();
+    }
+    mPtr = aPtr;
+    if (mPtr) {
+      aPtr->AddRef();
+    }
+  }
+  T* mPtr;
+};
+
+#endif // __RefCount_h__