bare-ffmpeg 1.0.0-25 → 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>
@@ -103,6 +107,26 @@ typedef struct {
   AVAudioFifo *handle;
 } bare_ffmpeg_audio_fifo_t;
 
+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
@@ -817,6 +841,160 @@ bare_ffmpeg_get_codec_name_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
   return std::string(name);
 }
 
+static std::string
+bare_ffmpeg_get_sample_format_name_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
+  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,
@@ -884,6 +1062,49 @@ bare_ffmpeg_codec_context_set_flags(
   context->handle->flags = value;
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_codec_context_get_extra_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
+) {
+  js_arraybuffer_t buffer;
+  int err = js_create_arraybuffer(
+    env,
+    context->handle->extradata,
+    static_cast<size_t>(context->handle->extradata_size),
+    buffer
+  );
+  assert(err == 0);
+
+  return buffer;
+}
+
+void
+bare_ffmpeg_codec_context_set_extra_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context,
+  js_arraybuffer_t buffer,
+  uint32_t offset,
+  uint32_t len
+) {
+  std::span<uint8_t> view;
+  int err = js_get_arraybuffer_info(env, buffer, view);
+  assert(err == 0);
+
+  if (context->handle->extradata_size) {
+    av_free(context->handle->extradata);
+  }
+
+  context->handle->extradata = reinterpret_cast<uint8_t *>(av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE));
+
+  memset(&context->handle->extradata[len], 0, AV_INPUT_BUFFER_PADDING_SIZE);
+  memcpy(context->handle->extradata, &view[offset], len);
+
+  context->handle->extradata_size = static_cast<int>(len);
+}
+
 static int
 bare_ffmpeg_frame_get_format(
   js_env_t *env,
@@ -1135,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,
@@ -1809,6 +2048,25 @@ bare_ffmpeg_codec_parameters_set_video_delay(
   parameters->handle->video_delay = delay;
 }
 
+static int
+bare_ffmpeg_codec_parameters_get_frame_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->frame_size;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_frame_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int frame_size
+) {
+  parameters->handle->frame_size = frame_size;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_frame_init(js_env_t *env, js_receiver_t) {
   int err;
@@ -2129,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
@@ -2318,6 +2565,62 @@ bare_ffmpeg_packet_set_data(
   memcpy(packet->handle->data, &data[offset], len);
 }
 
+static std::vector<js_arraybuffer_t>
+bare_ffmpeg_packet_get_side_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
+) {
+  std::vector<js_arraybuffer_t> res{};
+
+  int count = packet->handle->side_data_elems;
+  if (count == 0) return res;
+
+  for (int i = 0; i < count; i++) {
+    js_arraybuffer_t handle;
+    bare_ffmpeg_side_data_t *sd;
+    int err = js_create_arraybuffer(env, sd, handle);
+    assert(err == 0);
+
+    sd->handle = &packet->handle->side_data[i];
+
+    res.push_back(handle);
+  }
+
+  return res;
+}
+
+static void
+bare_ffmpeg_packet_set_side_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet,
+  std::vector<js_object_t> side_data_array
+) {
+  for (js_object_t side_data : side_data_array) {
+    int err;
+
+    int32_t type;
+    err = js_get_property(env, side_data, "type", type);
+    assert(err == 0);
+
+    js_arraybuffer_span_t buf;
+    err = js_get_property(env, side_data, "buffer", buf);
+    assert(err == 0);
+
+    int32_t offset;
+    err = js_get_property(env, side_data, "offset", offset);
+    assert(err == 0);
+
+    int32_t len;
+    err = js_get_property(env, side_data, "length", len);
+    assert(err == 0);
+
+    uint8_t *data = av_packet_new_side_data(packet->handle, static_cast<AVPacketSideDataType>(type), static_cast<size_t>(len));
+    memcpy(data, &buf[static_cast<size_t>(offset)], static_cast<size_t>(len));
+  }
+}
+
 static bool
 bare_ffmpeg_packet_is_keyframe(
   js_env_t *,
@@ -2327,6 +2630,20 @@ bare_ffmpeg_packet_is_keyframe(
   return packet->handle->flags & AV_PKT_FLAG_KEY;
 }
 
+static void
+bare_ffmpeg_packet_set_is_keyframe(
+  js_env_t *,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet,
+  bool has_key_frame
+) {
+  if (has_key_frame) {
+    packet->handle->flags |= AV_PKT_FLAG_KEY;
+  } else {
+    packet->handle->flags &= ~AV_PKT_FLAG_KEY;
+  }
+}
+
 static int64_t
 bare_ffmpeg_packet_get_dts(
   js_env_t *env,
@@ -2469,6 +2786,58 @@ 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,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_side_data_t, 1> side_data
+) {
+  return side_data->handle->type;
+}
+
+static std::string
+bare_ffmpeg_side_data_get_name(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_side_data_t, 1> side_data
+) {
+  return av_packet_side_data_name(side_data->handle->type);
+}
+
+static js_arraybuffer_t
+bare_ffmpeg_side_data_get_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_side_data_t, 1> side_data
+) {
+  js_arraybuffer_t handle;
+  uint8_t *buf;
+  int err = js_create_arraybuffer(env, side_data->handle->size, buf, handle);
+  assert(err == 0);
+
+  memcpy(buf, side_data->handle->data, side_data->handle->size);
+
+  return handle;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_scaler_init(
   js_env_t *env,
@@ -2693,8 +3062,6 @@ bare_ffmpeg_resampler_convert_frames(
     throw js_pending_exception;
   }
 
-  out_frame->handle->nb_samples = result;
-
   return result;
 }
 
@@ -2973,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);
@@ -3020,6 +3627,10 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("findDecoderByID", bare_ffmpeg_find_decoder_by_id)
   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)
@@ -3045,6 +3656,10 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setCodecContextGOPSize", bare_ffmpeg_codec_context_set_gop_size)
   V("getCodecContextFramerate", bare_ffmpeg_codec_context_get_framerate)
   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)
@@ -3099,6 +3714,8 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setCodecParametersSampleAspectRatio", bare_ffmpeg_codec_parameters_set_sample_aspect_ratio)
   V("getCodecParametersVideoDelay", bare_ffmpeg_codec_parameters_get_video_delay)
   V("setCodecParametersVideoDelay", bare_ffmpeg_codec_parameters_set_video_delay)
+  V("getCodecParametersFrameSize", bare_ffmpeg_codec_parameters_get_frame_size)
+  V("setCodecParametersFrameSize", bare_ffmpeg_codec_parameters_set_frame_size)
 
   V("initFrame", bare_ffmpeg_frame_init)
   V("destroyFrame", bare_ffmpeg_frame_destroy)
@@ -3127,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)
@@ -3138,7 +3755,10 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setPacketStreamIndex", bare_ffmpeg_packet_set_stream_index)
   V("getPacketData", bare_ffmpeg_packet_get_data)
   V("setPacketData", bare_ffmpeg_packet_set_data)
+  V("getPacketSideData", bare_ffmpeg_packet_get_side_data)
+  V("setPacketSideData", bare_ffmpeg_packet_set_side_data)
   V("isPacketKeyframe", bare_ffmpeg_packet_is_keyframe)
+  V("setPacketIsKeyFrame", bare_ffmpeg_packet_set_is_keyframe)
   V("getPacketDTS", bare_ffmpeg_packet_get_dts)
   V("setPacketDTS", bare_ffmpeg_packet_set_dts)
   V("getPacketPTS", bare_ffmpeg_packet_get_pts)
@@ -3150,6 +3770,11 @@ 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)
+  V("getSideDataBuffer", bare_ffmpeg_side_data_get_data)
 
   V("initScaler", bare_ffmpeg_scaler_init)
   V("destroyScaler", bare_ffmpeg_scaler_destroy)
@@ -3183,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) \
@@ -3417,6 +4064,57 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(SEEK_CUR)
   V(SEEK_SET)
   V(SEEK_END)
+
+  V(AV_PKT_DATA_PALETTE)
+  V(AV_PKT_DATA_NEW_EXTRADATA)
+  V(AV_PKT_DATA_PARAM_CHANGE)
+  V(AV_PKT_DATA_H263_MB_INFO)
+  V(AV_PKT_DATA_REPLAYGAIN)
+  V(AV_PKT_DATA_DISPLAYMATRIX)
+  V(AV_PKT_DATA_STEREO3D)
+  V(AV_PKT_DATA_AUDIO_SERVICE_TYPE)
+  V(AV_PKT_DATA_QUALITY_STATS)
+  V(AV_PKT_DATA_FALLBACK_TRACK)
+  V(AV_PKT_DATA_CPB_PROPERTIES)
+  V(AV_PKT_DATA_SKIP_SAMPLES)
+  V(AV_PKT_DATA_JP_DUALMONO)
+  V(AV_PKT_DATA_STRINGS_METADATA)
+  V(AV_PKT_DATA_SUBTITLE_POSITION)
+  V(AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL)
+  V(AV_PKT_DATA_WEBVTT_IDENTIFIER)
+  V(AV_PKT_DATA_WEBVTT_SETTINGS)
+  V(AV_PKT_DATA_METADATA_UPDATE)
+  V(AV_PKT_DATA_MPEGTS_STREAM_ID)
+  V(AV_PKT_DATA_MASTERING_DISPLAY_METADATA)
+  V(AV_PKT_DATA_SPHERICAL)
+  V(AV_PKT_DATA_CONTENT_LIGHT_LEVEL)
+  V(AV_PKT_DATA_A53_CC)
+  V(AV_PKT_DATA_ENCRYPTION_INIT_INFO)
+  V(AV_PKT_DATA_ENCRYPTION_INFO)
+  V(AV_PKT_DATA_AFD)
+  V(AV_PKT_DATA_PRFT)
+  V(AV_PKT_DATA_ICC_PROFILE)
+  V(AV_PKT_DATA_DOVI_CONF)
+  V(AV_PKT_DATA_S12M_TIMECODE)
+  V(AV_PKT_DATA_DYNAMIC_HDR10_PLUS)
+  V(AV_PKT_DATA_IAMF_MIX_GAIN_PARAM)
+  V(AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM)
+  V(AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM)
+  V(AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT)
+  V(AV_PKT_DATA_FRAME_CROPPING)
+  V(AV_PKT_DATA_LCEVC)
+  V(AV_PKT_DATA_3D_REFERENCE_DISPLAYS)
+  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;