bare-ffmpeg 1.0.0-9 → 1.0.0

package/cmake/ports/svt-av1/port.cmake

@@ -0,0 +1,42 @@
+include_guard(GLOBAL)
+
+if(WIN32)
+  set(lib SvtAv1Enc.lib)
+else()
+  set(lib libSvtAv1Enc.a)
+endif()
+
+set(args
+  -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+  -DBUILD_SHARED_LIBS=OFF
+  -DBUILD_TESTING=OFF
+  -DBUILD_APPS=OFF
+)
+
+if(WIN32)
+  list(APPEND args -DCOMPILE_C_ONLY=ON)
+endif()
+
+declare_port(
+  "gitlab:AOMediaCodec/SVT-AV1@2.3.0"
+  svt-av1
+  BYPRODUCTS lib/${lib}
+  ARGS ${args}
+)
+
+add_library(svt-av1 STATIC IMPORTED GLOBAL)
+
+add_dependencies(svt-av1 ${svt-av1})
+
+set_target_properties(
+  svt-av1
+  PROPERTIES
+  IMPORTED_LOCATION "${svt-av1_PREFIX}/lib/${lib}"
+)
+
+file(MAKE_DIRECTORY "${svt-av1_PREFIX}/include")
+
+target_include_directories(
+  svt-av1
+  INTERFACE "${svt-av1_PREFIX}/include"
+)

package/cmake/ports/x264/patches/01-windows-clang.patch

@@ -0,0 +1,33 @@
+diff --git a/configure b/configure
+index e242e73..28b4bfe 100755
+--- a/configure
++++ b/configure
+@@ -606,7 +606,7 @@ if [[ $host_os = mingw* || $host_os = msys* || $host_os = cygwin* ]]; then
+         if cc_check '' -Qdiag-error:10006,10157 ; then
+             CHECK_CFLAGS="$CHECK_CFLAGS -Qdiag-error:10006,10157"
+         fi
+-    elif [[ "$cc_base" = cl || "$cc_base" = cl[\ .]* ]]; then
++    elif [[ "$cc_base" = cl || "$cc_base" = cl[\ .]* || "$cc_base" = clang-cl || "$cc_base" = clang-cl[\ .]* ]]; then
+         # Standard Microsoft Visual Studio
+         compiler=CL
+         compiler_style=MS
+@@ -1458,8 +1458,8 @@ fi
+ DEPMM="${QPRE}MM"
+ DEPMT="${QPRE}MT"
+ if [ $compiler_style = MS ]; then
+-    AR="lib.exe -nologo -out:"
+-    LD="link.exe -out:"
++    AR="${AR-lib.exe} -nologo -out:"
++    LD="${LD-link.exe} -out:"
+     if [ $compiler = ICL ]; then
+         AR="xi$AR"
+         LD="xi$LD"
+@@ -1470,7 +1470,7 @@ if [ $compiler_style = MS ]; then
+     HAVE_GETOPT_LONG=0
+     LDFLAGS="-nologo -incremental:no $(cl_ldflags $LDFLAGS)"
+     LDFLAGSCLI="$(cl_ldflags $LDFLAGSCLI)"
+-    LIBX264=libx264.lib
++    LIBX264=x264.lib
+     RANLIB=
+     [ -n "$RC" ] && RCFLAGS="$RCFLAGS -nologo -I. -I\$(SRCPATH)/extras -fo"
+     STRIP=

package/cmake/ports/x264/port.cmake

@@ -0,0 +1,162 @@
+include_guard(GLOBAL)
+
+if(WIN32)
+  set(lib x264.lib)
+else()
+  set(lib libx264.a)
+endif()
+
+set(env)
+
+set(args
+  --disable-cli
+
+  --enable-static
+  --enable-strip
+  --enable-pic
+)
+
+if(CMAKE_BUILD_TYPE MATCHES "Debug|RelWithDebInfo")
+  list(APPEND args --enable-debug)
+endif()
+
+if(CMAKE_SYSTEM_NAME)
+  set(platform ${CMAKE_SYSTEM_NAME})
+else()
+  set(platform ${CMAKE_HOST_SYSTEM_NAME})
+endif()
+
+string(TOLOWER "${platform}" platform)
+
+if(platform MATCHES "darwin|ios")
+  set(platform "darwin")
+elseif(platform MATCHES "linux|android")
+  set(platform "linux")
+elseif(platform MATCHES "windows")
+  set(platform "msys")
+else()
+  message(FATAL_ERROR "Unsupported platform '${platform}'")
+endif()
+
+if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+  set(arch ${CMAKE_OSX_ARCHITECTURES})
+elseif(MSVC AND CMAKE_GENERATOR_PLATFORM)
+  set(arch ${CMAKE_GENERATOR_PLATFORM})
+elseif(ANDROID AND CMAKE_ANDROID_ARCH_ABI)
+  set(arch ${CMAKE_ANDROID_ARCH_ABI})
+elseif(CMAKE_SYSTEM_PROCESSOR)
+  set(arch ${CMAKE_SYSTEM_PROCESSOR})
+else()
+  set(arch ${CMAKE_HOST_SYSTEM_PROCESSOR})
+endif()
+
+string(TOLOWER "${arch}" arch)
+
+if(arch MATCHES "arm64|aarch64")
+  set(arch "aarch64")
+elseif(arch MATCHES "armv7-a|armeabi-v7a")
+  set(arch "arm")
+elseif(arch MATCHES "x64|x86_64|amd64")
+  set(arch "x86_64")
+elseif(arch MATCHES "x86|i386|i486|i586|i686")
+  set(arch "i686")
+else()
+  message(FATAL_ERROR "Unsupported architecture '${arch}'")
+endif()
+
+list(APPEND args --host=${arch}-${platform})
+
+if(APPLE)
+  list(APPEND args --sysroot=${CMAKE_OSX_SYSROOT})
+elseif(ANDROID)
+  list(APPEND args --sysroot=${CMAKE_SYSROOT} --disable-asm)
+elseif(WIN32)
+  list(APPEND args --disable-asm)
+endif()
+
+if(CMAKE_C_COMPILER)
+  cmake_path(GET CMAKE_C_COMPILER PARENT_PATH CC_path)
+  cmake_path(GET CMAKE_C_COMPILER FILENAME CC_filename)
+
+  list(APPEND env "CC=${CC_filename}")
+
+  list(APPEND args
+    --extra-cflags=--target=${CMAKE_C_COMPILER_TARGET}
+    --extra-ldflags=--target=${CMAKE_C_COMPILER_TARGET}
+  )
+
+  if(CMAKE_LINKER_TYPE MATCHES "LLD")
+    list(APPEND args --extra-ldflags=-fuse-ld=lld)
+  endif()
+
+  list(APPEND env --modify "PATH=path_list_prepend:${CC_path}")
+endif()
+
+if(CMAKE_ASM_NASM_COMPILER)
+  cmake_path(GET CMAKE_ASM_NASM_COMPILER PARENT_PATH AS_path)
+  cmake_path(GET CMAKE_ASM_NASM_COMPILER FILENAME AS_filename)
+
+  list(APPEND env "AS=${AS_filename}")
+
+  list(APPEND env --modify "PATH=path_list_prepend:${AS_path}")
+elseif(CMAKE_ASM_COMPILER)
+  cmake_path(GET CMAKE_ASM_COMPILER PARENT_PATH AS_path)
+  cmake_path(GET CMAKE_ASM_COMPILER FILENAME AS_filename)
+
+  list(APPEND env "AS=${AS_filename}")
+
+  list(APPEND args --extra-asflags=--target=${CMAKE_ASM_COMPILER_TARGET})
+
+  list(APPEND env --modify "PATH=path_list_prepend:${AS_path}")
+endif()
+
+if(CMAKE_RC_COMPILER)
+  cmake_path(GET CMAKE_RC_COMPILER PARENT_PATH RC_path)
+  cmake_path(GET CMAKE_RC_COMPILER FILENAME RC_filename)
+
+  list(APPEND env "RC=${RC_filename}")
+
+  list(APPEND env --modify "PATH=path_list_prepend:${RC_path}")
+endif()
+
+if(CMAKE_AR)
+  cmake_path(GET CMAKE_AR PARENT_PATH AR_path)
+  cmake_path(GET CMAKE_AR FILENAME AR_filename)
+
+  list(APPEND env "AR=${AR_filename}")
+
+  list(APPEND env --modify "PATH=path_list_prepend:${AR_path}")
+endif()
+
+set(patches)
+
+if(WIN32)
+  list(APPEND patches patches/01-windows-clang.patch)
+endif()
+
+declare_port(
+  "git:code.videolan.org/videolan/x264#stable"
+  x264
+  AUTOTOOLS
+  BYPRODUCTS lib/${lib}
+  ARGS ${args}
+  ENV ${env}
+  PATCHES ${patches}
+)
+
+add_library(x264 STATIC IMPORTED GLOBAL)
+
+add_dependencies(x264 ${x264})
+
+set_target_properties(
+  x264
+  PROPERTIES
+  IMPORTED_LOCATION "${x264_PREFIX}/lib/${lib}"
+)
+
+file(MAKE_DIRECTORY "${x264_PREFIX}/include")
+
+target_include_directories(
+  x264
+  INTERFACE "${x264_PREFIX}/include"
+)

package/index.js

@@ -1,30 +1,48 @@
+const AudioFIFO = require('./lib/audio-fifo')
+const ChannelLayout = require('./lib/channel-layout')
 const Codec = require('./lib/codec')
 const CodecContext = require('./lib/codec-context')
 const CodecParameters = require('./lib/codec-parameters')
 const Decoder = require('./lib/decoder')
+const Dictionary = require('./lib/dictionary')
 const Encoder = require('./lib/encoder')
-const {
-  InputFormatContext,
-  OutputFormatContext
-} = require('./lib/format-context')
+const { InputFormatContext, OutputFormatContext } = require('./lib/format-context')
+const Filter = require('./lib/filter')
+const FilterContext = require('./lib/filter-context')
+const FilterGraph = require('./lib/filter-graph')
+const FilterInOut = require('./lib/filter-inout')
 const Frame = require('./lib/frame')
-const Image = require('./lib/image')
+const HWDeviceContext = require('./lib/hw-device-context')
+const HWFramesContext = require('./lib/hw-frames-context')
+const HWFramesConstraints = require('./lib/hw-frames-constraints')
 const IOContext = require('./lib/io-context')
+const Image = require('./lib/image')
 const InputFormat = require('./lib/input-format')
 const OutputFormat = require('./lib/output-format')
 const Packet = require('./lib/packet')
-const Scaler = require('./lib/scaler')
-const Stream = require('./lib/stream')
 const Rational = require('./lib/rational')
-const Dictionary = require('./lib/dictionary')
 const Resampler = require('./lib/resampler')
+const Samples = require('./lib/samples')
+const Scaler = require('./lib/scaler')
+const Stream = require('./lib/stream')
+const log = require('./lib/log')
 
+exports.AudioFIFO = AudioFIFO
+exports.ChannelLayout = ChannelLayout
 exports.Codec = Codec
 exports.CodecContext = CodecContext
 exports.CodecParameters = CodecParameters
 exports.Decoder = Decoder
+exports.Dictionary = Dictionary
 exports.Encoder = Encoder
+exports.Filter = Filter
+exports.FilterContext = FilterContext
+exports.FilterGraph = FilterGraph
+exports.FilterInOut = FilterInOut
 exports.Frame = Frame
+exports.HWDeviceContext = HWDeviceContext
+exports.HWFramesContext = HWFramesContext
+exports.HWFramesConstraints = HWFramesConstraints
 exports.IOContext = IOContext
 exports.Image = Image
 exports.InputFormat = InputFormat
@@ -32,10 +50,11 @@ exports.InputFormatContext = InputFormatContext
 exports.OutputFormat = OutputFormat
 exports.OutputFormatContext = OutputFormatContext
 exports.Packet = Packet
+exports.Samples = Samples
 exports.Scaler = Scaler
 exports.Stream = Stream
 exports.Rational = Rational
-exports.Dictionary = Dictionary
 exports.Resampler = Resampler
+exports.log = log
 
 exports.constants = require('./lib/constants')

package/lib/audio-fifo.js

@@ -0,0 +1,47 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = class FFmpegAudioFIFO {
+  constructor(sampleFormat, channels, nbSamples) {
+    sampleFormat = constants.toSampleFormat(sampleFormat)
+
+    this._handle = binding.initAudioFifo(sampleFormat, channels, nbSamples)
+  }
+
+  destroy() {
+    binding.destroyAudioFifo(this._handle)
+    this._handle = null
+  }
+
+  write(frame) {
+    return binding.writeAudioFifo(this._handle, frame._handle)
+  }
+
+  read(frame, nbSamples) {
+    return binding.readAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  peek(frame, nbSamples) {
+    return binding.peekAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  drain(nbSamples) {
+    return binding.drainAudioFifo(this._handle, nbSamples)
+  }
+
+  reset() {
+    binding.resetAudioFifo(this._handle)
+  }
+
+  get size() {
+    return binding.getAudioFifoSize(this._handle)
+  }
+
+  get space() {
+    return binding.getAudioFifoSpace(this._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/channel-layout.js

@@ -0,0 +1,35 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = class FFmpegChannelLayout {
+  constructor(handle) {
+    this._handle = handle
+  }
+
+  get nbChannels() {
+    return binding.getChannelLayoutNbChannels(this._handle)
+  }
+
+  get mask() {
+    return binding.getChannelLayoutMask(this._handle)
+  }
+
+  static from(value) {
+    if (typeof value === 'string') value = constants.toChannelLayout(value)
+
+    if (typeof value === 'number') {
+      value = binding.channelLayoutFromMask(value)
+    } else if (typeof value === 'object' && value !== null) {
+      value = binding.copyChannelLayout(value._handle)
+    }
+
+    return new this(value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegChannelLayout },
+      nbChannels: this.nbChannels
+    }
+  }
+}

package/lib/codec-context.js

@@ -1,5 +1,8 @@
 const binding = require('../binding')
 const Rational = require('./rational')
+const ChannelLayout = require('./channel-layout')
+const HWDeviceContext = require('./hw-device-context')
+const { codecConfig, optionFlags } = require('./constants')
 
 module.exports = class FFmpegCodecContext {
   constructor(codec) {
@@ -37,17 +40,101 @@ module.exports = class FFmpegCodecContext {
     binding.setCodecContextHeight(this._handle, value)
   }
 
+  get sampleFormat() {
+    return binding.getCodecContextSampleFormat(this._handle)
+  }
+
+  set sampleFormat(value) {
+    return binding.setCodecContextSampleFormat(this._handle, value)
+  }
+
+  get sampleRate() {
+    return binding.getCodecContextSampleRate(this._handle)
+  }
+
+  set sampleRate(value) {
+    binding.setCodecContextSampleRate(this._handle, value)
+  }
+
   get timeBase() {
     const view = new Int32Array(binding.getCodecContextTimeBase(this._handle))
     return new Rational(view[0], view[1])
   }
 
   set timeBase(value) {
-    binding.setCodecContextTimeBase(
-      this._handle,
-      value.numerator,
-      value.denominator
-    )
+    binding.setCodecContextTimeBase(this._handle, value.numerator, value.denominator)
+  }
+
+  get frameRate() {
+    const view = new Int32Array(binding.getCodecContextFramerate(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set frameRate(value) {
+    binding.setCodecContextFramerate(this._handle, value.numerator, value.denominator)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(binding.getCodecContextChannelLayout(this._handle))
+  }
+
+  set channelLayout(value) {
+    binding.setCodecContextChannelLayout(this._handle, ChannelLayout.from(value)._handle)
+  }
+
+  get gopSize() {
+    return binding.getCodecContextGOPSize(this._handle)
+  }
+
+  set gopSize(value) {
+    binding.setCodecContextGOPSize(this._handle, value)
+  }
+
+  get flags() {
+    return binding.getCodecContextFlags(this._handle)
+  }
+
+  set flags(value) {
+    binding.setCodecContextFlags(this._handle, value)
+  }
+
+  get extraData() {
+    return Buffer.from(binding.getCodecContextExtraData(this._handle))
+  }
+
+  set extraData(value) {
+    binding.setCodecContextExtraData(this._handle, value.buffer, value.byteOffset, value.byteLength)
+  }
+
+  get frameSize() {
+    return binding.getCodecContextFrameSize(this._handle)
+  }
+
+  get frameNum() {
+    return binding.getCodecContextFrameNum(this._handle)
+  }
+
+  get requestSampleFormat() {
+    return binding.getCodecContextRequestSampleFormat(this._handle)
+  }
+
+  set requestSampleFormat(sampleFormat) {
+    binding.setCodecContextRequestSampleFormat(this._handle, sampleFormat)
+  }
+
+  get hwDeviceCtx() {
+    return HWDeviceContext.from(binding.getCodecContextHWDeviceCtx(this._handle))
+  }
+
+  set hwDeviceCtx(hwDeviceContext) {
+    binding.setCodecContextHWDeviceCtx(this._handle, hwDeviceContext._handle)
+  }
+
+  set getFormat(callback) {
+    const wrap = (pixelFormats) => {
+      return callback(this, pixelFormats)
+    }
+    binding.setCodecContextGetFormat(this._handle, wrap)
   }
 
   open(options) {
@@ -58,7 +145,6 @@ module.exports = class FFmpegCodecContext {
     } else {
       binding.openCodecContext(this._handle)
     }
-    return this
   }
 
   sendPacket(packet) {
@@ -70,14 +156,106 @@ module.exports = class FFmpegCodecContext {
   }
 
   sendFrame(frame) {
-    return binding.sendCodecContextFrame(this._handle, frame._handle)
+    let frameHandle = undefined
+
+    if (frame) frameHandle = frame._handle
+
+    return binding.sendCodecContextFrame(this._handle, frameHandle)
   }
 
   receiveFrame(frame) {
     return binding.receiveCodecContextFrame(this._handle, frame._handle)
   }
 
+  getSupportedConfig(config) {
+    if (config === codecConfig.FRAME_RATE) {
+      const data = binding.getSupportedFrameRates(this._handle, this._codec._handle)
+      if (!data || data.length === 0) return null
+
+      const view = new Int32Array(data)
+      const rates = []
+      for (let i = 0; i < view.length; i += 2) {
+        rates.push(new Rational(view[i], view[i + 1]))
+      }
+      return rates
+    }
+
+    if (config === codecConfig.CHANNEL_LAYOUT) {
+      const handles = binding.getSupportedChannelLayouts(this._handle, this._codec._handle)
+      if (!handles || handles.length === 0) return null
+
+      return handles.map((handle) => new ChannelLayout(handle))
+    }
+
+    const data = binding.getSupportedConfig(this._handle, this._codec._handle, config)
+
+    if (config === codecConfig.SAMPLE_RATE && !data) {
+      return null
+    }
+
+    return new Int32Array(data)
+  }
+
+  getOption(name, flags = optionFlags.SEARCH_CHILDREN) {
+    return binding.getOption(this._handle, name, flags)
+  }
+
+  setOption(name, value, flags = optionFlags.SEARCH_CHILDREN) {
+    return binding.setOption(this._handle, name, value, flags)
+  }
+
+  setOptionDictionary(dictionary, flags = optionFlags.SEARCH_CHILDREN) {
+    return binding.setOptionDictionary(this._handle, dictionary._handle, flags)
+  }
+
+  setOptionDefaults() {
+    return binding.setOptionDefaults(this._handle)
+  }
+
+  listOptionNames(flags = optionFlags.SEARCH_CHILDREN) {
+    return binding.listOptionNames(this._handle, flags)
+  }
+
+  getOptions(flags) {
+    const options = {}
+
+    for (const name of this.listOptionNames(flags)) {
+      try {
+        options[name] = this.getOption(name, flags)
+      } catch (error) {
+        // TODO: handle binary and other non-string types
+      }
+    }
+
+    return options
+  }
+
+  copyOptionsFrom(codecContext) {
+    binding.copyOptions(this._handle, codecContext._handle)
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodecContext },
+      _codec: this._codec,
+      _opened: this._opened,
+      flags: this.flags,
+      pixelFormat: this.pixelFormat,
+      width: this.width,
+      height: this.height,
+      sampleFormat: this.sampleFormat,
+      sampleRate: this.sampleRate,
+      timeBase: this.timeBase,
+      channelLayout: this.channelLayout,
+      gopSize: this.gopSize,
+      extraData: this.extraData,
+      frameRate: this.frameRate,
+      frameSize: this.frameSize,
+      frameNum: this.frameNum
+    }
+  }
 }