bare-ffmpeg 1.0.0-7 → 1.0.0-9

package/CMakeLists.txt

@@ -6,9 +6,9 @@ find_package(cmake-ports REQUIRED PATHS node_modules/cmake-ports)
 
 project(bare_ffmpeg C CXX)
 
-fetch_package("github:holepunchto/libjstl#096669a")
+fetch_package("github:holepunchto/libjstl#5b85a24")
 
-find_port(ffmpeg FEATURES dav1d svt-av1 x264)
+find_port(ffmpeg FEATURES gpl dav1d svt-av1 x264 opus)
 
 add_bare_module(bare_ffmpeg)
 

package/README.md

@@ -6,6 +6,815 @@ Low-level FFmpeg bindings for Bare.
 npm i bare-ffmpeg
 ```
 
+## API
+
+### `IOContext`
+
+The `IOContext` API provides functionality to create input/output contexts for media files.
+
+```js
+const io = new ffmpeg.IOContext(buffer)
+```
+
+Parameters:
+
+- `buffer` (`Buffer`): The media data buffer
+
+**Returns**: A new `IOContext` instance
+
+Example:
+
+```js
+const image = require('./fixtures/image/sample.jpeg', {
+  with: { type: 'binary' }
+})
+const io = new ffmpeg.IOContext(image)
+io.destroy()
+```
+
+#### Methods
+
+##### `IOContext.destroy()`
+
+Destroys the `IOContext` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `FormatContext`
+
+The `FormatContext` API provides the base functionality for reading and writing media files.
+
+> This is the base class that `InputFormatContext` and `OutputFormatContext` extend.
+
+#### Properties
+
+##### `FormatContext.io`
+
+Gets the IO context associated with this format context.
+
+**Returns**: `IOContext` instance or `null`
+
+##### `FormatContext.streams`
+
+Gets the array of media streams.
+
+**Returns**: Array of `Stream` instances
+
+#### Methods
+
+##### `FormatContext.readFrame(packet)`
+
+Reads the next frame from the media file into a packet.
+
+Parameters:
+
+- `packet` (`Packet`): The packet to store the frame data
+
+**Returns**: `boolean` indicating if a frame was read
+
+##### `FormatContext.getBestStream(type)`
+
+Gets the best stream of the specified media type.
+
+Parameters:
+
+- `type` (`number`): The media type from `ffmpeg.constants.mediaTypes`
+
+**Returns**: `Stream` instance or `null` if not found
+
+##### `FormatContext.destroy()`
+
+Destroys the `FormatContext` and frees all associated resources including streams. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `InputFormatContext`
+
+The `InputFormatContext` API extends `FormatContext` to provide functionality for reading media files.
+
+```js
+const format = new ffmpeg.InputFormatContext(io, options[, url])
+```
+
+Parameters:
+
+- `io` (`IOContext` | `InputFormat`): The IO context or input format. The ownership of `io` is transferred.
+- `options` (`Dictionary`): Format options. Required when using `InputFormat`, ignored when using `IOContext`. The ownership of `options` is transferred.
+- `url` (`string`, optional): Media source URL. Defaults to a platform-specific value
+
+**Returns**: A new `InputFormatContext` instance
+
+#### Methods
+
+##### `InputFormatContext.destroy()`
+
+Destroys the `InputFormatContext` and closes the input format. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: void
+
+### `OutputFormatContext`
+
+The `OutputFormatContext` API extends `FormatContext` to provide functionality for writing media files.
+
+```js
+const format = new ffmpeg.OutputFormatContext(formatName, io)
+```
+
+Parameters:
+
+- `formatName` (`string`): The output format name (e.g., `'mp4'`, `'avi'`)
+- `io` (`IOContext`): The IO context for writing. The ownership of `io` is transferred.
+
+**Returns**: A new `OutputFormatContext` instance
+
+#### Methods
+
+##### `OutputFormatContext.createStream(codec)`
+
+Creates a new stream in the output format.
+
+Parameters:
+
+- `codec` (`Codec`): The codec to use for the stream
+
+**Returns**: A new `Stream` instance
+
+##### `OutputFormatContext.destroy()`
+
+Destroys the `OutputFormatContext` and closes the output format. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Codec`
+
+The `Codec` API provides access to FFmpeg codecs for encoding and decoding.
+
+#### Static properties
+
+##### `Codec.H264`
+
+H.264 video codec.
+
+**Returns**: `Codec` instance
+
+##### `Codec.MJPEG`
+
+Motion JPEG video codec.
+
+**Returns**: `Codec` instance
+
+##### `Codec.AAC`
+
+AAC audio codec.
+
+**Returns**: `Codec` instance
+
+##### `Codec.AV1`
+
+AV1 video codec.
+
+**Returns**: `Codec` instance
+
+#### Properties
+
+##### `Codec.id`
+
+Gets the codec ID.
+
+**Returns**: `number`
+
+##### `Codec.encoder`
+
+Gets the encoder for this codec.
+
+**Returns**: `Encoder` instance
+
+##### `Codec.decoder`
+
+Gets the decoder for this codec.
+
+**Returns**: `Decoder` instance
+
+#### Methods
+
+##### `Codec.for(id)`
+
+Gets a codec by ID.
+
+Parameters:
+
+- `id` (`number`): The codec ID
+
+**Returns**: `Codec` instance
+
+### `CodecContext`
+
+The `CodecContext` API provides functionality to encode or decode media frames.
+
+```js
+const codecCtx = new ffmpeg.CodecContext(codec)
+```
+
+Parameters:
+
+- `codec` (Codec): The codec to use (e.g., `ffmpeg.Codec.H264.encoder`)
+
+**Returns**: A new `CodecContext` instance
+
+#### Properties
+
+##### `CodecContext.timeBase`
+
+Gets or sets the time base for the codec context.
+
+**Returns**: `Rational` instance
+
+##### `CodecContext.pixelFormat`
+
+Gets or sets the pixel format for video codecs.
+
+**Returns**: `number` (pixel format constant)
+
+##### `CodecContext.width`
+
+Gets or sets the frame width for video codecs.
+
+**Returns**: `number`
+
+##### `CodecContext.height`
+
+Gets or sets the frame height for video codecs.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `CodecContext.open([options])`
+
+Opens the codec context for encoding/decoding.
+
+Parameters:
+
+- `options` (`Dictionary`, optional): Codec-specific options
+
+**Returns**: `CodecContext` instance (for chaining)
+
+##### `CodecContext.sendFrame(frame)`
+
+Sends a frame to the encoder.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to encode
+
+**Returns**: `boolean` indicating if the frame was sent
+
+##### `CodecContext.receiveFrame(frame)`
+
+Receives a decoded frame from the decoder.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to store the decoded data
+
+**Returns**: `boolean` indicating if a frame was received
+
+##### `CodecContext.sendPacket(packet)`
+
+Sends a packet to the decoder.
+
+Parameters:
+
+- `packet` (`Packet`): The packet to decode
+
+**Returns**: `boolean` indicating if the packet was sent
+
+##### `CodecContext.receivePacket(packet)`
+
+Receives an encoded packet from the encoder.
+
+Parameters:
+
+- `packet` (`Packet`): The packet to store the encoded data
+
+**Returns**: `boolean` indicating if a packet was received
+
+##### `CodecContext.destroy()`
+
+Destroys the `CodecContext` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `CodecParameters`
+
+The `CodecParameters` API provides functionality to access codec parameters from streams.
+
+```js
+const params = stream.codecParameters // Get from stream
+```
+
+#### Properties
+
+##### `CodecParameters.bitRate`
+
+Gets the bit rate.
+
+**Returns**: `number`
+
+##### `CodecParameters.bitsPerCodedSample`
+
+Gets the bits per coded sample.
+
+**Returns**: `number`
+
+##### `CodecParameters.bitsPerRawSample`
+
+Gets the bits per raw sample.
+
+**Returns**: `number`
+
+##### `CodecParameters.sampleRate`
+
+Gets the sample rate for audio codecs.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `CodecParameters.fromContext(context)`
+
+Copies parameters from a codec context.
+
+Parameters:
+
+- `context` (`CodecContext`): The codec context
+
+**Returns**: `void`
+
+##### `CodecParameters.toContext(context)`
+
+Copies parameters to a codec context.
+
+Parameters:
+
+- `context` (`CodecContext`): The codec context
+
+**Returns**: `void`
+
+##### `CodecParameters.destroy()`
+
+Destroys the `CodecParameters` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `InputFormat`
+
+The `InputFormat` API provides functionality to specify input format for media sources.
+
+```js
+const format = new ffmpeg.InputFormat([name])
+```
+
+Parameters:
+
+- `name` (`string`, optional): The input format name. Defaults to a platform-specific value:
+  - `darwin`, `ios`: ``'avfoundation'`
+  - `linux`: `'v4l2'`
+  - `win32`: `'dshow'`
+
+**Returns**: A new `InputFormat` instance
+
+#### Methods
+
+##### `InputFormat.destroy()`
+
+Destroys the `InputFormat` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `OutputFormat`
+
+The `OutputFormat` API provides functionality to specify output format for media files.
+
+```js
+const format = new ffmpeg.OutputFormat(name)
+```
+
+Parameters:
+
+- `name` (`string`): The output format name (e.g., `'mp4'`, `'avi'`, `'mov'`)
+
+**Returns**: A new `OutputFormat` instance
+
+#### Methods
+
+##### `OutputFormat.destroy()`
+
+Destroys the `OutputFormat` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Frame`
+
+This structure describes decoded (raw) audio or video data.
+
+```js
+const frame = new ffmpeg.Frame()
+```
+
+**Returns**: A new `Frame` instance
+
+#### Properties
+
+##### `Frame.width`
+
+Gets or sets the frame width.
+
+**Returns**: `number`
+
+##### `Frame.height`
+
+Gets or sets the frame height.
+
+**Returns**: `number`
+
+##### `Frame.pixelFormat`
+
+Gets or sets the pixel format.
+
+**Returns**: `number` (pixel format constant)
+
+##### `Frame.format`
+
+Gets or sets the sample format for audio frames.
+
+**Returns**: `number` (sample format constant)
+
+##### `Frame.channelLayout`
+
+Gets or sets the channel layout for audio frames.
+
+**Returns**: `number` (channel layout constant)
+
+##### `Frame.nbSamples`
+
+Gets or sets the number of audio samples.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `Frame.alloc()`
+
+Allocates memory for the frame data.
+
+**Returns**: `void`
+
+##### `Frame.destroy()`
+
+Destroys the `Frame` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Packet`
+
+This structure stores compressed data. It is typically exported by demuxers and then passed as input to decoders, or received as output from encoders and then passed to muxers.
+
+```js
+const packet = new ffmpeg.Packet([buffer])
+```
+
+Parameters:
+
+- `buffer` (`Buffer`, optional): Initial packet data
+
+**Returns**: A new `Packet` instance
+
+#### Properties
+
+##### `Packet.data`
+
+Gets the packet data buffer.
+
+**Returns**: `Buffer`
+
+##### `Packet.streamIndex`
+
+Gets the stream index this packet belongs to.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `Packet.unref()`
+
+Decrements the reference count and unreferences the packet.
+
+**Returns**: `void`
+
+##### `Packet.destroy()`
+
+Destroys the `Packet` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Image`
+
+The `Image` API provides functionality to create and manage image buffers.
+
+```js
+const image = new ffmpeg.Image(pixelFormat, width, height[, align])
+```
+
+Parameters:
+
+- `pixelFormat` (`number` | `string`): The pixel format
+- `width` (`number`): The image width in pixels
+- `height` (`number`): The image height in pixels
+- `align` (`number`, optional): Memory alignment. Defaults to 1
+
+**Returns**: A new `Image` instance
+
+#### Properties
+
+##### `Image.pixelFormat`
+
+Gets the pixel format.
+
+**Returns**: `number`
+
+##### `Image.width`
+
+Gets the image width.
+
+**Returns**: `number`
+
+##### `Image.height`
+
+Gets the image height.
+
+**Returns**: `number`
+
+##### `Image.align`
+
+Gets the memory alignment.
+
+**Returns**: `number`
+
+##### `Image.data`
+
+Gets the image data buffer.
+
+**Returns**: `Buffer`
+
+#### Methods
+
+##### `Image.fill(frame)`
+
+Fills a frame with the image data.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to fill
+
+**Returns**: void
+
+##### `Image.lineSize([plane])`
+
+Gets the line size for a specific plane.
+
+Parameters:
+
+- `plane` (`number`, optional): Plane index. Defaults to 0
+
+**Returns**: `number`
+
+#### Static methods
+
+##### `Image.lineSize(pixelFormat, width[, plane])`
+
+Static method to get line size for a pixel format.
+
+Parameters:
+
+- `pixelFormat` (`number` | `string`): The pixel format
+- `width` (`number`): The image width
+- `plane` (`number`, optional): Plane index. Defaults to 0
+
+**Returns**: `number`
+
+### `Rational`
+
+The `Rational` API provides functionality to represent rational numbers (fractions).
+
+```js
+const rational = new ffmpeg.Rational(numerator, denominator)
+```
+
+Parameters:
+
+- `numerator` (`number`): The numerator
+- `denominator` (`number`): The denominator
+
+**Returns**: A new `Rational` instance
+
+#### Properties
+
+##### `Rational.numerator`
+
+Gets the numerator.
+
+**Returns**: `number`
+
+##### `Rational.denominator`
+
+Gets the denominator.
+
+**Returns**: `number`
+
+### `Stream`
+
+The `Stream` API provides functionality to access media stream information and create decoders/encoders.
+
+```js
+const stream = new ffmpeg.Stream(handle)
+```
+
+Parameters:
+
+- `handle` (`ArrayBuffer`): Internal stream handle
+
+**Returns**: A new `Stream` instance
+
+> Streams are typically obtained from format contexts: `const stream = format.streams[0]`
+
+#### Properties
+
+##### `Stream.codecParameters`
+
+Gets the codec parameters for this stream.
+
+**Returns**: `CodecParameters` instance
+
+##### `Stream.codec`
+
+Gets the codec for this stream
+
+**Returns**: `Codec` instance
+
+#### Methods
+
+##### `Stream.decoder()`
+
+Creates and opens a decoder for this stream.
+
+**Returns**: `CodecContext` instance
+
+##### `Stream.encoder()`
+
+Creates and opens an encoder for this stream.
+
+**Returns**: `CodecContext` instance
+
+##### `Stream.destroy()`
+
+Destroys the `Stream` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Resampler`
+
+The `Resampler` API provides functionality to convert audio between different sample rates, channel layouts, and sample formats.
+
+```js
+const resampler = new ffmpeg.Resampler(
+  inputSampleRate,
+  inputChannelLayout,
+  inputSampleFormat,
+  outputSampleRate,
+  outputChannelLayout,
+  outputSampleFormat
+)
+```
+
+Parameters:
+
+- `inputSampleRate` (`number`): Input sample rate in Hz
+- `inputChannelLayout` (`number`): Input channel layout constant
+- `inputSampleFormat` (`number`): Input sample format constant
+- `outputSampleRate` (`number`): Output sample rate in Hz
+- `outputChannelLayout` (`number`): Output channel layout constant
+- `outputSampleFormat` (`number`): Output sample format constant
+
+**Returns**: A new `Resampler` instance
+
+#### Properties
+
+##### `Resampler.inputSampleRate`
+
+Gets the input sample rate.
+
+**Returns**: `number`
+
+##### `Resampler.outputSampleRate`
+
+Gets the output sample rate.
+
+**Returns**: `number`
+
+##### `Resampler.delay`
+
+Gets the resampler delay in samples.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `Resampler.convert(inputFrame, outputFrame)`
+
+Converts audio data from input frame to output frame.
+
+Parameters:
+
+- `inputFrame` (`Frame`): The input audio frame
+- `outputFrame` (`Frame`): The output audio frame
+
+**Returns**: `number` of samples converted
+
+##### `Resampler.flush(outputFrame)`
+
+Flushes any remaining samples in the resampler.
+
+Parameters:
+
+- `outputFrame` (`Frame`): The output audio frame
+
+**Returns**: `number` of samples flushed
+
+##### `Resampler.destroy()`
+
+Destroys the `Resampler` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+### `Scaler`
+
+The `Scaler` API provides functionality to scale and convert video frames between different pixel formats and resolutions.
+
+```js
+const scaler = new ffmpeg.Scaler(
+  sourcePixelFormat,
+  sourceWidth,
+  sourceHeight,
+  targetPixelFormat,
+  targetWidth,
+  targetHeight
+)
+```
+
+Parameters:
+
+- `sourcePixelFormat` (`number` | `string`): Source pixel format
+- `sourceWidth` (`number`): Source width in pixels
+- `sourceHeight` (`number`): Source height in pixels
+- `targetPixelFormat` (`number` | `string`): Target pixel format
+- `targetWidth` (`number`): Target width in pixels
+- `targetHeight` (`number`): Target height in pixels
+
+**Returns**: A new `Scaler` instance
+
+#### Methods
+
+##### `Scaler.scale(source, target)`
+
+Scales a source frame to a target frame.
+
+Parameters:
+
+- `source` (`Frame`): The source frame
+- `target` (`Frame`): The target frame
+
+**Returns**: `boolean` indicating success
+
+##### `Scaler.scale(source, y, height, target)`
+
+Scales a portion of a source frame to a target frame.
+
+Parameters:
+
+- `source` (`Frame`): The source frame
+- `y` (`number`): Starting Y coordinate
+- `height` (`number`): Height to scale
+- `target` (`Frame`): The target frame
+
+**Returns**: `boolean` indicating success
+
+##### `Scaler.destroy()`
+
+Destroys the `Scaler` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
 ## License
 
 Apache-2.0

package/lib/codec-context.js

@@ -1,17 +1,14 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 const Rational = require('./rational')
 
-module.exports = class FFmpegCodecContext extends ReferenceCounted {
+module.exports = class FFmpegCodecContext {
   constructor(codec) {
-    super()
-
     this._codec = codec
     this._opened = false
     this._handle = binding.initCodecContext(codec._handle)
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyCodecContext(this._handle)
     this._handle = null
   }
@@ -65,14 +62,11 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
   }
 
   sendPacket(packet) {
-    binding.sendCodecContextPacket(this._handle, packet._handle)
-    return this
+    return binding.sendCodecContextPacket(this._handle, packet._handle)
   }
 
   receivePacket(packet) {
-    const res = binding.receiveCodecContextPacket(this._handle, packet._handle)
-    if (res) packet._ref()
-    return res
+    return binding.receiveCodecContextPacket(this._handle, packet._handle)
   }
 
   sendFrame(frame) {
@@ -82,4 +76,8 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
   receiveFrame(frame) {
     return binding.receiveCodecContextFrame(this._handle, frame._handle)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/codec-parameters.js

@@ -1,14 +1,11 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegCodecParameters extends ReferenceCounted {
+module.exports = class FFmpegCodecParameters {
   constructor(handle) {
-    super()
-
     this._handle = handle
   }
 
-  _destroy() {
+  destroy() {
     this._handle = null
   }
 
@@ -35,4 +32,8 @@ module.exports = class FFmpegCodecParameters extends ReferenceCounted {
   toContext(context) {
     binding.codecParametersToContext(context._handle, this._handle)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/codec.js

@@ -37,5 +37,6 @@ module.exports = class FFmpegCodec {
   static MJPEG = this.for(constants.codecs.MJPEG)
   static H264 = this.for(constants.codecs.H264)
   static AAC = this.for(constants.codecs.AAC)
+  static OPUS = this.for(constants.codecs.OPUS)
   static AV1 = this.for(constants.codecs.AV1)
 }

package/lib/constants.js

@@ -5,6 +5,7 @@ module.exports = exports = {
     MJPEG: binding.AV_CODEC_ID_MJPEG,
     H264: binding.AV_CODEC_ID_H264,
     AAC: binding.AV_CODEC_ID_AAC,
+    OPUS: binding.AV_CODEC_ID_OPUS,
     AV1: binding.AV_CODEC_ID_AV1
   },
   pixelFormats: {

package/lib/dictionary.js

@@ -1,14 +1,11 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegDictionary extends ReferenceCounted {
+module.exports = class FFmpegDictionary {
   constructor() {
-    super()
-
     this._handle = binding.initDictionary()
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyDictionary(this._handle)
     this._handle = null
   }
@@ -22,4 +19,8 @@ module.exports = class FFmpegDictionary extends ReferenceCounted {
   set(key, value) {
     binding.setDictionaryEntry(this._handle, key, value)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/format-context.js

@@ -1,22 +1,19 @@
 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')
 
-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
     }
 
@@ -33,13 +30,19 @@ 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)
+  }
+
+  getBestStreamIndex(type) {
+    return binding.getFormatContextBestStreamIndex(this._handle, type)
+  }
+
+  getStream(index) {
+    if (index < 0 || index >= this._streams.length) {
+      return null
     }
 
-    const result = binding.readFormatContextFrame(this._handle, packet._handle)
-    if (result) packet._ref()
-    return result
+    return this._streams[index]
   }
 
   getBestStream(type) {
@@ -58,16 +61,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':
@@ -102,8 +112,8 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
     }
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeInputFormatContext(this._handle)
     this._handle = null
@@ -121,8 +131,8 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     this._handle = binding.openOutputFormatContext(format._handle, io._handle)
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeOutputFormatContext(this._handle)
     this._handle = null

package/lib/frame.js

@@ -1,14 +1,11 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-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
   }
@@ -68,4 +65,8 @@ module.exports = class FFmpegFrame extends ReferenceCounted {
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/input-format.js

@@ -4,6 +4,7 @@ let defaultName = null
 
 switch (Bare.platform) {
   case 'darwin':
+  case 'ios':
     defaultName = 'avfoundation'
     break
   case 'linux':

package/lib/io-context.js

@@ -1,10 +1,7 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegIOContext extends ReferenceCounted {
+module.exports = class FFmpegIOContext {
   constructor(buffer = Buffer.alloc(0)) {
-    super()
-
     this._handle = binding.initIOContext(
       buffer.buffer,
       buffer.byteOffset,
@@ -12,8 +9,12 @@ module.exports = class FFmpegIOContext extends ReferenceCounted {
     )
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyIOContext(this._handle)
     this._handle = null
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/packet.js

@@ -1,10 +1,7 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegPacket extends ReferenceCounted {
+module.exports = class FFmpegPacket {
   constructor(buffer) {
-    super()
-
     if (buffer) {
       this._handle = binding.initPacketFromBuffer(
         buffer.buffer,
@@ -16,13 +13,12 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
     }
   }
 
-  _destroy() {
+  destroy() {
     binding.unrefPacket(this._handle)
     this._handle = null
   }
 
   unref() {
-    this._unref()
     binding.unrefPacket(this._handle)
   }
 
@@ -33,4 +29,8 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
   get data() {
     return Buffer.from(binding.getPacketData(this._handle))
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/resampler.js

@@ -44,6 +44,10 @@ class Resampler {
       this._handle = null
     }
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }
 
 module.exports = Resampler

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
   }
@@ -56,4 +53,8 @@ module.exports = class FFmpegScaler extends ReferenceCounted {
       target._handle
     )
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/stream.js

@@ -2,12 +2,9 @@ const binding = require('../binding')
 const Codec = require('./codec')
 const CodecContext = require('./codec-context')
 const CodecParameters = require('./codec-parameters')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegStream extends ReferenceCounted {
+module.exports = class FFmpegStream {
   constructor(handle) {
-    super()
-
     this._handle = handle
 
     this._codec = Codec.for(binding.getStreamCodec(this._handle))
@@ -17,7 +14,7 @@ module.exports = class FFmpegStream extends ReferenceCounted {
     )
   }
 
-  _destroy() {
+  destroy() {
     this._codecParameters.destroy()
     this._codecParameters = null
   }
@@ -41,4 +38,8 @@ module.exports = class FFmpegStream extends ReferenceCounted {
     this._codecParameters.toContext(context)
     return context.open()
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-7",
+  "version": "1.0.0-9",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",

package/lib/reference-counted.js

@@ -1,39 +0,0 @@
-module.exports = class FFmpegReferenceCounted {
-  constructor() {
-    this._refs = 0
-    this._destroyed = false
-  }
-
-  _ref() {
-    if (this._destroyed === false) this._refs++
-    return this
-  }
-
-  _unref() {
-    if (this._refs === 0) {
-      throw new Error('Cannot unreference object with no active references')
-    }
-
-    if (--this._refs === 0 && this._destroyed === true) this._destroy()
-    return this
-  }
-
-  _destroy() {}
-
-  destroy() {
-    if (this._refs !== 0) {
-      throw new Error('Cannot destroy object with active references')
-    }
-
-    if (this._destroyed === true) {
-      throw new Error('Object has already been destroyed')
-    }
-
-    this._destroyed = true
-    this._destroy()
-  }
-
-  [Symbol.dispose]() {
-    this.destroy()
-  }
-}