bare-ffmpeg 1.0.0-12 → 1.0.0-14

package/README.md

@@ -361,12 +361,6 @@ Parameters:
 
 **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.
@@ -676,12 +670,6 @@ 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.
@@ -815,6 +803,98 @@ Destroys the `Scaler` and frees all associated resources. Automatically called w
 
 **Returns**: `void`
 
+### `AudioFIFO`
+
+The `AudioFIFO` API provides a first in first out buffer for audio samples. This is useful for buffering audio data between different processing stages.
+
+```js
+const fifo = new ffmpeg.AudioFIFO(sampleFormat, channels, nbSamples)
+```
+
+Parameters:
+
+- `sampleFormat` (`number` | `string`): The audio sample format
+- `channels` (`number`): Number of audio channels
+- `nbSamples` (`number`): Initial buffer size in samples
+
+**Returns**: A new `AudioFIFO` instance
+
+Example:
+
+```js
+const fifo = new ffmpeg.AudioFIFO(ffmpeg.constants.sampleFormats.S16, 2, 1024)
+```
+
+#### Properties
+
+##### `AudioFIFO.size`
+
+Gets the number of samples currently in the FIFO.
+
+**Returns**: `number`
+
+##### `AudioFIFO.space`
+
+Gets the number of samples that can be written to the FIFO.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `AudioFIFO.write(frame)`
+
+Writes samples from a frame to the FIFO. The FIFO will automatically grow if needed.
+
+Parameters:
+
+- `frame` (`Frame`): The audio frame containing samples to write
+
+**Returns**: `number` of samples written
+
+##### `AudioFIFO.read(frame, nbSamples)`
+
+Reads samples from the FIFO into a frame.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to read samples into
+- `nbSamples` (`number`): Number of samples to read
+
+**Returns**: `number` of samples actually read
+
+##### `AudioFIFO.peek(frame, nbSamples)`
+
+Reads samples from the FIFO without removing them.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to read samples into
+- `nbSamples` (`number`): Number of samples to peek
+
+**Returns**: `number` of samples peeked
+
+##### `AudioFIFO.drain(nbSamples)`
+
+Removes samples from the FIFO without reading them.
+
+Parameters:
+
+- `nbSamples` (`number`): Number of samples to drain
+
+**Returns**: `void`
+
+##### `AudioFIFO.reset()`
+
+Resets the FIFO to empty state.
+
+**Returns**: `void`
+
+##### `AudioFIFO.destroy()`
+
+Destroys the `AudioFIFO` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
 ## License
 
 Apache-2.0

package/binding.cc

@@ -26,6 +26,7 @@ extern "C" {
 #include <libavutil/pixfmt.h>
 #include <libavutil/rational.h>
 #include <libavutil/samplefmt.h>
+#include <libavutil/audio_fifo.h>
 #include <libswresample/swresample.h>
 #include <libswscale/swscale.h>
 }
@@ -86,11 +87,16 @@ typedef struct {
   struct SwrContext *handle;
 } bare_ffmpeg_resampler_t;
 
+typedef struct {
+  AVAudioFifo *handle;
+} bare_ffmpeg_audio_fifo_t;
+
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static void
 bare_ffmpeg__on_init(void) {
   av_log_set_level(AV_LOG_ERROR);
+
   avdevice_register_all();
 }
 
@@ -117,8 +123,7 @@ bare_ffmpeg_io_context_init(
   else {
     io = reinterpret_cast<uint8_t *>(av_malloc(size));
 
-    size_t off = static_cast<size_t>(offset);
-    memcpy(io, &data[off], size);
+    memcpy(io, &data[static_cast<size_t>(offset)], size);
   }
 
   context->handle = avio_alloc_context(io, static_cast<int>(len), 0, NULL, NULL, NULL, NULL);
@@ -128,8 +133,13 @@ bare_ffmpeg_io_context_init(
 }
 
 static void
-bare_ffmpeg_io_context_destroy(js_env_t *env, js_receiver_t, js_arraybuffer_span_of_t<bare_ffmpeg_io_context_t, 1> context) {
+bare_ffmpeg_io_context_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_io_context_t, 1> context
+) {
   av_free(context->handle->buffer);
+
   avio_context_free(&context->handle);
 }
 
@@ -147,6 +157,7 @@ bare_ffmpeg_output_format_init(js_env_t *env, js_receiver_t, std::string name) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_output_format_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -161,6 +172,7 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_receiver_t, std::string name) {
   int err;
 
   const AVInputFormat *format = av_find_input_format(name.c_str());
+
   if (format == NULL) {
     err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name.c_str());
     assert(err == 0);
@@ -169,6 +181,7 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_receiver_t, std::string name) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_input_format_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -280,6 +293,7 @@ bare_ffmpeg_format_context_open_output(
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_format_context_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -344,11 +358,11 @@ bare_ffmpeg_format_context_get_best_stream_index(
   js_arraybuffer_span_of_t<bare_ffmpeg_format_context_t, 1> context,
   int32_t type
 ) {
-  int best_stream = av_find_best_stream(context->handle, static_cast<AVMediaType>(type), -1, -1, NULL, 0);
+  auto i = av_find_best_stream(context->handle, static_cast<AVMediaType>(type), -1, -1, NULL, 0);
 
-  if (best_stream < 0) best_stream = -1;
+  if (i < 0) i = -1;
 
-  return best_stream;
+  return i;
 }
 
 static js_arraybuffer_t
@@ -361,19 +375,13 @@ bare_ffmpeg_format_context_create_stream(
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_stream_t *stream;
   err = js_create_arraybuffer(env, stream, handle);
   assert(err == 0);
 
   stream->handle = avformat_new_stream(context->handle, codec->handle);
 
-  if (stream->handle == NULL) {
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
-
-    throw js_pending_exception;
-  }
-
   return handle;
 }
 
@@ -384,9 +392,11 @@ bare_ffmpeg_format_context_read_frame(
   js_arraybuffer_span_of_t<bare_ffmpeg_format_context_t, 1> context,
   js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
 ) {
+  int err;
+
   av_packet_unref(packet->handle);
 
-  int err = av_read_frame(context->handle, packet->handle);
+  err = av_read_frame(context->handle, packet->handle);
   if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -439,6 +449,7 @@ bare_ffmpeg_find_decoder_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_codec_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -462,6 +473,7 @@ bare_ffmpeg_find_encoder_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_codec_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -566,6 +578,7 @@ bare_ffmpeg_frame_set_channel_layout(
   js_arraybuffer_span_of_t<bare_ffmpeg_channel_layout_t, 1> layout
 ) {
   int err;
+
   err = av_channel_layout_copy(&frame->handle->ch_layout, &layout->handle);
   assert(err == 0);
 }
@@ -672,10 +685,12 @@ bare_ffmpeg_codec_context_get_time_base(
   js_receiver_t,
   js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
 ) {
+  int err;
+
   js_arraybuffer_t result;
-  int32_t *data;
 
-  int err = js_create_arraybuffer(env, data, result);
+  int32_t *data;
+  err = js_create_arraybuffer(env, 2, data, result);
   assert(err == 0);
 
   data[0] = context->handle->time_base.num;
@@ -724,6 +739,7 @@ bare_ffmpeg_codec_context_set_channel_layout(
   js_arraybuffer_span_of_t<bare_ffmpeg_channel_layout_t, 1> layout
 ) {
   int err;
+
   err = av_channel_layout_copy(&context->handle->ch_layout, &layout->handle);
   assert(err == 0);
 }
@@ -797,11 +813,7 @@ bare_ffmpeg_codec_context_send_frame(
   int err;
 
   err = avcodec_send_frame(context->handle, frame->handle);
-  if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
-    return false;
-  }
-
-  if (err < 0) {
+  if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
 
@@ -952,10 +964,12 @@ bare_ffmpeg_codec_parameters_get_channel_layout(
 
 static js_arraybuffer_t
 bare_ffmpeg_frame_init(js_env_t *env, js_receiver_t) {
+  int err;
+
   js_arraybuffer_t handle;
 
   bare_ffmpeg_frame_t *frame;
-  int err = js_create_arraybuffer(env, frame, handle);
+  err = js_create_arraybuffer(env, frame, handle);
   assert(err == 0);
 
   frame->handle = av_frame_alloc();
@@ -1113,7 +1127,7 @@ bare_ffmpeg_image_fill(
 ) {
   int err;
 
-  err = av_image_fill_arrays(
+  auto len = av_image_fill_arrays(
     frame->handle->data,
     frame->handle->linesize,
     &data[static_cast<size_t>(offset)],
@@ -1123,8 +1137,8 @@ bare_ffmpeg_image_fill(
     align
   );
 
-  if (err < 0) {
-    err = js_throw_error(env, NULL, av_err2str(err));
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
     assert(err == 0);
 
     throw js_pending_exception;
@@ -1218,6 +1232,7 @@ bare_ffmpeg_packet_init(js_env_t *env, js_receiver_t) {
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_packet_t *packet;
   err = js_create_arraybuffer(env, packet, handle);
   assert(err == 0);
@@ -1238,7 +1253,6 @@ bare_ffmpeg_packet_init_from_buffer(
   int err;
 
   AVPacket *pkt = av_packet_alloc();
-  assert(pkt != NULL);
 
   err = av_new_packet(pkt, static_cast<int>(len));
   assert(err == 0);
@@ -1246,6 +1260,7 @@ bare_ffmpeg_packet_init_from_buffer(
   memcpy(pkt->data, &data[static_cast<size_t>(offset)], static_cast<size_t>(len));
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_packet_t *packet;
   err = js_create_arraybuffer(env, packet, handle);
   assert(err == 0);
@@ -1280,9 +1295,11 @@ bare_ffmpeg_packet_get_data(
   js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
 ) {
   int err;
-  size_t size = static_cast<size_t>(packet->handle->size);
+
+  auto size = static_cast<size_t>(packet->handle->size);
 
   js_arraybuffer_t handle;
+
   uint8_t *data;
   err = js_create_arraybuffer(env, size, data, handle);
   assert(err == 0);
@@ -1303,18 +1320,21 @@ bare_ffmpeg_scaler_init(
   int32_t target_width,
   int32_t target_height
 ) {
+  int err;
+
   js_arraybuffer_t handle;
+
   bare_ffmpeg_scaler_t *scaler;
-  int err = js_create_arraybuffer(env, scaler, handle);
+  err = js_create_arraybuffer(env, scaler, handle);
   assert(err == 0);
 
   scaler->handle = sws_getContext(
     source_width,
     source_height,
-    (enum AVPixelFormat) source_format,
+    static_cast<AVPixelFormat>(source_format),
     target_width,
     target_height,
-    (enum AVPixelFormat) target_format,
+    static_cast<AVPixelFormat>(target_format),
     SWS_BICUBIC,
     NULL,
     NULL,
@@ -1345,7 +1365,7 @@ bare_ffmpeg_scaler_scale(
 ) {
   return sws_scale(
     scaler->handle,
-    (const uint8_t *const *) source->handle->data,
+    reinterpret_cast<const uint8_t *const *>(source->handle->data),
     source->handle->linesize,
     y,
     height,
@@ -1359,9 +1379,12 @@ bare_ffmpeg_dictionary_init(
   js_env_t *env,
   js_receiver_t
 ) {
+  int err;
+
   js_arraybuffer_t handle;
+
   bare_ffmpeg_dictionary_t *dict;
-  int err = js_create_arraybuffer(env, dict, handle);
+  err = js_create_arraybuffer(env, dict, handle);
   assert(err == 0);
 
   dict->handle = NULL;
@@ -1386,7 +1409,9 @@ bare_ffmpeg_dictionary_set_entry(
   std::string key,
   std::string value
 ) {
-  int err = av_dict_set(&dict->handle, key.c_str(), value.c_str(), 0);
+  int err;
+
+  err = av_dict_set(&dict->handle, key.c_str(), value.c_str(), 0);
   assert(err == 0);
 }
 
@@ -1449,7 +1474,6 @@ bare_ffmpeg_resampler_init(
   }
 
   err = swr_init(resampler->handle);
-
   if (err < 0) {
     swr_free(&resampler->handle);
 
@@ -1472,7 +1496,7 @@ bare_ffmpeg_resampler_convert_frames(
 ) {
   int err;
 
-  int result = swr_convert(
+  auto result = swr_convert(
     resampler->handle,
     (uint8_t **) out_frame->handle->data,
     out_frame->handle->nb_samples,
@@ -1483,6 +1507,7 @@ bare_ffmpeg_resampler_convert_frames(
   if (result < 0) {
     err = js_throw_error(env, NULL, av_err2str(result));
     assert(err == 0);
+
     throw js_pending_exception;
   }
 
@@ -1510,7 +1535,7 @@ bare_ffmpeg_resampler_flush(
 ) {
   int err;
 
-  int result = swr_convert(
+  auto result = swr_convert(
     resampler->handle,
     out_frame->handle->data,
     out_frame->handle->nb_samples,
@@ -1521,6 +1546,7 @@ bare_ffmpeg_resampler_flush(
   if (result < 0) {
     err = js_throw_error(env, NULL, av_err2str(result));
     assert(err == 0);
+
     throw js_pending_exception;
   }
 
@@ -1538,15 +1564,6 @@ bare_ffmpeg_resampler_destroy(
   swr_free(&resampler->handle);
 }
 
-static void
-bare_ffmpeg_channel_layout_destroy(
-  js_env_t *env,
-  js_receiver_t,
-  js_arraybuffer_span_of_t<bare_ffmpeg_channel_layout_t, 1> layout
-) {
-  av_channel_layout_uninit(&layout->handle);
-}
-
 static js_arraybuffer_t
 bare_ffmpeg_channel_layout_copy(
   js_env_t *env,
@@ -1596,6 +1613,149 @@ bare_ffmpeg_channel_layout_from_mask(
   return result;
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_audio_fifo_init(
+  js_env_t *env,
+  js_receiver_t,
+  int32_t sample_fmt,
+  int32_t channels,
+  int32_t nb_samples
+) {
+  int err;
+
+  js_arraybuffer_t handle;
+
+  bare_ffmpeg_audio_fifo_t *fifo;
+  err = js_create_arraybuffer(env, fifo, handle);
+  assert(err == 0);
+
+  fifo->handle = av_audio_fifo_alloc(
+    static_cast<AVSampleFormat>(sample_fmt),
+    channels,
+    nb_samples
+  );
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_audio_fifo_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  av_audio_fifo_free(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_write(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  int err;
+
+  int len = av_audio_fifo_write(fifo->handle, (void **) frame->handle->data, frame->handle->nb_samples);
+
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
+    assert(err == 0);
+    throw js_pending_exception;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_read(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
+  int32_t nb_samples
+) {
+  int err;
+
+  int len = av_audio_fifo_read(fifo->handle, (void **) frame->handle->data, nb_samples);
+
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
+    assert(err == 0);
+    throw js_pending_exception;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_peek(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
+  int32_t nb_samples
+) {
+  int err;
+
+  int len = av_audio_fifo_peek(fifo->handle, (void **) frame->handle->data, nb_samples);
+
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
+    assert(err == 0);
+    throw js_pending_exception;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_drain(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  int32_t nb_samples
+) {
+  int err;
+ 
+  int len = av_audio_fifo_drain(fifo->handle, nb_samples);
+
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
+    assert(err == 0);
+    throw js_pending_exception;
+  }
+ 
+  return len;
+}
+
+static void
+bare_ffmpeg_audio_fifo_reset(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  av_audio_fifo_reset(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  return av_audio_fifo_size(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_space(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  return av_audio_fifo_space(fifo->handle);
+}
+
 static js_value_t *
 bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   uv_once(&bare_ffmpeg__init_guard, bare_ffmpeg__on_init);
@@ -1706,10 +1866,19 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("getResamplerDelay", bare_ffmpeg_resampler_get_delay)
   V("flushResampler", bare_ffmpeg_resampler_flush)
 
-  V("destroyChannelLayout", bare_ffmpeg_channel_layout_destroy)
   V("copyChannelLayout", bare_ffmpeg_channel_layout_copy)
   V("getChannelLayoutNbChannels", bare_ffmpeg_channel_layout_get_nb_channels)
   V("channelLayoutFromMask", bare_ffmpeg_channel_layout_from_mask)
+
+  V("initAudioFifo", bare_ffmpeg_audio_fifo_init)
+  V("destroyAudioFifo", bare_ffmpeg_audio_fifo_destroy)
+  V("writeAudioFifo", bare_ffmpeg_audio_fifo_write)
+  V("readAudioFifo", bare_ffmpeg_audio_fifo_read)
+  V("peekAudioFifo", bare_ffmpeg_audio_fifo_peek)
+  V("drainAudioFifo", bare_ffmpeg_audio_fifo_drain)
+  V("resetAudioFifo", bare_ffmpeg_audio_fifo_reset)
+  V("getAudioFifoSize", bare_ffmpeg_audio_fifo_size)
+  V("getAudioFifoSpace", bare_ffmpeg_audio_fifo_space)
 #undef V
 
 #define V(name) \

package/index.js

@@ -1,3 +1,4 @@
+const AudioFIFO = require('./lib/audio-fifo')
 const ChannelLayout = require('./lib/channel-layout')
 const Codec = require('./lib/codec')
 const CodecContext = require('./lib/codec-context')
@@ -21,6 +22,7 @@ const Stream = require('./lib/stream')
 const Rational = require('./lib/rational')
 const Resampler = require('./lib/resampler')
 
+exports.AudioFIFO = AudioFIFO
 exports.ChannelLayout = ChannelLayout
 exports.Codec = Codec
 exports.CodecContext = CodecContext

package/lib/audio-fifo.js

@@ -0,0 +1,47 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = class FFmpegAudioFIFO {
+  constructor(sampleFormat, channels, nbSamples) {
+    sampleFormat = constants.toSampleFormat(sampleFormat)
+
+    this._handle = binding.initAudioFifo(sampleFormat, channels, nbSamples)
+  }
+
+  destroy() {
+    binding.destroyAudioFifo(this._handle)
+    this._handle = null
+  }
+
+  write(frame) {
+    return binding.writeAudioFifo(this._handle, frame._handle)
+  }
+
+  read(frame, nbSamples) {
+    return binding.readAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  peek(frame, nbSamples) {
+    return binding.peekAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  drain(nbSamples) {
+    return binding.drainAudioFifo(this._handle, nbSamples)
+  }
+
+  reset() {
+    binding.resetAudioFifo(this._handle)
+  }
+
+  get size() {
+    return binding.getAudioFifoSize(this._handle)
+  }
+
+  get space() {
+    return binding.getAudioFifoSpace(this._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/channel-layout.js

@@ -10,15 +10,6 @@ module.exports = class FFmpegChannelLayout {
     return binding.getChannelLayoutNbChannels(this._handle)
   }
 
-  destroy() {
-    binding.destroyChannelLayout(this._handle)
-    this._handle = null
-  }
-
-  [Symbol.dispose]() {
-    this.destroy()
-  }
-
   static from(value) {
     if (typeof value === 'string') value = constants.toChannelLayout(value)
 

package/lib/codec-context.js

@@ -72,9 +72,10 @@ module.exports = class FFmpegCodecContext {
   }
 
   set channelLayout(value) {
-    using copy = ChannelLayout.from(value)
-
-    binding.setCodecContextChannelLayout(this._handle, copy._handle)
+    binding.setCodecContextChannelLayout(
+      this._handle,
+      ChannelLayout.from(value)._handle
+    )
   }
 
   open(options) {

package/lib/codec-parameters.js

@@ -6,10 +6,6 @@ module.exports = class FFmpegCodecParameters {
     this._handle = handle
   }
 
-  destroy() {
-    this._handle = null
-  }
-
   get bitRate() {
     return binding.getCodecParametersBitRate(this._handle)
   }
@@ -51,8 +47,4 @@ module.exports = class FFmpegCodecParameters {
   toContext(context) {
     binding.codecParametersToContext(context._handle, this._handle)
   }
-
-  [Symbol.dispose]() {
-    this.destroy()
-  }
 }

package/lib/format-context.js

@@ -16,9 +16,6 @@ class FFmpegFormatContext {
       this._io.destroy()
       this._io = null
     }
-
-    for (const stream of this._streams) stream.destroy()
-    this._streams = []
   }
 
   get io() {

package/lib/frame.js

@@ -48,9 +48,10 @@ module.exports = class FFmpegFrame {
   }
 
   set channelLayout(value) {
-    using copy = ChannelLayout.from(value)
-
-    binding.setFrameChannelLayout(this._handle, copy._handle)
+    binding.setFrameChannelLayout(
+      this._handle,
+      ChannelLayout.from(value)._handle
+    )
   }
 
   get nbSamples() {

package/lib/stream.js

@@ -14,11 +14,6 @@ module.exports = class FFmpegStream {
     )
   }
 
-  destroy() {
-    this._codecParameters.destroy()
-    this._codecParameters = null
-  }
-
   get codec() {
     return this._codec
   }
@@ -38,8 +33,4 @@ module.exports = class FFmpegStream {
     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-12",
+  "version": "1.0.0-14",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",