bare-ffmpeg 1.0.0-3 → 1.0.0-31

package/cmake/ports/x264/port.cmake

@@ -0,0 +1,157 @@
+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()
+
+declare_port(
+  "git:code.videolan.org/videolan/x264#stable"
+  x264
+  AUTOTOOLS
+  BYPRODUCTS lib/${lib}
+  ARGS ${args}
+  ENV ${env}
+  PATCHES
+    patches/01-windows-clang.patch
+)
+
+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,28 +1,44 @@
+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 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 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 Rational = require('./lib/rational')
+const Resampler = require('./lib/resampler')
+const Samples = require('./lib/samples')
 const Scaler = require('./lib/scaler')
 const Stream = require('./lib/stream')
-const Rational = require('./lib/rational')
-const Dictionary = require('./lib/dictionary')
+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.IOContext = IOContext
 exports.Image = Image
@@ -31,9 +47,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,17 +1,16 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 const Rational = require('./rational')
+const ChannelLayout = require('./channel-layout')
+const { codecConfig, optionFlags } = require('./constants')
 
-module.exports = class FFmpegCodecContext extends ReferenceCounted {
+module.exports = class FFmpegCodecContext {
   constructor(codec) {
-    super()
-
     this._codec = codec
     this._opened = false
     this._handle = binding.initCodecContext(codec._handle)
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyCodecContext(this._handle)
     this._handle = null
   }
@@ -40,16 +39,109 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
     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) {
-    const view = new Int32Array(2)
-    view[0] = value.numerator
-    view[1] = value.denominator
-    binding.setCodecContextTimeBase(this._handle, view.buffer)
+    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)
+  }
+
+  set getFormat(callback) {
+    const wrap = (pixelFormats) => {
+      return callback(this, pixelFormats)
+    }
+    binding.setCodecContextGetFormat(this._handle, wrap)
   }
 
   open(options) {
@@ -60,25 +152,127 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
     } else {
       binding.openCodecContext(this._handle)
     }
-    return this
   }
 
   sendPacket(packet) {
-    binding.sendCodecContextPacket(this._handle, packet._handle)
-    return this
+    return binding.sendCodecContextPacket(this._handle, packet._handle)
   }
 
   receivePacket(packet) {
-    const res = binding.receiveCodecContextPacket(this._handle, packet._handle)
-    if (res) packet._ref()
-    return res
+    return binding.receiveCodecContextPacket(this._handle, packet._handle)
   }
 
   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
+    }
+  }
 }