bare-ffmpeg 1.0.0-15 → 1.0.0-16

package/lib/frame.d.ts

@@ -0,0 +1,23 @@
+import FFmpegChannelLayout from './channel-layout'
+
+declare class FFmpegFrame {
+  readonly pictType: number
+
+  get channelLayout(): FFmpegChannelLayout
+  set channelLayout(value: FFmpegChannelLayout | string | number)
+
+  width: number
+  height: number
+  pixelFormat: number
+  format: number
+  nbSamples: number
+
+  constructor()
+
+  alloc(): void
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegFrame

package/lib/frame.js

@@ -1,5 +1,6 @@
 const binding = require('../binding')
 const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
 module.exports = class FFmpegFrame {
   constructor() {
@@ -66,6 +67,31 @@ module.exports = class FFmpegFrame {
     return binding.getFramePictType(this._handle)
   }
 
+  get pts() {
+    return binding.getFramePTS(this._handle)
+  }
+
+  set pts(value) {
+    return binding.setFramePTS(this._handle, value)
+  }
+
+  get packetDTS() {
+    return binding.getFramePacketDTS(this._handle)
+  }
+
+  set packetDTS(value) {
+    return binding.setFramePacketDTS(this._handle, value)
+  }
+
+  get timeBase() {
+    const view = new Int32Array(binding.getFrameTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    binding.setFrameTimeBase(this._handle, value.numerator, value.denominator)
+  }
+
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
@@ -73,4 +99,20 @@ module.exports = class FFmpegFrame {
   [Symbol.dispose]() {
     this.destroy()
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegFrame },
+      width: this.width,
+      height: this.height,
+      pixelFormat: this.pixelFormat,
+      format: this.format,
+      channelLayout: this.channelLayout,
+      nbSamples: this.nbSamples,
+      pictType: this.pictType,
+      pts: this.pts,
+      packetDTS: this.packetDTS,
+      timeBase: this.timeBase
+    }
+  }
 }

package/lib/image.d.ts

@@ -0,0 +1,30 @@
+import Buffer from 'bare-buffer'
+import FFmpegFrame from './frame'
+
+declare class FFmpegImage {
+  readonly pixelFormat: number
+  readonly width: number
+  readonly height: number
+  readonly align: number
+  readonly data: Buffer
+
+  constructor(
+    pixelFormat: string | number,
+    width: number,
+    height: number,
+    align?: number
+  )
+
+  fill(frame: FFmpegFrame): void
+  read(frame: FFmpegFrame): void
+
+  lineSize(plane?: number): number
+
+  static lineSize(
+    pixelFormat: string | number,
+    width: number,
+    plane?: number
+  ): number
+}
+
+export = FFmpegImage

package/lib/input-format.d.ts

@@ -0,0 +1,5 @@
+declare class FFmpegInputFormat {
+  constructor(name?: string)
+}
+
+export = FFmpegInputFormat

package/lib/input-format.js

@@ -22,4 +22,8 @@ module.exports = class FFmpegInputFormat {
   constructor(name = defaultName) {
     this._handle = binding.initInputFormat(name)
   }
+
+  get flags() {
+    return binding.getInputFormatFlags(this._handle)
+  }
 }

package/lib/io-context.d.ts

@@ -0,0 +1,10 @@
+import Buffer from 'bare-buffer'
+
+declare class FFmpegIOContext {
+  constructor(buffer?: Buffer)
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegIOContext

package/lib/io-context.js

@@ -1,12 +1,30 @@
 const binding = require('../binding')
 
 module.exports = class FFmpegIOContext {
-  constructor(buffer = Buffer.alloc(0)) {
-    this._handle = binding.initIOContext(
-      buffer.buffer,
-      buffer.byteOffset,
-      buffer.byteLength
-    )
+  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)
+    }
+
+    let onwrite
+
+    if (typeof opts.onwrite === 'function') {
+      onwrite = function (chunk) {
+        opts.onwrite(Buffer.from(chunk))
+      }
+    }
+
+    this._handle = binding.initIOContext(buffer, offset, len, onwrite)
   }
 
   destroy() {

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.d.ts

@@ -0,0 +1,5 @@
+declare class FFmpegOutputFormat {
+  constructor(name: string)
+}
+
+export = FFmpegOutputFormat

package/lib/output-format.js

@@ -4,4 +4,8 @@ module.exports = class FFmpegOutputFormat {
   constructor(name) {
     this._handle = binding.initOutputFormat(name)
   }
+
+  get flags() {
+    return binding.getOutputFormatFlags(this._handle)
+  }
 }

package/lib/packet.d.ts

@@ -0,0 +1,16 @@
+import Buffer from 'bare-buffer'
+
+declare class FFmpegPacket {
+  readonly streamIndex: number
+  readonly data: Buffer
+  readonly isKeyframe: boolean
+
+  constructor(buffer?: Buffer)
+
+  unref(): void
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegPacket

package/lib/packet.js

@@ -1,4 +1,5 @@
 const binding = require('../binding')
+const Rational = require('./rational')
 
 module.exports = class FFmpegPacket {
   constructor(buffer) {
@@ -26,14 +27,90 @@ 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 isKeyframe() {
     return binding.isPacketKeyframe(this._handle)
   }
 
+  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(rational) {
+    return binding.rescalePacketTimestamps(
+      this._handle,
+      rational.numerator,
+      rational.denominator
+    )
+  }
+
+  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
+    }
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }

package/lib/rational.d.ts

@@ -0,0 +1,8 @@
+declare class FFmpegRational {
+  numerator: number
+  denominator: number
+
+  constructor(numerator: number, denominator: number)
+}
+
+export = FFmpegRational

package/lib/rational.js

@@ -1,6 +1,32 @@
+const binding = require('../binding')
+
 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 unless
+    // required by codec or format
+    if (this.denominator < 1) return false
+
+    // common initial value for AVRational(0, 1)
+    if (this.q2d === 0) return false
+
+    return true
+  }
+
+  get uninitialized() {
+    return this.numerator === 0 && this.denominator === 1
+  }
+
+  get q2d() {
+    return this.numerator / this.denominator
+  }
+
+  static from(num) {
+    const view = new Int32Array(binding.rationalD2Q(num))
+    return new FFmpegRational(view[0], view[1])
+  }
 }

package/lib/resampler.d.ts

@@ -0,0 +1,26 @@
+import FFmpegChannelLayout from './channel-layout'
+import FFmpegFrame from './frame'
+
+declare class FFmpegResampler {
+  readonly inputSampleRate: number
+  readonly outputSampleRate: number
+  readonly delay: number
+
+  constructor(
+    inputSampleRate: number,
+    inputChannelLayout: FFmpegChannelLayout | string | number,
+    inputFormat: number,
+    outputSampleRate: number,
+    outputChannelLayout: FFmpegChannelLayout | string | number,
+    outputFormat: number
+  )
+
+  convert(inputFrame: FFmpegFrame, outputFrame: FFmpegFrame): number
+
+  flush(outputFrame: FFmpegFrame): number
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegResampler

package/lib/resampler.js

@@ -1,7 +1,7 @@
 const binding = require('../binding')
 const ChannelLayout = require('./channel-layout')
 
-class Resampler {
+class FFmpegResampler {
   constructor(
     inputSampleRate,
     inputChannelLayout,
@@ -60,4 +60,4 @@ class Resampler {
   }
 }
 
-module.exports = Resampler
+module.exports = FFmpegResampler

package/lib/samples.d.ts

@@ -0,0 +1,16 @@
+import Buffer from 'bare-buffer'
+import FFmpegFrame from './frame'
+
+declare class FFmpegSamples {
+  readonly sampleFormat: string | number
+  readonly nbChannels: number
+  readonly nbSamples: number
+  readonly align: number
+  readonly data: Buffer
+
+  constructor(sampleFormat: string | number, nbSamples: number, align?: number)
+
+  fill(frame: FFmpegFrame): void
+}
+
+export = FFmpegSamples

package/lib/scaler.d.ts

@@ -0,0 +1,26 @@
+import FFmpegFrame from './frame'
+
+declare class FFmpegScaler {
+  constructor(
+    sourcePixelFormat: string | number,
+    sourceWidth: number,
+    sourceHeight: number,
+    targetPixelFormat: string | number,
+    targetWidth: number,
+    targetHeight: number
+  )
+
+  scale(
+    source: FFmpegFrame,
+    y: number,
+    height: number,
+    target: FFmpegFrame
+  ): boolean
+  scale(source: FFmpegFrame, y: number, target: FFmpegFrame): boolean
+  scale(source: FFmpegFrame, target: FFmpegFrame): boolean
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegScaler

package/lib/scaler.js

@@ -39,10 +39,10 @@ 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(

package/lib/stream.d.ts

@@ -0,0 +1,18 @@
+import FFmpegCodec from './codec'
+import FFmpegCodecContext from './codec-context'
+import FFmpegCodecParameters from './codec-parameters'
+
+declare class FFmpegStream {
+  readonly codec: FFmpegCodec
+  readonly codecParameters: FFmpegCodecParameters
+
+  constructor(handle: ArrayBuffer)
+
+  decoder(): FFmpegCodecContext
+  encoder(): FFmpegCodecContext
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegStream

package/lib/stream.js

@@ -2,34 +2,67 @@ 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)
+  }
+
+  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.codecId)
   }
 
   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
+    )
+  }
+
   decoder() {
-    const context = new CodecContext(this._codec.decoder)
+    const context = new CodecContext(this.codec.decoder)
     this._codecParameters.toContext(context)
     return context.open()
   }
 
   encoder() {
-    const context = new CodecContext(this._codec.encoder)
+    const context = new CodecContext(this.codec.encoder)
     this._codecParameters.toContext(context)
     return context.open()
   }

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-15",
+  "version": "1.0.0-16",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./package": "./package.json"
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "binding.cc",
     "binding.js",
     "CMakeLists.txt",
@@ -17,7 +21,8 @@
   ],
   "addon": true,
   "scripts": {
-    "test": "prettier . --check && bare test.js"
+    "test": "prettier . --check && bare test.js",
+    "format": "prettier . --write && clang-format -i binding.cc"
   },
   "repository": {
     "type": "git",
@@ -30,11 +35,20 @@
   },
   "homepage": "https://github.com/holepunchto/bare-ffmpeg#readme",
   "devDependencies": {
+    "bare-buffer": "^3.2.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"
+  },
+  "peerDependencies": {
+    "bare-buffer": "*"
+  },
+  "peerDependenciesMeta": {
+    "bare-buffer": {
+      "optional": true
+    }
   }
 }