bare-ffmpeg 1.0.0-2 → 1.0.0-20

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,27 +1,35 @@
+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 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.Frame = Frame
 exports.IOContext = IOContext
@@ -31,9 +39,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,15 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 const Rational = require('./rational')
+const ChannelLayout = require('./channel-layout')
 
-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 +38,73 @@ 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)
   }
 
   open(options) {
@@ -64,21 +119,43 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
   }
 
   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)
   }
+
+  [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
+    }
+  }
 }

package/lib/codec-parameters.js

@@ -1,33 +1,157 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
-module.exports = class FFmpegCodecParameters extends ReferenceCounted {
+module.exports = class FFmpegCodecParameters {
   constructor(handle) {
-    super()
-
     this._handle = handle
   }
 
-  _destroy() {
-    this._handle = null
-  }
-
   get bitRate() {
     return binding.getCodecParametersBitRate(this._handle)
   }
 
+  set bitRate(rate) {
+    binding.setCodecParametersBitRate(this._handle, rate)
+  }
+
   get bitsPerCodedSample() {
     return binding.getCodecParametersBitsPerCodedSample(this._handle)
   }
 
+  set bitsPerCodedSample(bits) {
+    binding.setCodecParametersBitsPerCodedSample(this._handle, bits)
+  }
+
   get bitsPerRawSample() {
     return binding.getCodecParametersBitsPerRawSample(this._handle)
   }
 
+  set bitsPerRawSample(bits) {
+    binding.setCodecParametersBitsPerRawSample(this._handle, bits)
+  }
+
   get sampleRate() {
     return binding.getCodecParametersSampleRate(this._handle)
   }
 
+  set sampleRate(rate) {
+    binding.setCodecParametersSampleRate(this._handle, rate)
+  }
+
+  get frameRate() {
+    const view = new Int32Array(
+      binding.getCodecParametersFramerate(this._handle)
+    )
+    return new Rational(view[0], view[1])
+  }
+
+  set frameRate(rate) {
+    binding.setCodecParametersFramerate(
+      this._handle,
+      rate.numerator,
+      rate.denominator
+    )
+  }
+
+  get nbChannels() {
+    return binding.getCodecParametersNbChannels(this._handle)
+  }
+
+  set nbChannels(numberOfChannels) {
+    binding.setCodecParametersNbChannels(this._handle, numberOfChannels)
+  }
+
+  get type() {
+    return binding.getCodecParametersType(this._handle)
+  }
+
+  set type(type) {
+    binding.setCodecParametersType(this._handle, type)
+  }
+
+  get tag() {
+    return binding.getCodecParametersTag(this._handle)
+  }
+
+  set tag(tag) {
+    binding.setCodecParametersTag(this._handle, tag)
+  }
+
+  get id() {
+    return binding.getCodecParametersId(this._handle)
+  }
+
+  set id(id) {
+    binding.setCodecParametersId(this._handle, id)
+  }
+
+  get level() {
+    return binding.getCodecParametersLevel(this._handle)
+  }
+
+  set level(level) {
+    binding.setCodecParametersLevel(this._handle, level)
+  }
+
+  get profile() {
+    return binding.getCodecParametersProfile(this._handle)
+  }
+
+  set profile(profile) {
+    binding.setCodecParametersProfile(this._handle, profile)
+  }
+
+  get format() {
+    return binding.getCodecParametersFormat(this._handle)
+  }
+
+  set format(format) {
+    binding.setCodecParametersFormat(this._handle, format)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(
+      binding.getCodecParametersChannelLayout(this._handle)
+    )
+  }
+
+  set channelLayout(value) {
+    binding.setCodecParametersChannelLayout(
+      this._handle,
+      ChannelLayout.from(value)._handle
+    )
+  }
+
+  get width() {
+    return binding.getCodecParametersWidth(this._handle)
+  }
+
+  set width(value) {
+    binding.setCodecParametersWidth(this._handle, value)
+  }
+
+  get height() {
+    return binding.getCodecParametersHeight(this._handle)
+  }
+
+  set height(value) {
+    binding.setCodecParametersHeight(this._handle, value)
+  }
+
+  get extraData() {
+    return Buffer.from(binding.getCodecParametersExtraData(this._handle))
+  }
+
+  set extraData(value) {
+    binding.setCodecParametersExtraData(
+      this._handle,
+      value.buffer,
+      value.byteOffset,
+      value.byteLength
+    )
+  }
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -35,4 +159,26 @@ module.exports = class FFmpegCodecParameters extends ReferenceCounted {
   toContext(context) {
     binding.codecParametersToContext(context._handle, this._handle)
   }
+
+  // TODO: add other props
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodecParameters },
+      type: this.type,
+      id: this.id,
+      format: this.format,
+      profile: this.profile,
+      level: this.level,
+      width: this.width,
+      height: this.height,
+      bitRate: this.bitRate,
+      bitsPerCodedSample: this.bitsPerCodedSample,
+      bitsPerRawSample: this.bitsPerRawSample,
+      sampleRate: this.sampleRate,
+      nbChannels: this.nbChannels,
+      channelLayout: this.channelLayout,
+      frameRate: this.frameRate,
+      extraData: this.extraData
+    }
+  }
 }

package/lib/codec.js

@@ -1,6 +1,7 @@
 const Decoder = require('./decoder')
 const Encoder = require('./encoder')
 const constants = require('./constants')
+const binding = require('../binding')
 
 const codecs = new Map()
 
@@ -25,6 +26,21 @@ module.exports = class FFmpegCodec {
     return this._encoder
   }
 
+  get name() {
+    if (Number.isInteger(this._id)) {
+      return binding.getCodecNameByID(this._id)
+    }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodec },
+      id: this.id,
+      name: this.name
+    }
+  }
+
+  /** @return {FFmpegCodec} */
   static for(id) {
     let codec = codecs.get(id)
     if (codec === undefined) {
@@ -36,4 +52,7 @@ module.exports = class FFmpegCodec {
 
   static MJPEG = this.for(constants.codecs.MJPEG)
   static H264 = this.for(constants.codecs.H264)
+  static AAC = this.for(constants.codecs.AAC)
+  static OPUS = this.for(constants.codecs.OPUS)
+  static AV1 = this.for(constants.codecs.AV1)
 }