bare-ffmpeg 1.0.0-8 → 1.0.0

package/lib/io-context.js

@@ -1,11 +1,28 @@
 const binding = require('../binding')
 
 module.exports = class FFmpegIOContext {
-  constructor(buffer = Buffer.alloc(0)) {
+  constructor(buffer, opts = {}) {
+    let offset = 0
+    let len = 0
+
+    if (typeof buffer === 'number') {
+      len = buffer
+      buffer = undefined
+    } else if (buffer) {
+      offset = buffer.byteOffset
+      len = buffer.byteLength
+      buffer = buffer.buffer
+    } else {
+      buffer = Buffer.alloc(0)
+    }
+
     this._handle = binding.initIOContext(
-      buffer.buffer,
-      buffer.byteOffset,
-      buffer.byteLength
+      buffer,
+      offset,
+      len,
+      opts.onwrite && onwriteWrapper.bind(null, opts.onwrite),
+      opts.onread && onreadWrapper.bind(null, opts.onread),
+      opts.onseek
     )
   }
 
@@ -18,3 +35,11 @@ module.exports = class FFmpegIOContext {
     this.destroy()
   }
 }
+
+function onwriteWrapper(target, arraybuffer) {
+  return target(Buffer.from(arraybuffer))
+}
+
+function onreadWrapper(target, arraybuffer, requestedLen) {
+  return target(Buffer.from(arraybuffer), requestedLen)
+}

package/lib/log.js

@@ -0,0 +1,16 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = {
+  ...constants.logLevels
+}
+
+Object.defineProperty(module.exports, 'level', {
+  get() {
+    return binding.getLogLevel()
+  },
+
+  set(level) {
+    return binding.setLogLevel(level)
+  }
+})

package/lib/output-format.js

@@ -1,7 +1,38 @@
 const binding = require('../binding')
 
 module.exports = class FFmpegOutputFormat {
-  constructor(name) {
-    this._handle = binding.initOutputFormat(name)
+  constructor(name, handle) {
+    if (handle) this._handle = handle
+    else this._handle = binding.initOutputFormat(name)
+  }
+
+  static from(handle) {
+    return new FFmpegOutputFormat(null, handle)
+  }
+
+  get flags() {
+    return binding.getOutputFormatFlags(this._handle)
+  }
+
+  get extensions() {
+    return binding.getOutputFormatExtensions(this._handle)
+  }
+
+  get mimeType() {
+    return binding.getOutputFormatMimeType(this._handle)
+  }
+
+  get name() {
+    return binding.getOutputFormatName(this._handle)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegOutputFormat },
+      name: this.name,
+      flags: this.flags,
+      extensions: this.extensions,
+      mimeType: this.mimeType
+    }
   }
 }

package/lib/packet.js

@@ -1,4 +1,41 @@
 const binding = require('../binding')
+const Rational = require('./rational')
+
+class SideData {
+  constructor(handle, opts = {}) {
+    this._handle = handle
+    this._type = opts.type || null
+    this._data = opts.data || null
+  }
+
+  static fromData(data, type) {
+    return new SideData(null, { data, type })
+  }
+
+  get type() {
+    if (this._type) return this._type
+    return binding.getSideDataType(this._handle)
+  }
+
+  get name() {
+    if (!this._handle) return null
+    return binding.getSideDataName(this._handle)
+  }
+
+  get data() {
+    if (this._data) return this._data
+    return Buffer.from(binding.getSideDataBuffer(this._handle))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: SideData },
+      type: this.type,
+      name: this.name,
+      data: this.data
+    }
+  }
+}
 
 module.exports = class FFmpegPacket {
   constructor(buffer) {
@@ -14,7 +51,7 @@ module.exports = class FFmpegPacket {
   }
 
   destroy() {
-    binding.unrefPacket(this._handle)
+    binding.destroyPacket(this._handle)
     this._handle = null
   }
 
@@ -26,11 +63,116 @@ module.exports = class FFmpegPacket {
     return binding.getPacketStreamIndex(this._handle)
   }
 
+  set streamIndex(value) {
+    return binding.setPacketStreamIndex(this._handle, value)
+  }
+
   get data() {
     return Buffer.from(binding.getPacketData(this._handle))
   }
 
+  set data(value) {
+    binding.setPacketData(this._handle, value.buffer, value.byteOffset, value.byteLength)
+  }
+
+  get sideData() {
+    const handles = binding.getPacketSideData(this._handle)
+    return handles.map((handle) => new SideData(handle))
+  }
+
+  set sideData(values) {
+    binding.setPacketSideData(
+      this._handle,
+      values.map((value) => ({
+        buffer: value.data.buffer,
+        offset: value.data.byteOffset,
+        length: value.data.byteLength,
+        type: value.type
+      }))
+    )
+  }
+
+  get isKeyframe() {
+    return binding.isPacketKeyframe(this._handle)
+  }
+
+  set isKeyframe(value) {
+    binding.setPacketIsKeyFrame(this._handle, value)
+  }
+
+  get dts() {
+    return binding.getPacketDTS(this._handle)
+  }
+
+  set dts(value) {
+    return binding.setPacketDTS(this._handle, value)
+  }
+
+  get pts() {
+    return binding.getPacketPTS(this._handle)
+  }
+
+  set pts(value) {
+    return binding.setPacketPTS(this._handle, value)
+  }
+
+  get timeBase() {
+    const view = new Int32Array(binding.getPacketTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    binding.setPacketTimeBase(this._handle, value.numerator, value.denominator)
+  }
+
+  rescaleTimestamps(srcTimeBase, dstTimeBase) {
+    return binding.rescalePacketTimestamps(
+      this._handle,
+      srcTimeBase.numerator,
+      srcTimeBase.denominator,
+      dstTimeBase.numerator,
+      dstTimeBase.denominator
+    )
+  }
+
+  copyPropsFrom(sourcePacket) {
+    binding.copyPacketProps(this._handle, sourcePacket._handle)
+  }
+
+  get duration() {
+    return binding.getPacketDuration(this._handle)
+  }
+
+  set duration(value) {
+    return binding.setPacketDuration(this._handle, value)
+  }
+
+  get flags() {
+    return binding.getPacketFlags(this._handle)
+  }
+
+  set flags(value) {
+    return binding.setPacketFlags(this._handle, value)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegPacket },
+      streamIndex: this.streamIndex,
+      flags: this.flags,
+      isKeyframe: this.isKeyframe,
+      timeBase: this.timeBase,
+      dts: this.dts,
+      pts: this.pts,
+      duration: this.duration,
+      data: this.data,
+      sideData: this.sideData
+    }
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }
 }
+
+module.exports.SideData = SideData

package/lib/rational.js

@@ -1,6 +1,51 @@
+const binding = require('../binding')
+const { AV_ROUND_NEAR_INF } = require('./constants').rounding
+
 module.exports = class FFmpegRational {
-  constructor(numerator, denominator) {
+  constructor(numerator = 0, denominator = 1) {
     this.numerator = numerator
     this.denominator = denominator
   }
+
+  get valid() {
+    // don't support negative denominators for now
+    if (this.denominator < 0) return false
+
+    const n = this.toNumber()
+
+    if (Number.isNaN(n) || n === 0) return false
+
+    return true
+  }
+
+  get uninitialized() {
+    // common initial value for AVRational(0, 1)
+    return this.numerator === 0 && this.denominator === 1
+  }
+
+  toNumber() {
+    return this.numerator / this.denominator
+  }
+
+  equals(other) {
+    return this.numerator === other.numerator && this.denominator === other.denominator
+  }
+
+  static from(num) {
+    const view = new Int32Array(binding.rationalD2Q(num))
+    return new FFmpegRational(view[0], view[1])
+  }
+
+  static rescaleQ(n, src, dst, round = AV_ROUND_NEAR_INF) {
+    if (src.equals(dst)) return n
+
+    return binding.rationalRescaleQ(
+      n,
+      src.numerator,
+      src.denominator,
+      dst.numerator,
+      dst.denominator,
+      round
+    )
+  }
 }

package/lib/resampler.js

@@ -1,6 +1,7 @@
 const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
 
-class Resampler {
+class FFmpegResampler {
   constructor(
     inputSampleRate,
     inputChannelLayout,
@@ -9,29 +10,36 @@ class Resampler {
     outputChannelLayout,
     outputFormat
   ) {
+    inputChannelLayout = ChannelLayout.from(inputChannelLayout)
+    outputChannelLayout = ChannelLayout.from(outputChannelLayout)
+
+    this._inputSampleRate = inputSampleRate
+    this._outputSampleRate = outputSampleRate
+
     this._handle = binding.initResampler(
       inputSampleRate,
       inputFormat,
-      inputChannelLayout,
+      inputChannelLayout._handle,
       outputSampleRate,
       outputFormat,
-      outputChannelLayout
+      outputChannelLayout._handle
     )
+  }
 
-    this.inputSampleRate = inputSampleRate
-    this.outputSampleRate = outputSampleRate
+  get inputSampleRate() {
+    return this._inputSampleRate
   }
 
-  convert(inputFrame, outputFrame) {
-    return binding.convertResampler(
-      this._handle,
-      inputFrame._handle,
-      outputFrame._handle
-    )
+  get outputSampleRate() {
+    return this._outputSampleRate
   }
 
   get delay() {
-    return binding.getResamplerDelay(this._handle, this.inputSampleRate)
+    return binding.getResamplerDelay(this._handle, this._inputSampleRate)
+  }
+
+  convert(inputFrame, outputFrame) {
+    return binding.convertResampler(this._handle, inputFrame._handle, outputFrame._handle)
   }
 
   flush(outputFrame) {
@@ -39,10 +47,8 @@ class Resampler {
   }
 
   destroy() {
-    if (this._handle) {
-      binding.destroyResampler(this._handle)
-      this._handle = null
-    }
+    binding.destroyResampler(this._handle)
+    this._handle = null
   }
 
   [Symbol.dispose]() {
@@ -50,4 +56,4 @@ class Resampler {
   }
 }
 
-module.exports = Resampler
+module.exports = FFmpegResampler

package/lib/samples.js

@@ -0,0 +1,85 @@
+const binding = require('../binding')
+
+module.exports = class FFmpegSamples {
+  _data
+  _frame
+
+  constructor({ noAlignment = false } = {}) {
+    this._noAlignment = noAlignment
+  }
+
+  get data() {
+    return this._data
+  }
+
+  get format() {
+    return this._frame.format
+  }
+
+  get channelLayout() {
+    return this._frame.channelLayout
+  }
+
+  get nbSamples() {
+    return this._frame.nbSamples
+  }
+
+  get nbChannels() {
+    return this.channelLayout && this.channelLayout.nbChannels
+  }
+
+  get pts() {
+    return this._frame.pts
+  }
+
+  fill(frame) {
+    const { format, channelLayout, nbSamples } = frame
+
+    const len = FFmpegSamples.bufferSize(
+      format,
+      channelLayout.nbChannels,
+      nbSamples,
+      this._noAlignment
+    )
+
+    if (!this._data || len !== this._data.length) {
+      this._data = Buffer.allocUnsafe(len)
+    }
+
+    const res = binding.fillSamples(
+      frame._handle,
+      this._data.buffer,
+      this._data.byteOffset,
+      this._noAlignment
+    )
+
+    this._frame = frame
+
+    return res
+  }
+
+  read(frame) {
+    const { format, channelLayout, nbSamples } = frame
+
+    const len = FFmpegSamples.bufferSize(
+      format,
+      channelLayout.nbChannels,
+      nbSamples,
+      this._noAlignment
+    )
+
+    if (!this._data || len !== this._data.length) {
+      this._data = Buffer.allocUnsafe(len)
+    }
+
+    binding.readSamples(frame._handle, this._data.buffer, this._data.byteOffset, this._noAlignment)
+  }
+
+  copy(frame, dstOffset = 0, srcOffset = 0) {
+    binding.copySamples(frame._handle, this._frame._handle, dstOffset, srcOffset, this.nbSamples)
+  }
+
+  static bufferSize(format, nbChannels, nbSamples, noAlignment = false) {
+    return binding.samplesBufferSize(format, nbChannels, nbSamples, noAlignment)
+  }
+}

package/lib/scaler.js

@@ -39,19 +39,13 @@ module.exports = class FFmpegScaler {
     if (typeof y !== 'number') {
       target = y
       y = 0
-      height = this._targetHeight
+      height = source.height
     } else if (typeof height !== 'number') {
       target = height
-      height = this._targetHeight
+      height = source.height
     }
 
-    return binding.scaleScaler(
-      this._handle,
-      source._handle,
-      y,
-      height,
-      target._handle
-    )
+    return binding.scaleScaler(this._handle, source._handle, y, height, target._handle)
   }
 
   [Symbol.dispose]() {

package/lib/stream.js

@@ -2,44 +2,81 @@ const binding = require('../binding')
 const Codec = require('./codec')
 const CodecContext = require('./codec-context')
 const CodecParameters = require('./codec-parameters')
+const Rational = require('./rational')
 
 module.exports = class FFmpegStream {
   constructor(handle) {
     this._handle = handle
 
-    this._codec = Codec.for(binding.getStreamCodec(this._handle))
+    this._codecParameters = new CodecParameters(binding.getStreamCodecParameters(this._handle))
+  }
+
+  get id() {
+    return binding.getStreamId(this._handle)
+  }
 
-    this._codecParameters = new CodecParameters(
-      binding.getStreamCodecParameters(this._handle)
-    )
+  set id(value) {
+    binding.setStreamId(this._handle, value)
   }
 
-  destroy() {
-    this._codecParameters.destroy()
-    this._codecParameters = null
+  get index() {
+    return binding.getStreamIndex(this._handle)
   }
 
   get codec() {
-    return this._codec
+    return Codec.for(this.codecParameters.id)
   }
 
   get codecParameters() {
     return this._codecParameters
   }
 
+  get timeBase() {
+    const view = new Int32Array(binding.getStreamTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    binding.setStreamTimeBase(this._handle, value.numerator, value.denominator)
+  }
+
+  get avgFramerate() {
+    const view = new Int32Array(binding.getStreamAverageFramerate(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set avgFramerate(value) {
+    binding.setStreamAverageFramerate(this._handle, value.numerator, value.denominator)
+  }
+
+  get duration() {
+    return binding.getStreamDuration(this._handle)
+  }
+
+  set duration(value) {
+    binding.setStreamDuration(this._handle, value)
+  }
+
   decoder() {
-    const context = new CodecContext(this._codec.decoder)
+    const context = new CodecContext(this.codec.decoder)
     this._codecParameters.toContext(context)
-    return context.open()
+    return context
   }
 
   encoder() {
-    const context = new CodecContext(this._codec.encoder)
+    const context = new CodecContext(this.codec.encoder)
     this._codecParameters.toContext(context)
-    return context.open()
+    return context
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegStream },
+      id: this.id,
+      index: this.index,
+      timeBase: this.timeBase,
+      avgFramerate: this.avgFramerate,
+      codecParameters: this.codecParameters
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-8",
+  "version": "1.0.0",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",
@@ -8,15 +8,18 @@
   },
   "files": [
     "index.js",
-    "binding.c",
+    "binding.cc",
     "binding.js",
     "CMakeLists.txt",
     "lib",
-    "prebuilds"
+    "prebuilds",
+    "cmake"
   ],
   "addon": true,
   "scripts": {
-    "test": "prettier . --check && bare test.js"
+    "test": "prettier . --check && bare test.js",
+    "format": "prettier . --write && clang-format -i binding.cc",
+    "example": "bare ./examples/index.js"
   },
   "repository": {
     "type": "git",
@@ -29,11 +32,12 @@
   },
   "homepage": "https://github.com/holepunchto/bare-ffmpeg#readme",
   "devDependencies": {
+    "bare-assert": "^1.1.0",
     "brittle": "^3.4.0",
     "cmake-bare": "^1.1.2",
     "cmake-harden": "^1.0.2",
     "cmake-ports": "^1.5.0",
     "prettier": "^3.3.3",
-    "prettier-config-standard": "^7.0.0"
+    "prettier-config-holepunch": "^2.0.0"
   }
 }