bare-ffmpeg 1.0.0-26 → 1.0.0-27

package/binding.cc

@@ -1,3 +1,4 @@
+#include <optional>
 #include <tuple>
 #include <vector>
 
@@ -16,6 +17,9 @@ extern "C" {
 #include <libavcodec/codec_par.h>
 #include <libavcodec/packet.h>
 #include <libavdevice/avdevice.h>
+#include <libavfilter/avfilter.h>
+#include <libavfilter/buffersink.h>
+#include <libavfilter/buffersrc.h>
 #include <libavformat/avformat.h>
 #include <libavformat/avio.h>
 #include <libavutil/audio_fifo.h>
@@ -107,6 +111,22 @@ typedef struct {
   AVPacketSideData *handle;
 } bare_ffmpeg_side_data_t;
 
+typedef struct {
+  const AVFilter *handle;
+} bare_ffmpeg_filter_t;
+
+typedef struct {
+  AVFilterContext *handle;
+} bare_ffmpeg_filter_context_t;
+
+typedef struct {
+  AVFilterGraph *handle;
+} bare_ffmpeg_filter_graph_t;
+
+typedef struct {
+  AVFilterInOut *handle;
+} bare_ffmpeg_filter_inout_t;
+
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static inline bool
@@ -826,6 +846,155 @@ bare_ffmpeg_get_sample_format_name_by_id(js_env_t *env, js_receiver_t, uint32_t
   return av_get_sample_fmt_name(static_cast<enum AVSampleFormat>(id));
 }
 
+static std::vector<int32_t>
+bare_ffmpeg_codec_get_supported_config(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_t, 1> codec,
+  int32_t cfg
+) {
+  int err;
+
+  int count = 0;
+  const void *list = nullptr;
+
+  err = avcodec_get_supported_config(context->handle, codec->handle, static_cast<AVCodecConfig>(cfg), 0, &list, &count);
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  std::vector<int32_t> values;
+
+  if (count > 0 && list) {
+    const int32_t *int_list = static_cast<const int32_t *>(list);
+    for (int i = 0; i < count; i++) {
+      values.push_back(int_list[i]);
+    }
+    return values;
+  }
+
+  switch (static_cast<AVCodecConfig>(cfg)) {
+  case AV_CODEC_CONFIG_PIX_FORMAT:
+    for (int i = 0; i < AV_PIX_FMT_NB; i++) {
+      if (av_pix_fmt_desc_get(static_cast<AVPixelFormat>(i)) != nullptr) {
+        values.push_back(i);
+      }
+    }
+    break;
+  case AV_CODEC_CONFIG_SAMPLE_FORMAT:
+    for (int i = 0; i < AV_SAMPLE_FMT_NB; i++) {
+      values.push_back(i);
+    }
+    break;
+  case AV_CODEC_CONFIG_COLOR_RANGE:
+    values.push_back(AVCOL_RANGE_UNSPECIFIED);
+    values.push_back(AVCOL_RANGE_MPEG);
+    values.push_back(AVCOL_RANGE_JPEG);
+    break;
+  case AV_CODEC_CONFIG_COLOR_SPACE:
+    for (int i = 0; i < AVCOL_SPC_NB; i++) {
+      values.push_back(i);
+    }
+    break;
+  case AV_CODEC_CONFIG_SAMPLE_RATE:
+    values.push_back(0);
+    break;
+  default:
+    break;
+  }
+
+  return values;
+}
+
+static std::optional<js_arraybuffer_t>
+bare_ffmpeg_codec_get_supported_frame_rates(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_t, 1> codec
+) {
+  int err;
+
+  const AVCodecContext *ctx = context->handle;
+  const AVCodec *c = codec->handle;
+
+  int count = 0;
+  const void *list = nullptr;
+
+  err = avcodec_get_supported_config(ctx, c, AV_CODEC_CONFIG_FRAME_RATE, 0, &list, &count);
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  if (!list || count == 0) {
+    return std::nullopt;
+  }
+
+  js_arraybuffer_t result;
+  int32_t *data;
+  err = js_create_arraybuffer(env, static_cast<size_t>(count * 2), data, result);
+  assert(err == 0);
+
+  const AVRational *rational_list = static_cast<const AVRational *>(list);
+  for (int i = 0; i < count; i++) {
+    data[i * 2] = rational_list[i].num;
+    data[i * 2 + 1] = rational_list[i].den;
+  }
+
+  return result;
+}
+
+static std::optional<std::vector<js_arraybuffer_t>>
+bare_ffmpeg_codec_get_supported_channel_layouts(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_t, 1> codec
+) {
+  int err;
+  std::vector<js_arraybuffer_t> result;
+
+  const AVCodecContext *ctx = context->handle;
+  const AVCodec *c = codec->handle;
+
+  int count = 0;
+  const void *list = nullptr;
+
+  err = avcodec_get_supported_config(ctx, c, AV_CODEC_CONFIG_CHANNEL_LAYOUT, 0, &list, &count);
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  if (!list || count == 0) {
+    return std::nullopt;
+  }
+
+  const AVChannelLayout *layout_list = static_cast<const AVChannelLayout *>(list);
+  for (int i = 0; i < count; i++) {
+    js_arraybuffer_t handle;
+    bare_ffmpeg_channel_layout_t *layout;
+    err = js_create_arraybuffer(env, layout, handle);
+    assert(err == 0);
+
+    err = av_channel_layout_copy(&layout->handle, &layout_list[i]);
+    assert(err >= 0);
+
+    result.push_back(handle);
+  }
+
+  return result;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_codec_context_init(
   js_env_t *env,
@@ -1187,6 +1356,24 @@ bare_ffmpeg_codec_context_set_gop_size(
   context->handle->gop_size = gop_size;
 }
 
+static int
+bare_ffmpeg_codec_context_get_frame_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
+) {
+  return context->handle->frame_size;
+}
+
+static int64_t
+bare_ffmpeg_codec_context_get_frame_num(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
+) {
+  return context->handle->frame_num;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_codec_context_get_framerate(
   js_env_t *env,
@@ -2200,71 +2387,60 @@ bare_ffmpeg_image_get_line_size(
   );
 }
 
-static js_arraybuffer_t
-bare_ffmpeg_samples_init(
+static int
+bare_ffmpeg_samples_buffer_size(
   js_env_t *env,
   js_receiver_t,
   int32_t sample_format,
   int32_t nb_channels,
   int32_t nb_samples,
-  int32_t align
+  bool no_alignment
 ) {
-  int err;
-
   auto len = av_samples_get_buffer_size(
     NULL,
     nb_channels,
     nb_samples,
     static_cast<AVSampleFormat>(sample_format),
-    align
+    no_alignment
   );
 
   if (len < 0) {
-    err = js_throw_error(env, NULL, av_err2str(len));
+    int err = js_throw_error(env, NULL, av_err2str(len));
     assert(err == 0);
 
     throw js_pending_exception;
   }
 
-  js_arraybuffer_t handle;
-  err = js_create_arraybuffer(env, static_cast<size_t>(len), handle);
-  assert(err == 0);
-
-  return handle;
+  return len;
 }
 
 static int
 bare_ffmpeg_samples_fill(
   js_env_t *env,
   js_receiver_t,
-  int32_t sample_format,
-  int32_t nb_channels,
-  int32_t nb_samples,
-  int32_t align,
-  js_arraybuffer_span_t data,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
+  js_arraybuffer_span_t target,
   uint64_t offset,
-  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+  bool no_alignment
 ) {
-  int err;
-
-  auto len = av_samples_fill_arrays(
+  auto res = av_samples_fill_arrays(
     frame->handle->data,
     frame->handle->linesize,
-    &data[static_cast<size_t>(offset)],
-    nb_channels,
-    nb_samples,
-    static_cast<AVSampleFormat>(sample_format),
-    align
+    &target[offset],
+    frame->handle->ch_layout.nb_channels,
+    frame->handle->nb_samples,
+    static_cast<AVSampleFormat>(frame->handle->format),
+    no_alignment
   );
 
-  if (len < 0) {
-    err = js_throw_error(env, NULL, av_err2str(len));
+  if (res < 0) {
+    int err = js_throw_error(env, NULL, av_err2str(res));
     assert(err == 0);
 
     throw js_pending_exception;
   }
 
-  return len;
+  return res;
 }
 
 static js_arraybuffer_t
@@ -2610,6 +2786,24 @@ bare_ffmpeg_packet_set_flags(
   packet->handle->flags = value;
 }
 
+static void
+bare_ffmpeg_packet_copy_props(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> dst,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> src
+) {
+  int err;
+
+  err = av_packet_copy_props(dst->handle, src->handle);
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+}
+
 static int
 bare_ffmpeg_side_data_get_type(
   js_env_t *env,
@@ -2868,8 +3062,6 @@ bare_ffmpeg_resampler_convert_frames(
     throw js_pending_exception;
   }
 
-  out_frame->handle->nb_samples = result;
-
   return result;
 }
 
@@ -3148,6 +3340,246 @@ bare_ffmpeg_rational_d2q(
   return result;
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_filter_get_by_name(
+  js_env_t *env,
+  js_receiver_t,
+  std::string name
+) {
+  int err;
+
+  js_arraybuffer_t handle;
+  bare_ffmpeg_filter_t *filter;
+  err = js_create_arraybuffer(env, filter, handle);
+  assert(err == 0);
+
+  filter->handle = avfilter_get_by_name(name.c_str());
+  if (filter->handle == nullptr) {
+    err = js_throw_errorf(env, nullptr, "No Filter found for '%s' name", name.c_str());
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+
+  return handle;
+}
+
+static js_arraybuffer_t
+bare_ffmpeg_filter_context_init(
+  js_env_t *env,
+  js_receiver_t
+) {
+  js_arraybuffer_t handle;
+  bare_ffmpeg_filter_context_t *filter_ctx;
+  int err = js_create_arraybuffer(env, filter_ctx, handle);
+  assert(err == 0);
+
+  return handle;
+}
+
+static js_arraybuffer_t
+bare_ffmpeg_filter_graph_init(
+  js_env_t *env,
+  js_receiver_t
+) {
+  js_arraybuffer_t handle;
+  bare_ffmpeg_filter_graph_t *filter_graph;
+  int err = js_create_arraybuffer(env, filter_graph, handle);
+  assert(err == 0);
+
+  filter_graph->handle = avfilter_graph_alloc();
+  assert(filter_graph->handle != nullptr);
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_filter_graph_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_graph_t, 1> filter_graph
+) {
+  avfilter_graph_free(&filter_graph->handle);
+}
+
+static void
+bare_ffmpeg_filter_graph_create_filter(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_graph_t, 1> graph,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_context_t, 1> filter_context,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_t, 1> filter,
+  std::string name,
+  std::optional<std::string> args
+) {
+  int err = avfilter_graph_create_filter(
+    &filter_context->handle,
+    filter->handle,
+    name.c_str(),
+    args.has_value() ? args.value().c_str() : nullptr,
+    nullptr,
+    graph->handle
+  );
+
+  if (err < 0) {
+    err = js_throw_error(env, nullptr, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+}
+
+static void
+bare_ffmpeg_filter_graph_parse(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_graph_t, 1> graph,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> inputs,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> outputs,
+  std::string filter_description
+) {
+  int err = avfilter_graph_parse(graph->handle, filter_description.c_str(), inputs->handle, outputs->handle, nullptr);
+  if (err < 0) {
+    err = js_throw_error(env, nullptr, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+}
+
+static void
+bare_ffmpeg_filter_graph_configure(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_graph_t, 1> graph
+) {
+  int err = avfilter_graph_config(graph->handle, nullptr);
+  if (err < 0) {
+    err = js_throw_error(env, nullptr, av_err2str(err));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
+}
+
+static int
+bare_ffmpeg_filter_graph_push_frame(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_context_t, 1> ctx,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  return av_buffersrc_add_frame(ctx->handle, frame->handle);
+}
+
+static int
+bare_ffmpeg_filter_graph_pull_frame(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_context_t, 1> ctx,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  return av_buffersink_get_frame(ctx->handle, frame->handle);
+}
+
+static js_arraybuffer_t
+bare_ffmpeg_filter_inout_init(
+  js_env_t *env,
+  js_receiver_t
+) {
+  js_arraybuffer_t handle;
+  bare_ffmpeg_filter_inout_t *filter_inout;
+  int err = js_create_arraybuffer(env, filter_inout, handle);
+  assert(err == 0);
+
+  filter_inout->handle = avfilter_inout_alloc();
+  assert(filter_inout->handle);
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_filter_inout_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout
+) {
+  avfilter_inout_free(&filter_inout->handle);
+}
+
+static std::optional<std::string>
+bare_ffmpeg_filter_inout_get_name(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout
+) {
+  if (!filter_inout->handle->name) return std::nullopt;
+  return filter_inout->handle->name;
+}
+
+static void
+bare_ffmpeg_filter_inout_set_name(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout,
+  std::string name
+) {
+  if (filter_inout->handle->name) {
+    av_free(filter_inout->handle->name);
+  }
+  filter_inout->handle->name = av_strdup(name.c_str());
+}
+
+static void
+bare_ffmpeg_filter_inout_set_filter_context(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_context_t, 1> filter_ctx
+) {
+  filter_inout->handle->filter_ctx = filter_ctx->handle;
+}
+
+static int
+bare_ffmpeg_filter_inout_get_pad_idx(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout
+) {
+  return filter_inout->handle->pad_idx;
+}
+
+static void
+bare_ffmpeg_filter_inout_set_pad_idx(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout,
+  int pad_idx
+) {
+  filter_inout->handle->pad_idx = pad_idx;
+}
+
+static void
+bare_ffmpeg_filter_inout_set_next(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> filter_inout,
+  js_arraybuffer_span_of_t<bare_ffmpeg_filter_inout_t, 1> next
+) {
+  filter_inout->handle->next = next->handle;
+}
+
+static int64_t
+bare_ffmpeg_rational_rescale_q(
+  int64_t ts,
+  int32_t bq_num,
+  int32_t bq_den,
+  int32_t cq_num,
+  int32_t cq_den
+) {
+  return av_rescale_q(ts, {bq_num, bq_den}, {cq_num, cq_den});
+}
+
 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);
@@ -3196,6 +3628,9 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("findEncoderByID", bare_ffmpeg_find_encoder_by_id)
   V("getCodecNameByID", bare_ffmpeg_get_codec_name_by_id)
   V("getSampleFormatNameByID", bare_ffmpeg_get_sample_format_name_by_id)
+  V("getSupportedConfig", bare_ffmpeg_codec_get_supported_config)
+  V("getSupportedFrameRates", bare_ffmpeg_codec_get_supported_frame_rates)
+  V("getSupportedChannelLayouts", bare_ffmpeg_codec_get_supported_channel_layouts)
 
   V("initCodecContext", bare_ffmpeg_codec_context_init)
   V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
@@ -3223,6 +3658,8 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setCodecContextFramerate", bare_ffmpeg_codec_context_set_framerate)
   V("getCodecContextExtraData", bare_ffmpeg_codec_context_get_extra_data)
   V("setCodecContextExtraData", bare_ffmpeg_codec_context_set_extra_data)
+  V("getCodecContextFrameSize", bare_ffmpeg_codec_context_get_frame_size)
+  V("getCodecContextFrameNum", bare_ffmpeg_codec_context_get_frame_num)
 
   V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
   V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
@@ -3307,7 +3744,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("readImage", bare_ffmpeg_image_read)
   V("getImageLineSize", bare_ffmpeg_image_get_line_size)
 
-  V("initSamples", bare_ffmpeg_samples_init)
+  V("samplesBufferSize", bare_ffmpeg_samples_buffer_size)
   V("fillSamples", bare_ffmpeg_samples_fill)
 
   V("initPacket", bare_ffmpeg_packet_init)
@@ -3333,6 +3770,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setPacketDuration", bare_ffmpeg_packet_set_duration)
   V("getPacketFlags", bare_ffmpeg_packet_get_flags)
   V("setPacketFlags", bare_ffmpeg_packet_set_flags)
+  V("copyPacketProps", bare_ffmpeg_packet_copy_props)
 
   V("getSideDataType", bare_ffmpeg_side_data_get_type)
   V("getSideDataName", bare_ffmpeg_side_data_get_name)
@@ -3370,6 +3808,28 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("getAudioFifoSpace", bare_ffmpeg_audio_fifo_space)
 
   V("rationalD2Q", bare_ffmpeg_rational_d2q)
+  V("rationalRescaleQ", bare_ffmpeg_rational_rescale_q)
+
+  V("getFilterByName", bare_ffmpeg_filter_get_by_name)
+
+  V("initFilterContext", bare_ffmpeg_filter_context_init)
+
+  V("initFilterGraph", bare_ffmpeg_filter_graph_init)
+  V("destroyFilterGraph", bare_ffmpeg_filter_graph_destroy)
+  V("createFilterGraphFilter", bare_ffmpeg_filter_graph_create_filter)
+  V("parseFilterGraph", bare_ffmpeg_filter_graph_parse)
+  V("configureFilterGraph", bare_ffmpeg_filter_graph_configure)
+  V("pushFilterGraphFrame", bare_ffmpeg_filter_graph_push_frame)
+  V("pullFilterGraphFrame", bare_ffmpeg_filter_graph_pull_frame)
+
+  V("initFilterInout", bare_ffmpeg_filter_inout_init)
+  V("destroyFilterInOut", bare_ffmpeg_filter_inout_destroy)
+  V("getFilterInOutName", bare_ffmpeg_filter_inout_get_name)
+  V("setFilterInOutName", bare_ffmpeg_filter_inout_set_name)
+  V("setFilterInOutFilterContext", bare_ffmpeg_filter_inout_set_filter_context)
+  V("getFilterInOutPadIdx", bare_ffmpeg_filter_inout_get_pad_idx)
+  V("setFilterInOutPadIdx", bare_ffmpeg_filter_inout_set_pad_idx)
+  V("setFilterInOutNext", bare_ffmpeg_filter_inout_set_next)
 #undef V
 
 #define V(name) \
@@ -3647,6 +4107,14 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(AV_PKT_DATA_RTCP_SR)
   V(AV_PKT_DATA_NB)
 
+  V(AV_CODEC_CONFIG_PIX_FORMAT)
+  V(AV_CODEC_CONFIG_FRAME_RATE)
+  V(AV_CODEC_CONFIG_SAMPLE_RATE)
+  V(AV_CODEC_CONFIG_SAMPLE_FORMAT)
+  V(AV_CODEC_CONFIG_CHANNEL_LAYOUT)
+  V(AV_CODEC_CONFIG_COLOR_RANGE)
+  V(AV_CODEC_CONFIG_COLOR_SPACE)
+
 #undef V
 
   return exports;

package/index.js

@@ -10,6 +10,10 @@ const {
   InputFormatContext,
   OutputFormatContext
 } = require('./lib/format-context')
+const Filter = require('./lib/filter')
+const FilterContext = require('./lib/filter-context')
+const FilterGraph = require('./lib/filter-graph')
+const FilterInOut = require('./lib/filter-inout')
 const Frame = require('./lib/frame')
 const IOContext = require('./lib/io-context')
 const Image = require('./lib/image')
@@ -31,6 +35,10 @@ exports.CodecParameters = CodecParameters
 exports.Decoder = Decoder
 exports.Dictionary = Dictionary
 exports.Encoder = Encoder
+exports.Filter = Filter
+exports.FilterContext = FilterContext
+exports.FilterGraph = FilterGraph
+exports.FilterInOut = FilterInOut
 exports.Frame = Frame
 exports.IOContext = IOContext
 exports.Image = Image