bare-ffmpeg 1.0.0-3 → 1.0.0-31

package/lib/filter-graph.js

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

@@ -1,26 +1,22 @@
 const binding = require('../binding')
 const Stream = require('./stream.js')
-const ReferenceCounted = require('./reference-counted')
 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 extends ReferenceCounted {
+class FFmpegFormatContext {
   constructor(io) {
-    super()
-
-    this._io = io ? io._ref() : null
+    this._io = io
     this._streams = []
   }
 
-  _destroy() {
+  destroy() {
     if (this._io) {
-      this._io._unref()
+      this._io.destroy()
       this._io = null
     }
-
-    for (const stream of this._streams) stream.destroy()
-    this._streams = []
   }
 
   get io() {
@@ -32,23 +28,24 @@ class FFmpegFormatContext extends ReferenceCounted {
   }
 
   readFrame(packet) {
-    if (packet._refs !== 0) {
-      throw new Error('Cannot read into packet with active references')
-    }
+    return binding.readFormatContextFrame(this._handle, packet._handle)
+  }
 
-    const result = binding.readFormatContextFrame(this._handle, packet._handle)
-    if (result) packet._ref()
-    return result
+  getBestStreamIndex(type) {
+    return binding.getFormatContextBestStreamIndex(this._handle, type)
   }
 
-  getBestStream(type) {
-    if (typeof type !== 'number') {
-      throw new TypeError(
-        `Type parameter should be of type number but got: ${typeof type}`
-      )
+  getStream(index) {
+    if (index < 0 || index >= this._streams.length) {
+      return null
     }
 
-    if (this._streams.length == 0) {
+    return this._streams[index]
+  }
+
+  /** @returns {Stream|null} */
+  getBestStream(type) {
+    if (this._streams.length === 0) {
       return null
     }
 
@@ -63,16 +60,23 @@ class FFmpegFormatContext extends ReferenceCounted {
 
     return this._streams[bestIndex]
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }
 
 let defaultURL = null
 
 switch (Bare.platform) {
   case 'darwin':
-    defaultURL = '0'
+  case 'ios':
+    defaultURL = '0:0'
     break
   case 'linux':
     // TODO: test on real machine
+    // we might need separate contexts for linux
+    // video: V4L2 and audio: ALSA/PulseAudio
     defaultURL = '/dev/video0'
     break
   case 'win32':
@@ -86,14 +90,20 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
   constructor(io, options, url = defaultURL) {
     if (io instanceof IOContext) {
       super(io)
+
       this._handle = binding.openInputFormatContextWithIO(io._handle)
     } else if (io instanceof InputFormat) {
       super()
+
+      options = options || new Dictionary()
+
       this._handle = binding.openInputFormatContextWithFormat(
         io._handle,
         options._handle,
         url
       )
+
+      options.destroy()
     }
 
     for (const handle of binding.getFormatContextStreams(this._handle)) {
@@ -101,12 +111,21 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
     }
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     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 (
@@ -118,22 +137,44 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     if (typeof format === 'string') format = new OutputFormat(format)
 
     this._handle = binding.openOutputFormatContext(format._handle, io._handle)
+    this._isOutput = true
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeOutputFormatContext(this._handle)
     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,59 +1,125 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
-module.exports = class FFmpegFrame extends ReferenceCounted {
+module.exports = class FFmpegFrame {
   constructor() {
-    super()
-
     this._handle = binding.initFrame()
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyFrame(this._handle)
     this._handle = null
   }
 
-  channel(i) {
-    if (i < 0 || i > 7) {
-      throw new RangeError(`Channel index must be between 0 and 7`)
-    }
+  unref() {
+    binding.unrefFrame(this._handle)
+  }
 
-    return Buffer.from(binding.getFrameChannel(this._handle, i))
+  get width() {
+    return binding.getFrameWidth(this._handle)
   }
 
   set width(value) {
     binding.setFrameWidth(this._handle, value)
   }
 
-  get width() {
-    return binding.getFrameWidth(this._handle)
+  get height() {
+    return binding.getFrameHeight(this._handle)
   }
 
   set height(value) {
     binding.setFrameHeight(this._handle, value)
   }
 
-  get height() {
-    return binding.getFrameHeight(this._handle)
+  get format() {
+    return binding.getFrameFormat(this._handle)
+  }
+
+  set format(value) {
+    binding.setFrameFormat(this._handle, value)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(binding.getFrameChannelLayout(this._handle))
+  }
+
+  set channelLayout(value) {
+    binding.setFrameChannelLayout(
+      this._handle,
+      ChannelLayout.from(value)._handle
+    )
+  }
+
+  get nbSamples() {
+    return binding.getFrameNbSamples(this._handle)
   }
 
-  set pixelFormat(value) {
-    binding.setFramePixelFormat(this._handle, value)
+  set nbSamples(value) {
+    binding.setFrameNbSamples(this._handle, value)
   }
 
-  get pixelFormat() {
-    return binding.getFramePixelFormat(this._handle)
+  get pictType() {
+    return binding.getFramePictType(this._handle)
   }
 
-  lineSize(channel) {
-    return binding.getFrameLineSize(this._handle, channel)
+  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)
+  }
+
+  copyProperties(source) {
+    binding.copyFrameProperties(this._handle, source._handle)
   }
 
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
 
-  get data() {
-    return Buffer.from(binding.getFrameData(this._handle))
+  [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/image.js

@@ -40,8 +40,30 @@ 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
+    )
+  }
+
+  lineSize(plane = 0) {
+    return binding.getImageLineSize(this._pixelFormat, this._width, plane)
+  }
+
+  static lineSize(pixelFormat, width, plane = 0) {
+    return binding.getImageLineSize(pixelFormat, width, plane)
+  }
 }

package/lib/input-format.js

@@ -3,7 +3,11 @@ const binding = require('../binding')
 let defaultName = null
 
 switch (Bare.platform) {
+  case 'android':
+    defaultName = 'android_camera'
+    break
   case 'darwin':
+  case 'ios':
     defaultName = 'avfoundation'
     break
   case 'linux':
@@ -15,10 +19,38 @@ switch (Bare.platform) {
 }
 
 module.exports = class FFmpegInputFormat {
-  constructor(name = defaultName) {
-    if (typeof name !== 'string' || name.length < 1) {
-      throw new TypeError('Input format name should be a non empty string')
+  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
     }
-    this._handle = binding.initInputFormat(name)
   }
 }

package/lib/io-context.js

@@ -1,15 +1,45 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegIOContext extends ReferenceCounted {
-  constructor(buffer = Buffer.alloc(0)) {
-    super()
+module.exports = class FFmpegIOContext {
+  constructor(buffer, opts = {}) {
+    let offset = 0
+    let len = 0
 
-    this._handle = binding.initIOContext(buffer)
+    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,
+      offset,
+      len,
+      opts.onwrite && onwriteWrapper.bind(null, opts.onwrite),
+      opts.onread && onreadWrapper.bind(null, opts.onread),
+      opts.onseek
+    )
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyIOContext(this._handle)
     this._handle = null
   }
+
+  [Symbol.dispose]() {
+    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
+    }
   }
 }