bare-ffmpeg 1.0.0-8 → 1.0.0

package/lib/dictionary.js

@@ -1,6 +1,16 @@
 const binding = require('../binding')
 
 module.exports = class FFmpegDictionary {
+  static from(obj) {
+    const dictionary = new FFmpegDictionary()
+
+    for (const [key, value] of Object.entries(obj)) {
+      dictionary.set(key, value)
+    }
+
+    return dictionary
+  }
+
   constructor() {
     this._handle = binding.initDictionary()
   }
@@ -17,9 +27,19 @@ module.exports = class FFmpegDictionary {
   }
 
   set(key, value) {
+    if (typeof value !== 'string') value = String(value)
+
     binding.setDictionaryEntry(this._handle, key, value)
   }
 
+  entries() {
+    return binding.getDictionaryEntries(this._handle)
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.entries()
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }

package/lib/errors.js

@@ -0,0 +1,26 @@
+module.exports = class FFmpegError extends Error {
+  constructor(msg, code, fn = FFmpegError) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name() {
+    return 'FFmpegError'
+  }
+
+  static UNKNOWN_PIXEL_FORMAT(msg) {
+    return new FFmpegError(msg, 'UNKNOWN_PIXEL_FORMAT', FFmpegError.UNKNOWN_PIXEL_FORMAT)
+  }
+
+  static UNKNOWN_SAMPLE_FORMAT(msg) {
+    return new FFmpegError(msg, 'UNKNOWN_SAMPLE_FORMAT', FFmpegError.UNKNOWN_SAMPLE_FORMAT)
+  }
+
+  static UNKNOWN_CHANNEL_LAYOUT(msg) {
+    return new FFmpegError(msg, 'UNKNOWN_CHANNEL_LAYOUT', FFmpegError.UNKNOWN_CHANNEL_LAYOUT)
+  }
+}

package/lib/filter-context.js

@@ -0,0 +1,7 @@
+const binding = require('../binding')
+
+module.exports = class FilterContext {
+  constructor() {
+    this._handle = binding.initFilterContext()
+  }
+}

package/lib/filter-graph.js

@@ -0,0 +1,42 @@
+const binding = require('../binding')
+
+module.exports = class FilterGraph {
+  constructor() {
+    this._handle = binding.initFilterGraph()
+  }
+
+  destroy() {
+    binding.destroyFilterGraph(this._handle)
+    this._handle = null
+  }
+
+  createFilter(context, filter, name, args) {
+    return binding.createFilterGraphFilter(
+      this._handle,
+      context._handle,
+      filter._handle,
+      name,
+      args ?? undefined
+    )
+  }
+
+  parse(filterDescription, inputs, outputs) {
+    binding.parseFilterGraph(this._handle, inputs._handle, outputs._handle, filterDescription)
+  }
+
+  configure() {
+    binding.configureFilterGraph(this._handle)
+  }
+
+  pushFrame(ctx, frame) {
+    return binding.pushFilterGraphFrame(ctx._handle, frame._handle)
+  }
+
+  pullFrame(ctx, frame) {
+    return binding.pullFilterGraphFrame(ctx._handle, frame._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/filter-inout.js

@@ -0,0 +1,52 @@
+const binding = require('../binding')
+
+module.exports = class FilterInOut {
+  constructor(handle = binding.initFilterInout()) {
+    this._handle = handle
+    this._next = null
+    this._filterContext = null
+  }
+
+  destroy() {
+    binding.destroyFilterInOut(this._handle)
+    this._handle = null
+  }
+
+  get name() {
+    return binding.getFilterInOutName(this._handle)
+  }
+
+  set name(value) {
+    return binding.setFilterInOutName(this._handle, value)
+  }
+
+  get filterContext() {
+    return this._filterContext
+  }
+
+  set filterContext(value) {
+    this._filterContext = value
+    return binding.setFilterInOutFilterContext(this._handle, this._filterContext._handle)
+  }
+
+  get padIdx() {
+    return binding.getFilterInOutPadIdx(this._handle)
+  }
+
+  set padIdx(value) {
+    return binding.setFilterInOutPadIdx(this._handle, value)
+  }
+
+  get next() {
+    return this._next
+  }
+
+  set next(value) {
+    this._next = value
+    return binding.setFilterInOutNext(this._handle, this._next._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/filter.js

@@ -0,0 +1,7 @@
+const binding = require('../binding')
+
+module.exports = class Filter {
+  constructor(name) {
+    this._handle = binding.getFilterByName(name)
+  }
+}

package/lib/format-context.js

@@ -4,6 +4,7 @@ const OutputFormat = require('./output-format')
 const IOContext = require('./io-context')
 const InputFormat = require('./input-format')
 const Dictionary = require('./dictionary')
+/** @typedef {import('./packet')} Packet */
 
 class FFmpegFormatContext {
   constructor(io) {
@@ -16,9 +17,6 @@ class FFmpegFormatContext {
       this._io.destroy()
       this._io = null
     }
-
-    for (const stream of this._streams) stream.destroy()
-    this._streams = []
   }
 
   get io() {
@@ -45,15 +43,13 @@ class FFmpegFormatContext {
     return this._streams[index]
   }
 
+  /** @returns {Stream|null} */
   getBestStream(type) {
-    if (this._streams.length == 0) {
+    if (this._streams.length === 0) {
       return null
     }
 
-    const bestIndex = binding.getFormatContextBestStreamIndex(
-      this._handle,
-      type
-    )
+    const bestIndex = binding.getFormatContextBestStreamIndex(this._handle, type)
 
     if (bestIndex < 0 || bestIndex >= this._streams.length) {
       return null
@@ -71,6 +67,7 @@ let defaultURL = null
 
 switch (Bare.platform) {
   case 'darwin':
+  case 'ios':
     defaultURL = '0:0'
     break
   case 'linux':
@@ -84,9 +81,7 @@ switch (Bare.platform) {
     break
 }
 
-exports.InputFormatContext = class FFmpegInputFormatContext extends (
-  FFmpegFormatContext
-) {
+exports.InputFormatContext = class FFmpegInputFormatContext extends FFmpegFormatContext {
   constructor(io, options, url = defaultURL) {
     if (io instanceof IOContext) {
       super(io)
@@ -97,11 +92,7 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
 
       options = options || new Dictionary()
 
-      this._handle = binding.openInputFormatContextWithFormat(
-        io._handle,
-        options._handle,
-        url
-      )
+      this._handle = binding.openInputFormatContextWithFormat(io._handle, options._handle, url)
 
       options.destroy()
     }
@@ -117,17 +108,25 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
     binding.closeInputFormatContext(this._handle)
     this._handle = null
   }
+
+  dump(printIdx = 0, printUrl = '') {
+    binding.dumpFormatContext(this._handle, false, printIdx, printUrl)
+  }
+
+  get inputFormat() {
+    const handle = binding.getFormatContextInputFormat(this._handle)
+    if (handle) return InputFormat.from(handle)
+  }
 }
 
-exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
-  FFmpegFormatContext
-) {
+exports.OutputFormatContext = class FFmpegOutputFormatContext extends FFmpegFormatContext {
   constructor(format, io) {
     super(io)
 
     if (typeof format === 'string') format = new OutputFormat(format)
 
     this._handle = binding.openOutputFormatContext(format._handle, io._handle)
+    this._isOutput = true
   }
 
   destroy() {
@@ -137,13 +136,34 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     this._handle = null
   }
 
-  createStream(codec) {
-    const stream = new Stream(
-      binding.createFormatContextStream(this._handle, codec._handle)
-    )
+  createStream() {
+    const stream = new Stream(binding.createFormatContextStream(this._handle))
 
     this._streams.push(stream)
 
     return stream
   }
+
+  /** @param {Dictionary} [options] format options */
+  writeHeader(options) {
+    binding.writeFormatContextHeader(this._handle, options?._handle)
+  }
+
+  /** @param {Packet} packet */
+  writeFrame(packet) {
+    binding.writeFormatContextFrame(this._handle, packet._handle)
+  }
+
+  writeTrailer() {
+    binding.writeFormatContextTrailer(this._handle)
+  }
+
+  dump(printIdx = 0, printUrl = '') {
+    binding.dumpFormatContext(this._handle, true, printIdx, printUrl)
+  }
+
+  get outputFormat() {
+    const handle = binding.getFormatContextOutputFormat(this._handle)
+    if (handle) return OutputFormat.from(handle)
+  }
 }

package/lib/frame.js

@@ -1,4 +1,8 @@
 const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
+const HWFramesContext = require('./hw-frames-context')
+const Rational = require('./rational')
+const constants = require('./constants')
 
 module.exports = class FFmpegFrame {
   constructor() {
@@ -10,6 +14,10 @@ module.exports = class FFmpegFrame {
     this._handle = null
   }
 
+  unref() {
+    binding.unrefFrame(this._handle)
+  }
+
   get width() {
     return binding.getFrameWidth(this._handle)
   }
@@ -26,14 +34,6 @@ module.exports = class FFmpegFrame {
     binding.setFrameHeight(this._handle, value)
   }
 
-  get pixelFormat() {
-    return binding.getFramePixelFormat(this._handle)
-  }
-
-  set pixelFormat(value) {
-    binding.setFramePixelFormat(this._handle, value)
-  }
-
   get format() {
     return binding.getFrameFormat(this._handle)
   }
@@ -43,11 +43,11 @@ module.exports = class FFmpegFrame {
   }
 
   get channelLayout() {
-    return binding.getFrameChannelLayout(this._handle)
+    return new ChannelLayout(binding.getFrameChannelLayout(this._handle))
   }
 
   set channelLayout(value) {
-    binding.setFrameChannelLayout(this._handle, value)
+    binding.setFrameChannelLayout(this._handle, ChannelLayout.from(value)._handle)
   }
 
   get nbSamples() {
@@ -58,8 +58,62 @@ module.exports = class FFmpegFrame {
     binding.setFrameNbSamples(this._handle, value)
   }
 
-  audioChannel() {
-    return binding.getFrameAudioChannel(this._handle)
+  get pictType() {
+    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)
+  }
+
+  get sampleRate() {
+    return binding.getFrameSampleRate(this._handle)
+  }
+
+  set sampleRate(value) {
+    binding.setFrameSampleRate(this._handle, value)
+  }
+
+  get hwFramesCtx() {
+    const handle = binding.getFrameHWFramesCtx(this._handle)
+    return handle ? HWFramesContext.from(handle) : null
+  }
+
+  set hwFramesCtx(hwFramesContext) {
+    binding.setFrameHWFramesCtx(this._handle, hwFramesContext._handle)
+  }
+
+  copyProperties(source) {
+    binding.copyFrameProperties(this._handle, source._handle)
+  }
+
+  transferData(destination) {
+    binding.transferFrameData(destination._handle, this._handle)
+  }
+
+  hwMap(destination, flags = constants.hwFrameMapFlags.NONE) {
+    binding.mapFrame(destination._handle, this._handle, flags)
   }
 
   alloc() {
@@ -69,4 +123,19 @@ module.exports = class FFmpegFrame {
   [Symbol.dispose]() {
     this.destroy()
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegFrame },
+      width: this.width,
+      height: this.height,
+      format: this.format,
+      channelLayout: this.channelLayout,
+      nbSamples: this.nbSamples,
+      pictType: this.pictType,
+      pts: this.pts,
+      packetDTS: this.packetDTS,
+      timeBase: this.timeBase
+    }
+  }
 }

package/lib/hw-device-context.js

@@ -0,0 +1,31 @@
+const binding = require('../binding')
+
+module.exports = class HWDeviceContext {
+  constructor(type, device = undefined, handle = undefined) {
+    if (handle) {
+      this._handle = handle
+    } else {
+      this._handle = binding.initHWDeviceContext(type, device)
+    }
+  }
+
+  static from(handle) {
+    if (handle == null) return null
+    return new HWDeviceContext(null, undefined, handle)
+  }
+
+  destroy() {
+    binding.destroyHWDeviceContext(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: HWDeviceContext }
+    }
+  }
+}

package/lib/hw-frames-constraints.js

@@ -0,0 +1,54 @@
+const binding = require('../binding')
+
+module.exports = class HWFramesConstraints {
+  constructor(handle) {
+    this._handle = handle
+  }
+
+  get validSwFormats() {
+    return binding.getHWFramesConstraintsValidSwFormats(this._handle)
+  }
+
+  get validHwFormats() {
+    return binding.getHWFramesConstraintsValidHwFormats(this._handle)
+  }
+
+  get minWidth() {
+    return binding.getHWFramesConstraintsMinWidth(this._handle)
+  }
+
+  get maxWidth() {
+    return binding.getHWFramesConstraintsMaxWidth(this._handle)
+  }
+
+  get minHeight() {
+    return binding.getHWFramesConstraintsMinHeight(this._handle)
+  }
+
+  get maxHeight() {
+    return binding.getHWFramesConstraintsMaxHeight(this._handle)
+  }
+
+  // Note: HWFramesConstraints is independently allocated by FFmpeg and must be
+  // explicitly freed. It is not owned by HWFramesContext.
+  destroy() {
+    binding.destroyHWFramesConstraints(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: HWFramesConstraints },
+      validSwFormats: this.validSwFormats,
+      validHwFormats: this.validHwFormats,
+      minWidth: this.minWidth,
+      maxWidth: this.maxWidth,
+      minHeight: this.minHeight,
+      maxHeight: this.maxHeight
+    }
+  }
+}

package/lib/hw-frames-context.js

@@ -0,0 +1,92 @@
+const binding = require('../binding')
+const HWFramesConstraints = require('./hw-frames-constraints')
+
+module.exports = class HWFramesContext {
+  constructor(hwDeviceContext, format, swFormat, width, height, handle = undefined) {
+    if (handle) {
+      this._handle = handle
+      return
+    }
+
+    this._handle = binding.initHWFramesContext(
+      hwDeviceContext._handle,
+      format,
+      swFormat,
+      width,
+      height
+    )
+  }
+
+  static from(handle) {
+    if (handle == null) return null
+    return new HWFramesContext(null, null, null, null, null, handle)
+  }
+
+  get format() {
+    return binding.getHWFramesContextFormat(this._handle)
+  }
+
+  set format(value) {
+    binding.setHWFramesContextFormat(this._handle, value)
+  }
+
+  get swFormat() {
+    return binding.getHWFramesContextSWFormat(this._handle)
+  }
+
+  set swFormat(value) {
+    binding.setHWFramesContextSWFormat(this._handle, value)
+  }
+
+  get width() {
+    return binding.getHWFramesContextWidth(this._handle)
+  }
+
+  set width(value) {
+    binding.setHWFramesContextWidth(this._handle, value)
+  }
+
+  get height() {
+    return binding.getHWFramesContextHeight(this._handle)
+  }
+
+  set height(value) {
+    binding.setHWFramesContextHeight(this._handle, value)
+  }
+
+  get initialPoolSize() {
+    return binding.getHWFramesContextInitialPoolSize(this._handle)
+  }
+
+  set initialPoolSize(value) {
+    binding.setHWFramesContextInitialPoolSize(this._handle, value)
+  }
+
+  getBuffer(frame) {
+    binding.getHWFramesContextBuffer(this._handle, frame._handle)
+  }
+
+  getConstraints() {
+    const handle = binding.getHWFramesContextConstraints(this._handle)
+    return new HWFramesConstraints(handle)
+  }
+
+  destroy() {
+    binding.destroyHWFramesContext(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: HWFramesContext },
+      format: this.format,
+      swFormat: this.swFormat,
+      width: this.width,
+      height: this.height
+    }
+  }
+}

package/lib/image.js

@@ -10,9 +10,7 @@ module.exports = class FFmpegImage {
     this._height = height
     this._align = align
 
-    this._data = Buffer.from(
-      binding.initImage(pixelFormat, width, height, align)
-    )
+    this._data = Buffer.from(binding.initImage(pixelFormat, width, height, align))
   }
 
   get pixelFormat() {
@@ -40,6 +38,19 @@ module.exports = class FFmpegImage {
       this._pixelFormat,
       this._width,
       this._height,
+      this._align,
+      this._data.buffer,
+      this._data.byteOffset,
+      frame._handle
+    )
+  }
+
+  read(frame) {
+    binding.readImage(
+      this._pixelFormat,
+      this._width,
+      this._height,
+      this._align,
       this._data.buffer,
       this._data.byteOffset,
       frame._handle

package/lib/input-format.js

@@ -3,6 +3,9 @@ const binding = require('../binding')
 let defaultName = null
 
 switch (Bare.platform) {
+  case 'android':
+    defaultName = 'android_camera'
+    break
   case 'darwin':
   case 'ios':
     defaultName = 'avfoundation'
@@ -16,7 +19,38 @@ switch (Bare.platform) {
 }
 
 module.exports = class FFmpegInputFormat {
-  constructor(name = defaultName) {
-    this._handle = binding.initInputFormat(name)
+  constructor(name = defaultName, handle) {
+    if (handle) this._handle = handle
+    else this._handle = binding.initInputFormat(name)
+  }
+
+  static from(handle) {
+    return new FFmpegInputFormat(null, handle)
+  }
+
+  get flags() {
+    return binding.getInputFormatFlags(this._handle)
+  }
+
+  get extensions() {
+    return binding.getInputFormatExtensions(this._handle)
+  }
+
+  get mimeType() {
+    return binding.getInputFormatMimeType(this._handle)
+  }
+
+  get name() {
+    return binding.getInputFormatName(this._handle)
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegInputFormat },
+      name: this.name,
+      flags: this.flags,
+      extensions: this.extensions,
+      mimeType: this.mimeType
+    }
   }
 }