bare-ffmpeg 1.0.0-21 → 1.0.0-23

package/CMakeLists.txt

@@ -8,7 +8,7 @@ project(bare_ffmpeg C CXX)
 
 fetch_package("github:holepunchto/libjstl#5b85a24")
 
-find_port(ffmpeg FEATURES gpl dav1d svt-av1 x264 opus)
+find_port(ffmpeg FEATURES dav1d svt-av1 opus)
 
 add_bare_module(bare_ffmpeg)
 

package/README.md

@@ -108,6 +108,21 @@ for (const [key, value] of dict) {
 }
 ```
 
+#### Static methods
+
+##### `Dictionary.from(object)`
+
+A helper to create a `Dictionary` instance from an object.
+
+```js
+const dict = ffmpeg.Dictionary.from({
+  foo: 'bar',
+  baz: 'qux'
+})
+```
+
+**Returns**: A new `Dictionary` instance
+
 ### `FormatContext`
 
 The `FormatContext` API provides the base functionality for reading and writing media files.
@@ -600,15 +615,9 @@ 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.
+Gets or sets the format of the frame, `-1` if unknown or unset.
 
 **Returns**: `number` (sample format constant)
 
@@ -852,17 +861,47 @@ Parameters:
 
 #### Properties
 
+##### `Stream.id`
+
+Gets or sets the stream ID.
+
+**Returns**: `number`
+
+##### `Stream.index`
+
+Gets the stream index.
+
+**Returns**: `number`
+
+##### `Stream.codec`
+
+Gets the codec for this stream.
+
+**Returns**: `Codec` instance
+
 ##### `Stream.codecParameters`
 
 Gets the codec parameters for this stream.
 
 **Returns**: `CodecParameters` instance
 
-##### `Stream.codec`
+##### `Stream.timeBase`
 
-Gets the codec for this stream
+Gets or sets the time base for the stream.
 
-**Returns**: `Codec` instance
+**Returns**: `Rational` instance
+
+##### `Stream.avgFramerate`
+
+Gets or sets the average framerate for video streams.
+
+**Returns**: `Rational` instance
+
+Example:
+
+```js
+const fps = stream.avgFramerate.toNumber()
+```
 
 #### Methods
 

package/binding.cc

@@ -1,14 +1,13 @@
-#include <assert.h>
-#include <cstdint>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
 #include <tuple>
 #include <vector>
 
+#include <assert.h>
 #include <bare.h>
 #include <js.h>
 #include <jstl.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
 
 extern "C" {
 #include <libavcodec/avcodec.h>
@@ -34,13 +33,18 @@ extern "C" {
 #include <libswscale/swscale.h>
 }
 
-using bare_ffmpeg_io_context_on_write_cb_t = js_function_t<void, js_arraybuffer_t>;
+using bare_ffmpeg_io_context_write_cb_t = js_function_t<void, js_typedarray_t<uint8_t>>;
+using bare_ffmpeg_io_context_read_cb_t = js_function_t<int32_t, js_typedarray_t<uint8_t>, int32_t>;
+using bare_ffmpeg_io_context_seek_cb_t = js_function_t<int64_t, int64_t, std::string>;
 
 typedef struct {
   AVIOContext *handle;
 
   js_env_t *env;
-  js_persistent_t<bare_ffmpeg_io_context_on_write_cb_t> on_write;
+
+  js_persistent_t<bare_ffmpeg_io_context_write_cb_t> on_write;
+  js_persistent_t<bare_ffmpeg_io_context_read_cb_t> on_read;
+  js_persistent_t<bare_ffmpeg_io_context_seek_cb_t> on_seek;
 } bare_ffmpeg_io_context_t;
 
 typedef struct {
@@ -102,9 +106,9 @@ typedef struct {
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static inline bool
-bad_timebase(const AVRational r) {
-  return r.den < 1 ||    // invalid denominator
-         av_q2d(r) == 0; // detect initial state: (0 / 1)
+bare_ffmpeg__bad_timebase(const AVRational r) {
+  return r.den < 1 ||    // Invalid denominator
+         av_q2d(r) == 0; // Initial state (0 / 1)
 }
 
 static void
@@ -125,24 +129,107 @@ bare_ffmpeg_log_set_level(js_env_t *, int32_t level) {
 }
 
 static int
-io_context_write_packet(void *opaque, const uint8_t *chunk, int len) {
+bare_ffmpeg__on_io_context_write(void *opaque, const uint8_t *buf, int len) {
+  int err;
+
+  auto context = static_cast<bare_ffmpeg_io_context_t *>(opaque);
+
+  auto env = context->env;
+
+  bare_ffmpeg_io_context_write_cb_t callback;
+  err = js_get_reference_value(env, context->on_write, callback);
+  assert(err == 0);
+
+  js_arraybuffer_t data;
+  err = js_create_arraybuffer(env, buf, static_cast<size_t>(len), data);
+  assert(err == 0);
+
+  js_typedarray_t<uint8_t> view;
+  err = js_create_typedarray(env, static_cast<size_t>(len), data, view);
+  assert(err == 0);
+
+
+  err = js_call_function(env, callback, view);
+  assert(err == 0);
+
+  return 0;
+}
+
+static int
+bare_ffmpeg__on_io_context_read(void *opaque, uint8_t *buf, int len) {
+  int err;
+
   auto context = reinterpret_cast<bare_ffmpeg_io_context_t *>(opaque);
+
   auto env = context->env;
 
-  bare_ffmpeg_io_context_on_write_cb_t callback;
+  bare_ffmpeg_io_context_read_cb_t callback;
+  err = js_get_reference_value(env, context->on_read, callback);
+  assert(err == 0);
 
-  int err = js_get_reference_value(env, context->on_write, callback);
+  js_arraybuffer_t arraybuffer;
+  err = js_create_external_arraybuffer(env, buf, static_cast<size_t>(len), arraybuffer);
   assert(err == 0);
 
-  js_arraybuffer_t data;
-  err = js_create_arraybuffer(env, chunk, static_cast<size_t>(len), data);
+  js_typedarray_t<uint8_t> view;
+  err = js_create_typedarray(env, static_cast<size_t>(len), arraybuffer, view);
+  assert(err == 0);
+
+  int32_t result;
+  int call_status = js_call_function<js_type_options_t{}, int32_t, js_typedarray_t<uint8_t>, int32_t>(env, callback, view, len, result);
 
+  err = js_detach_arraybuffer(env, arraybuffer);
   assert(err == 0);
 
-  // TODO: running on js-stack during avformat_write_header()
-  // trace other invocations, pray singlethread.
-  err = js_call_function(env, callback, data);
-  return err;
+  if (call_status < 0) return AVERROR(EIO);
+
+  if (result == 0) return AVERROR_EOF;
+
+  return result;
+}
+
+static int64_t
+bare_ffmpeg__on_io_context_seek(void *opaque, int64_t offset, int whence) {
+  int err;
+
+  auto context = reinterpret_cast<bare_ffmpeg_io_context_t *>(opaque);
+
+  auto env = context->env;
+
+  int64_t result;
+  std::string whence_str;
+  switch (whence) {
+  case AVSEEK_SIZE:
+    whence_str = "avseek_size";
+    break;
+  case AVSEEK_FORCE:
+    whence_str = "avseek_force";
+    break;
+  case SEEK_SET:
+    whence_str = "seek_set";
+    break;
+  case SEEK_CUR:
+    whence_str = "seek_cur";
+    break;
+  case SEEK_END:
+    whence_str = "seek_end";
+    break;
+  default:
+    whence_str = "unknown:" + std::to_string(whence);
+  }
+
+  bare_ffmpeg_io_context_seek_cb_t callback;
+  err = js_get_reference_value(env, context->on_seek, callback);
+  assert(err == 0);
+
+  err = js_call_function<js_type_options_t{}, int64_t, int64_t, std::string>(env, callback, offset, whence_str, result);
+  if (err < 0) return AVERROR(EIO); // read-error
+
+  if (result == -1) {
+    return AVERROR(ENOSYS); // seek-op not supported by IO
+  }
+
+  return result;
 }
 
 static js_arraybuffer_t
@@ -152,7 +239,9 @@ bare_ffmpeg_io_context_init(
   std::optional<js_arraybuffer_span_t> data,
   uint64_t offset,
   uint64_t len,
-  std::optional<bare_ffmpeg_io_context_on_write_cb_t> on_write
+  std::optional<bare_ffmpeg_io_context_write_cb_t> on_write,
+  std::optional<bare_ffmpeg_io_context_read_cb_t> on_read,
+  std::optional<bare_ffmpeg_io_context_seek_cb_t> on_seek
 ) {
   int err;
 
@@ -164,37 +253,46 @@ bare_ffmpeg_io_context_init(
 
   context->env = env;
 
-  int write_flag = 0;
+  int writable = 0;
+
   if (on_write) {
-    write_flag = 1;
+    writable = 1;
+
     err = js_create_reference(env, *on_write, context->on_write);
     assert(err == 0);
   }
 
-  size_t size = static_cast<size_t>(len);
-
-  uint8_t *io = NULL;
+  if (on_read) {
+    err = js_create_reference(env, *on_read, context->on_read);
+    assert(err == 0);
+  }
 
-  if (size) {
-    io = reinterpret_cast<uint8_t *>(av_malloc(size));
+  if (on_seek) {
+    err = js_create_reference(env, *on_seek, context->on_seek);
+    assert(err == 0);
   }
 
+  auto size = static_cast<size_t>(len);
+
+  auto io = reinterpret_cast<uint8_t *>(av_malloc(size));
+
   if (data) {
     memcpy(io, &data.value()[static_cast<size_t>(offset)], size);
   }
 
-  // TODO: for stream read support provide read/seek callbacks
-
   context->handle = avio_alloc_context(
     io,
     static_cast<int>(len),
-    write_flag,
+    writable,
     context,
-    NULL, // io_context_read_packet
-    io_context_write_packet,
-    NULL // io_context_seek
+    on_read ? bare_ffmpeg__on_io_context_read : nullptr,
+    on_write ? bare_ffmpeg__on_io_context_write : nullptr,
+    on_seek ? bare_ffmpeg__on_io_context_seek : nullptr
   );
-  assert(context->handle->opaque == context);
+
+  if (!on_seek) {
+    context->handle->seekable = 0;
+  }
 
   return handle;
 }
@@ -208,7 +306,10 @@ bare_ffmpeg_io_context_destroy(
   av_free(context->handle->buffer);
 
   avio_context_free(&context->handle);
+
   context->on_write.reset();
+  context->on_read.reset();
+  context->on_seek.reset();
 }
 
 static js_arraybuffer_t
@@ -415,7 +516,7 @@ bare_ffmpeg_format_context_get_streams(
 ) {
   int err;
 
-  uint32_t len = context->handle->nb_streams;
+  auto len = context->handle->nb_streams;
 
   js_array_t result;
   err = js_create_array(env, len, result);
@@ -497,15 +598,14 @@ bare_ffmpeg_format_context_write_header(
   js_env_t *env,
   js_receiver_t,
   js_arraybuffer_span_of_t<bare_ffmpeg_format_context_t, 1> context,
-  std::optional<js_arraybuffer_span_of_t<bare_ffmpeg_dictionary_t, 1>> muxer_options
+  std::optional<js_arraybuffer_span_of_t<bare_ffmpeg_dictionary_t, 1>> options
 ) {
   int err;
 
-  if (!muxer_options) {
-    err = avformat_write_header(context->handle, NULL);
+  if (options) {
+    err = avformat_write_header(context->handle, &options.value()->handle);
   } else {
-    auto dict = *muxer_options;
-    err = avformat_write_header(context->handle, &dict->handle);
+    err = avformat_write_header(context->handle, NULL);
   }
 
   if (err < 0) {
@@ -517,6 +617,7 @@ bare_ffmpeg_format_context_write_header(
 
   return err;
 }
+
 static void
 bare_ffmpeg_format_context_write_frame(
   js_env_t *env,
@@ -524,8 +625,9 @@ bare_ffmpeg_format_context_write_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_interleaved_write_frame(context->handle, packet->handle);
+  int err;
 
+  err = av_interleaved_write_frame(context->handle, packet->handle);
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -540,7 +642,9 @@ bare_ffmpeg_format_context_write_trailer(
   js_receiver_t,
   js_arraybuffer_span_of_t<bare_ffmpeg_format_context_t, 1> context
 ) {
-  int err = av_write_trailer(context->handle);
+  int err;
+
+  err = av_write_trailer(context->handle);
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -562,6 +666,7 @@ bare_ffmpeg_format_context_dump(
 
   for (int i = 0; i < context->handle->nb_streams; i++) {
     auto stream = context->handle->streams[i];
+
     av_log(NULL, AV_LOG_INFO, "  - stream=%i timebase=(%i / %i)\n", i, stream->time_base.num, stream->time_base.den);
   }
 }
@@ -770,7 +875,6 @@ bare_ffmpeg_codec_context_open(
   int err;
 
   err = avcodec_open2(context->handle, context->handle->codec, NULL);
-
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -800,7 +904,7 @@ bare_ffmpeg_codec_context_set_flags(
   context->handle->flags = value;
 }
 
-static int64_t
+static int
 bare_ffmpeg_frame_get_format(
   js_env_t *env,
   js_receiver_t,
@@ -1133,7 +1237,7 @@ bare_ffmpeg_codec_context_send_frame(
   int err;
 
   if (frame) {
-    err = avcodec_send_frame(context->handle, (*frame)->handle);
+    err = avcodec_send_frame(context->handle, frame.value()->handle);
   } else {
     err = avcodec_send_frame(context->handle, NULL); // End of stream
   }
@@ -1178,7 +1282,6 @@ bare_ffmpeg_codec_parameters_from_context(
   int err;
 
   err = avcodec_parameters_from_context(parameters->handle, context->handle);
-
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -1213,6 +1316,7 @@ bare_ffmpeg_codec_parameters_alloc(
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_codec_parameters_t *parameters;
   err = js_create_arraybuffer(env, parameters, handle);
   assert(err == 0);
@@ -1578,7 +1682,6 @@ bare_ffmpeg_codec_parameters_set_extra_data(
   int err;
 
   std::span<uint8_t> view;
-
   err = js_get_arraybuffer_info(env, buffer, view);
   assert(err == 0);
 
@@ -1592,6 +1695,7 @@ bare_ffmpeg_codec_parameters_set_extra_data(
   size_t min_size = len + AV_INPUT_BUFFER_PADDING_SIZE;
 
   parameters->handle->extradata = reinterpret_cast<uint8_t *>(av_malloc(min_size));
+
   memset(&parameters->handle->extradata[len], 0, AV_INPUT_BUFFER_PADDING_SIZE);
 
   memcpy(parameters->handle->extradata, &view[offset], len);
@@ -1797,25 +1901,6 @@ bare_ffmpeg_frame_set_height(
   frame->handle->height = height;
 }
 
-static int64_t
-bare_ffmpeg_frame_get_pixel_format(
-  js_env_t *env,
-  js_receiver_t,
-  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
-) {
-  return frame->handle->format;
-}
-
-static void
-bare_ffmpeg_frame_set_pixel_format(
-  js_env_t *env,
-  js_receiver_t,
-  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
-  int32_t format
-) {
-  frame->handle->format = static_cast<AVPixelFormat>(format);
-}
-
 static int32_t
 bare_ffmpeg_frame_get_nb_samples(
   js_env_t *env,
@@ -1909,6 +1994,7 @@ bare_ffmpeg_frame_get_time_base(
 
   return result;
 }
+
 static void
 bare_ffmpeg_frame_set_time_base(
   js_env_t *env,
@@ -2015,10 +2101,12 @@ bare_ffmpeg_image_read(
   uint64_t offset,
   js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
 ) {
+  int err;
+
   uint8_t *dst_data[4];
   int dst_linesize[4];
 
-  int err = av_image_fill_arrays(
+  auto len = av_image_fill_arrays(
     dst_data,
     dst_linesize,
     &data[offset],
@@ -2027,7 +2115,13 @@ bare_ffmpeg_image_read(
     height,
     align
   );
-  assert(err >= 0);
+
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
+    assert(err == 0);
+
+    throw js_pending_exception;
+  }
 
   av_image_copy(
     dst_data,
@@ -2174,6 +2268,15 @@ bare_ffmpeg_packet_unref(
   av_packet_unref(packet->handle);
 }
 
+static void
+bare_ffmpeg_packet_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
+) {
+  av_packet_free(&packet->handle);
+}
+
 static int32_t
 bare_ffmpeg_packet_get_stream_index(
   js_env_t *env,
@@ -2224,6 +2327,7 @@ bare_ffmpeg_packet_set_data(
   uint32_t len
 ) {
   int err;
+
   assert(offset + len <= data.size());
 
   av_packet_unref(packet->handle);
@@ -2329,11 +2433,11 @@ bare_ffmpeg_packet_rescale_ts(
   int32_t den
 ) {
   AVRational src = packet->handle->time_base;
-  AVRational dst = {.num = num, .den = den};
+  AVRational dst = {num, den};
 
   if (
-    bad_timebase(src) ||
-    bad_timebase(dst) ||
+    bare_ffmpeg__bad_timebase(src) ||
+    bare_ffmpeg__bad_timebase(dst) ||
     packet->handle->dts == AV_NOPTS_VALUE ||
     packet->handle->pts == AV_NOPTS_VALUE
   ) {
@@ -2439,7 +2543,9 @@ bare_ffmpeg_scaler_scale(
   int height,
   js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> target
 ) {
-  int err = av_frame_copy_props(target->handle, source->handle);
+  int err;
+
+  err = av_frame_copy_props(target->handle, source->handle);
   assert(err == 0);
 
   return sws_scale(
@@ -2503,6 +2609,7 @@ bare_ffmpeg_dictionary_get_entries(
   std::vector<std::tuple<const char *, const char *>> entries{};
 
   const AVDictionaryEntry *entry = nullptr;
+
   while ((entry = av_dict_iterate(dict->handle, entry))) {
     entries.emplace_back(entry->key, entry->value);
   }
@@ -2760,11 +2867,12 @@ bare_ffmpeg_audio_fifo_write(
 ) {
   int err;
 
-  int len = av_audio_fifo_write(fifo->handle, (void **) frame->handle->data, frame->handle->nb_samples);
+  auto 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;
   }
 
@@ -2781,11 +2889,12 @@ bare_ffmpeg_audio_fifo_read(
 ) {
   int err;
 
-  int len = av_audio_fifo_read(fifo->handle, (void **) frame->handle->data, nb_samples);
+  auto 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;
   }
 
@@ -2802,11 +2911,12 @@ bare_ffmpeg_audio_fifo_peek(
 ) {
   int err;
 
-  int len = av_audio_fifo_peek(fifo->handle, (void **) frame->handle->data, nb_samples);
+  auto 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;
   }
 
@@ -2822,11 +2932,12 @@ bare_ffmpeg_audio_fifo_drain(
 ) {
   int err;
 
-  int len = av_audio_fifo_drain(fifo->handle, nb_samples);
+  auto 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;
   }
 
@@ -2866,12 +2977,10 @@ bare_ffmpeg_rational_d2q(
   js_receiver_t,
   double num
 ) {
-  constexpr int safe_max = 1 << 26;
-
-  auto rational = av_d2q(num, safe_max);
-
   int err;
 
+  auto rational = av_d2q(num, 1 << 26);
+
   js_arraybuffer_t result;
 
   int32_t *data;
@@ -3018,8 +3127,6 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setFrameWidth", bare_ffmpeg_frame_set_width)
   V("getFrameHeight", bare_ffmpeg_frame_get_height)
   V("setFrameHeight", bare_ffmpeg_frame_set_height)
-  V("getFramePixelFormat", bare_ffmpeg_frame_get_pixel_format)
-  V("setFramePixelFormat", bare_ffmpeg_frame_set_pixel_format)
   V("getFrameFormat", bare_ffmpeg_frame_get_format)
   V("setFrameFormat", bare_ffmpeg_frame_set_format)
   V("getFrameChannelLayout", bare_ffmpeg_frame_get_channel_layout)
@@ -3045,6 +3152,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
 
   V("initPacket", bare_ffmpeg_packet_init)
   V("initPacketFromBuffer", bare_ffmpeg_packet_init_from_buffer)
+  V("destroyPacket", bare_ffmpeg_packet_destroy)
   V("unrefPacket", bare_ffmpeg_packet_unref)
   V("getPacketStreamIndex", bare_ffmpeg_packet_get_stream_index)
   V("setPacketStreamIndex", bare_ffmpeg_packet_set_stream_index)

package/cmake/ports/ffmpeg/port.cmake

@@ -285,6 +285,7 @@ if(CMAKE_HOST_WIN32)
   find_path(
     msys2
     NAMES msys2.exe
+    PATHS "C:/tools/msys64"
     REQUIRED
   )
 

package/lib/codec.js

@@ -51,7 +51,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

@@ -1,7 +1,6 @@
 const binding = require('../binding')
 const errors = require('./errors')
 
-// Helpers
 function makeTag(a, b, c, d) {
   return (
     a.charCodeAt(0) |
@@ -14,7 +13,6 @@ function makeTag(a, b, c, d) {
 module.exports = exports = {
   codecs: {
     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,
@@ -22,11 +20,7 @@ module.exports = exports = {
     MP3: binding.AV_CODEC_ID_MP3
   },
   tags: {
-    // Source Ref:
-    // https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/riff.c#L36
-    // https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/riff.c#L530
     MJPEG: makeTag('M', 'J', 'P', 'G'),
-    H264: makeTag('H', '2', '6', '4'),
     AV1: makeTag('A', 'V', '0', '1'),
     AAC: 0x00ff,
     FLAC: 0xf1ac,

package/lib/dictionary.js

@@ -1,6 +1,16 @@
 const binding = require('../binding')
 
 module.exports = class FFmpegDictionary {
+  static from(obj) {
+    const dictionary = new FFmpegDictionary()
+
+    for (const [key, value] of Object.entries(obj)) {
+      dictionary.set(key, value)
+    }
+
+    return dictionary
+  }
+
   constructor() {
     this._handle = binding.initDictionary()
   }

package/lib/frame.js

@@ -32,14 +32,6 @@ module.exports = class FFmpegFrame {
     binding.setFrameHeight(this._handle, value)
   }
 
-  get pixelFormat() {
-    return binding.getFramePixelFormat(this._handle)
-  }
-
-  set pixelFormat(value) {
-    binding.setFramePixelFormat(this._handle, value)
-  }
-
   get format() {
     return binding.getFrameFormat(this._handle)
   }
@@ -109,7 +101,6 @@ module.exports = class FFmpegFrame {
       __proto__: { constructor: FFmpegFrame },
       width: this.width,
       height: this.height,
-      pixelFormat: this.pixelFormat,
       format: this.format,
       channelLayout: this.channelLayout,
       nbSamples: this.nbSamples,

package/lib/io-context.js

@@ -16,15 +16,14 @@ module.exports = class FFmpegIOContext {
       buffer = Buffer.alloc(0)
     }
 
-    let onwrite
-
-    if (typeof opts.onwrite === 'function') {
-      onwrite = function (chunk) {
-        opts.onwrite(Buffer.from(chunk))
-      }
-    }
-
-    this._handle = binding.initIOContext(buffer, offset, len, onwrite)
+    this._handle = binding.initIOContext(
+      buffer,
+      offset,
+      len,
+      opts.onwrite,
+      opts.onread,
+      opts.onseek
+    )
   }
 
   destroy() {

package/lib/packet.js

@@ -15,7 +15,7 @@ module.exports = class FFmpegPacket {
   }
 
   destroy() {
-    binding.unrefPacket(this._handle)
+    binding.destroyPacket(this._handle)
     this._handle = null
   }
 

package/package.json

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