bare-ffmpeg 1.0.0-3 → 1.0.0-31

package/lib/packet.js

@@ -1,17 +1,45 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const Rational = require('./rational')
 
-module.exports = class FFmpegPacket extends ReferenceCounted {
-  constructor(buffer) {
-    super()
+class SideData {
+  constructor(handle, opts = {}) {
+    this._handle = handle
+    this._type = opts.type || null
+    this._data = opts.data || null
+  }
 
-    if (buffer) {
-      if (!Buffer.isBuffer(buffer)) {
-        throw TypeError(
-          `Buffer parameter should be of type Buffer but got: ${typeof buffer}`
-        )
-      }
+  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) {
+    if (buffer) {
       this._handle = binding.initPacketFromBuffer(
         buffer.buffer,
         buffer.byteOffset,
@@ -22,13 +50,12 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
     }
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyPacket(this._handle)
     this._handle = null
   }
 
   unref() {
-    this._unref()
     binding.unrefPacket(this._handle)
   }
 
@@ -36,7 +63,121 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
     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,54 @@
+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

@@ -0,0 +1,63 @@
+const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
+
+class FFmpegResampler {
+  constructor(
+    inputSampleRate,
+    inputChannelLayout,
+    inputFormat,
+    outputSampleRate,
+    outputChannelLayout,
+    outputFormat
+  ) {
+    inputChannelLayout = ChannelLayout.from(inputChannelLayout)
+    outputChannelLayout = ChannelLayout.from(outputChannelLayout)
+
+    this._inputSampleRate = inputSampleRate
+    this._outputSampleRate = outputSampleRate
+
+    this._handle = binding.initResampler(
+      inputSampleRate,
+      inputFormat,
+      inputChannelLayout._handle,
+      outputSampleRate,
+      outputFormat,
+      outputChannelLayout._handle
+    )
+  }
+
+  get inputSampleRate() {
+    return this._inputSampleRate
+  }
+
+  get outputSampleRate() {
+    return this._outputSampleRate
+  }
+
+  get delay() {
+    return binding.getResamplerDelay(this._handle, this._inputSampleRate)
+  }
+
+  convert(inputFrame, outputFrame) {
+    return binding.convertResampler(
+      this._handle,
+      inputFrame._handle,
+      outputFrame._handle
+    )
+  }
+
+  flush(outputFrame) {
+    return binding.flushResampler(this._handle, outputFrame._handle)
+  }
+
+  destroy() {
+    binding.destroyResampler(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}
+
+module.exports = FFmpegResampler

package/lib/samples.js

@@ -0,0 +1,96 @@
+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

@@ -1,8 +1,7 @@
 const binding = require('../binding')
 const constants = require('./constants')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegScaler extends ReferenceCounted {
+module.exports = class FFmpegScaler {
   constructor(
     sourcePixelFormat,
     sourceWidth,
@@ -11,8 +10,6 @@ module.exports = class FFmpegScaler extends ReferenceCounted {
     targetWidth,
     targetHeight
   ) {
-    super()
-
     sourcePixelFormat = constants.toPixelFormat(sourcePixelFormat)
     targetPixelFormat = constants.toPixelFormat(targetPixelFormat)
 
@@ -33,7 +30,7 @@ module.exports = class FFmpegScaler extends ReferenceCounted {
     )
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyScaler(this._handle)
     this._handle = null
   }
@@ -42,10 +39,10 @@ module.exports = class FFmpegScaler extends ReferenceCounted {
     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(
@@ -56,4 +53,8 @@ module.exports = class FFmpegScaler extends ReferenceCounted {
       target._handle
     )
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/stream.js

@@ -2,43 +2,87 @@ const binding = require('../binding')
 const Codec = require('./codec')
 const CodecContext = require('./codec-context')
 const CodecParameters = require('./codec-parameters')
-const ReferenceCounted = require('./reference-counted')
+const Rational = require('./rational')
 
-module.exports = class FFmpegStream extends ReferenceCounted {
+module.exports = class FFmpegStream {
   constructor(handle) {
-    super()
-
     this._handle = handle
 
-    this._codec = Codec.for(binding.getStreamCodec(this._handle))
-
     this._codecParameters = new CodecParameters(
       binding.getStreamCodecParameters(this._handle)
     )
   }
 
-  _destroy() {
-    this._codecParameters.destroy()
-    this._codecParameters = null
+  get id() {
+    return binding.getStreamId(this._handle)
+  }
+
+  set id(value) {
+    binding.setStreamId(this._handle, value)
+  }
+
+  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.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-3",
+  "version": "1.0.0-31",
   "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,8 +32,10 @@
   },
   "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"