bare-ffmpeg 1.0.0-24 → 1.0.0-26

package/README.md

@@ -10,19 +10,59 @@ npm i bare-ffmpeg
 
 ### `IOContext`
 
-The `IOContext` API provides functionality to create input/output contexts for media files.
+The `IOContext` API provides functionality to create input/output contexts for media files with support for streaming and custom I/O operations.
 
 ```js
-const io = new ffmpeg.IOContext(buffer)
+const io = new ffmpeg.IOContext(buffer[, options])
 ```
 
 Parameters:
 
-- `buffer` (`Buffer`): The media data buffer
+- `buffer` (`Buffer` | `number`): The media data buffer or buffer size for streaming
+- `options` (`object`, optional): Configuration options
+  - `onread` (`function`): A function for refilling the buffer.
+  - `onwrite` (`function`): A function for writing the buffer contents.
+  - `onseek` (`function`): A function for seeking to specified byte position.
 
 **Returns**: A new `IOContext` instance
 
-Example:
+#### Constructor Options
+
+##### `onread(buffer, requestedLen)`
+
+Callback function called when FFmpeg needs to read data. For streaming scenarios where data is not available in a single buffer.
+
+Parameters:
+
+- `buffer` (`Buffer`): Buffer to fill with data
+- `requestedLen` (`number`): Number of bytes requested
+
+**Returns**: `number` - Number of bytes actually read, or 0 for EOF
+
+##### `onwrite(buffer)`
+
+Callback function called when FFmpeg needs to write data. For streaming output scenarios.
+
+Parameters:
+
+- `buffer` (`Buffer`): Buffer containing data to write
+
+**Returns**: `number` - Number of bytes written
+
+##### `onseek(offset, whence)`
+
+Callback function called when FFmpeg needs to seek within the data source.
+
+Parameters:
+
+- `offset` (`number`): Offset to seek to
+- `whence` (`number`): Seek mode (see `ffmpeg.constants.seek`)
+
+**Returns**: `number` - New position or file size for `AVSEEK_SIZE`
+
+#### Examples
+
+**Basic usage with buffer:**
 
 ```js
 const image = require('./fixtures/image/sample.jpeg', {
@@ -32,6 +72,43 @@ const io = new ffmpeg.IOContext(image)
 io.destroy()
 ```
 
+**Streaming with custom read callback:**
+
+```js
+const io = new ffmpeg.IOContext(4096, {
+  onread: (buffer) => {
+    const bytesToRead = Math.min(buffer.length, data.length - offset)
+    if (bytesToRead === 0) return 0
+
+    const chunk = data.subarray(offset, offset + bytesToRead)
+    buffer.set(chunk)
+    offset += bytesToRead
+    return bytesToRead
+  }
+})
+```
+
+**Streaming with seek support:**
+
+```js
+const io = new ffmpeg.IOContext(4096, {
+  onread: (buffer) => {
+    // ... read implementation
+  },
+  onseek: (offset, whence) => {
+    switch (whence) {
+      case ffmpeg.constants.seek.SIZE:
+        return data.length
+      case ffmpeg.constants.seek.SET:
+        offset = offset
+        return offset
+      default:
+        return -1
+    }
+  }
+})
+```
+
 #### Methods
 
 ##### `IOContext.destroy()`
@@ -675,6 +752,18 @@ Gets the stream index this packet belongs to.
 
 **Returns**: `number`
 
+##### `Packet.isKeyFrame`
+
+Get or set the key frame flag.
+
+**Returns**: `boolean`
+
+##### `Packet.sideData`
+
+Gets or sets the side data associated with the packet.
+
+**Returns**: `Array<SideData>`
+
 #### Methods
 
 ##### `Packet.unref()`
@@ -689,6 +778,67 @@ Destroys the `Packet` and frees all associated resources. Automatically called w
 
 **Returns**: `void`
 
+### `SideData`
+
+The `SideData` API provides functionality to handle side data associated with packets. Side data contains additional metadata that may be useful for specific codecs or processing.
+
+```js
+const sideData = new ffmpeg.Packet.SideData(handle, options)
+```
+
+Parameters:
+
+- `handle` (`ArrayBuffer`): Internal side data handle
+- `options` (`object`, optional): Configuration options
+  - `type` (`number`): The side data type
+  - `data` (`Buffer`): The side data buffer
+
+**Returns**: A new `SideData` instance
+
+#### Static Methods
+
+##### `SideData.fromData(data, type)`
+
+Creates a new `SideData` instance from data and type.
+
+Parameters:
+
+- `data` (`Buffer`): The side data buffer
+- `type` (`number`): The side data type constant
+
+**Returns**: A new `SideData` instance
+
+#### Properties
+
+##### `SideData.type`
+
+Gets the side data type.
+
+**Returns**: `number`
+
+##### `SideData.name`
+
+Gets the human-readable name of the side data type.
+
+**Returns**: `string`
+
+##### `SideData.data`
+
+Gets the side data buffer.
+
+**Returns**: `Buffer`
+
+#### Example
+
+```js
+const packet = new ffmpeg.Packet()
+const sideData = ffmpeg.Packet.SideData.fromData(
+  Buffer.from('metadata'),
+  ffmpeg.constants.packetSideDataType.NEW_EXTRADATA
+)
+packet.sideData = [sideData]
+```
+
 ### `Image`
 
 The `Image` API provides functionality to create and manage image buffers.

package/binding.cc

@@ -35,7 +35,7 @@ extern "C" {
 
 using bare_ffmpeg_io_context_write_cb_t = js_function_t<void, js_arraybuffer_t>;
 using bare_ffmpeg_io_context_read_cb_t = js_function_t<int32_t, js_arraybuffer_t, int32_t>;
-using bare_ffmpeg_io_context_seek_cb_t = js_function_t<int64_t, int64_t, std::string>;
+using bare_ffmpeg_io_context_seek_cb_t = js_function_t<int64_t, int64_t, int>;
 
 typedef struct {
   AVIOContext *handle;
@@ -103,6 +103,10 @@ typedef struct {
   AVAudioFifo *handle;
 } bare_ffmpeg_audio_fifo_t;
 
+typedef struct {
+  AVPacketSideData *handle;
+} bare_ffmpeg_side_data_t;
+
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static inline bool
@@ -145,7 +149,8 @@ bare_ffmpeg__on_io_context_write(void *opaque, const uint8_t *buf, int len) {
   assert(err == 0);
 
   err = js_call_function(env, callback, data);
-  assert(err == 0);
+
+  if (err < 0) return AVERROR(EIO);
 
   return 0;
 }
@@ -181,39 +186,21 @@ bare_ffmpeg__on_io_context_read(void *opaque, uint8_t *buf, int len) {
 
 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);
+  int 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);
+  err = js_call_function<
+    js_type_options_t{},
+    int64_t,
+    int64_t,
+    int>(
+    env, callback, offset, whence, result
+  );
   if (err < 0) return AVERROR(EIO); // read-error
 
   if (result == -1) {
@@ -391,6 +378,12 @@ bare_ffmpeg_format_context_open_input_with_io(
   if (err < 0) {
     avformat_free_context(context->handle);
 
+    bool is_exception_pending;
+    err = js_is_exception_pending(env, &is_exception_pending);
+    assert(err == 0);
+
+    if (is_exception_pending) throw js_pending_exception;
+
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
 
@@ -828,6 +821,11 @@ 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 js_arraybuffer_t
 bare_ffmpeg_codec_context_init(
   js_env_t *env,
@@ -895,6 +893,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,
@@ -1820,6 +1861,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;
@@ -2329,6 +2389,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 *,
@@ -2338,6 +2454,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,
@@ -2480,6 +2610,40 @@ bare_ffmpeg_packet_set_flags(
   packet->handle->flags = value;
 }
 
+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,
@@ -3031,6 +3195,7 @@ 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("initCodecContext", bare_ffmpeg_codec_context_init)
   V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
@@ -3056,6 +3221,8 @@ 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("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
   V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
@@ -3110,6 +3277,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)
@@ -3149,7 +3318,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)
@@ -3162,6 +3334,10 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("getPacketFlags", bare_ffmpeg_packet_get_flags)
   V("setPacketFlags", bare_ffmpeg_packet_set_flags)
 
+  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)
   V("scaleScaler", bare_ffmpeg_scaler_scale)
@@ -3421,6 +3597,56 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
 
   // Levels
   V(AV_LEVEL_UNKNOWN)
+
+  // SEEK
+  V(AVSEEK_SIZE)
+  V(AVSEEK_FORCE)
+  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)
+
 #undef V
 
   return exports;

package/cmake/ports/ffmpeg/port.cmake

@@ -332,7 +332,7 @@ list(APPEND env
 )
 
 declare_port(
-  "github:FFmpeg/FFmpeg#n7.1.1"
+  "github:FFmpeg/FFmpeg#n8.0"
   ffmpeg
   AUTOTOOLS
   DEPENDS ${depends}

package/lib/codec-context.js

@@ -107,6 +107,19 @@ module.exports = class FFmpegCodecContext {
     binding.setCodecContextFlags(this._handle, value)
   }
 
+  get extraData() {
+    return Buffer.from(binding.getCodecContextExtraData(this._handle))
+  }
+
+  set extraData(value) {
+    binding.setCodecContextExtraData(
+      this._handle,
+      value.buffer,
+      value.byteOffset,
+      value.byteLength
+    )
+  }
+
   open(options) {
     if (this._opened) return
     this._opened = true
@@ -155,7 +168,8 @@ module.exports = class FFmpegCodecContext {
       sampleRate: this.sampleRate,
       timeBase: this.timeBase,
       channelLayout: this.channelLayout,
-      gopSize: this.gopSize
+      gopSize: this.gopSize,
+      extraData: this.extraData
     }
   }
 }

package/lib/codec-parameters.js

@@ -72,6 +72,14 @@ module.exports = class FFmpegCodecParameters {
     )
   }
 
+  get frameSize() {
+    return binding.getCodecParametersFrameSize(this._handle)
+  }
+
+  set frameSize(size) {
+    binding.setCodecParametersFrameSize(this._handle, size)
+  }
+
   get videoDelay() {
     return binding.getCodecParametersVideoDelay(this._handle)
   }

package/lib/constants.js

@@ -133,6 +133,57 @@ module.exports = exports = {
     NOFILE: binding.AVFMT_NOFILE,
     NEEDNUMBER: binding.AVFMT_NEEDNUMBER,
     NOTIMESTAMPS: binding.AVFMT_NOTIMESTAMPS
+  },
+  seek: {
+    SIZE: binding.AVSEEK_SIZE,
+    FORCE: binding.AVSEEK_FORCE,
+    CUR: binding.SEEK_CUR,
+    SET: binding.SEEK_SET,
+    END: binding.SEEK_END
+  },
+  packetSideDataType: {
+    PALETTE: binding.AV_PKT_DATA_PALETTE,
+    NEW_EXTRADATA: binding.AV_PKT_DATA_NEW_EXTRADATA,
+    PARAM_CHANGE: binding.AV_PKT_DATA_PARAM_CHANGE,
+    H263_MB_INFO: binding.AV_PKT_DATA_H263_MB_INFO,
+    REPLAYGAIN: binding.AV_PKT_DATA_REPLAYGAIN,
+    DISPLAYMATRIX: binding.AV_PKT_DATA_DISPLAYMATRIX,
+    STEREO3D: binding.AV_PKT_DATA_STEREO3D,
+    AUDIO_SERVICE_TYPE: binding.AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+    QUALITY_STATS: binding.AV_PKT_DATA_QUALITY_STATS,
+    FALLBACK_TRACK: binding.AV_PKT_DATA_FALLBACK_TRACK,
+    CPB_PROPERTIES: binding.AV_PKT_DATA_CPB_PROPERTIES,
+    SKIP_SAMPLES: binding.AV_PKT_DATA_SKIP_SAMPLES,
+    JP_DUALMONO: binding.AV_PKT_DATA_JP_DUALMONO,
+    STRINGS_METADATA: binding.AV_PKT_DATA_STRINGS_METADATA,
+    SUBTITLE_POSITION: binding.AV_PKT_DATA_SUBTITLE_POSITION,
+    MATROSKA_BLOCKADDITIONAL: binding.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
+    WEBVTT_IDENTIFIER: binding.AV_PKT_DATA_WEBVTT_IDENTIFIER,
+    WEBVTT_SETTINGS: binding.AV_PKT_DATA_WEBVTT_SETTINGS,
+    METADATA_UPDATE: binding.AV_PKT_DATA_METADATA_UPDATE,
+    MPEGTS_STREAM_ID: binding.AV_PKT_DATA_MPEGTS_STREAM_ID,
+    MASTERING_DISPLAY_METADATA: binding.AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+    SPHERICAL: binding.AV_PKT_DATA_SPHERICAL,
+    CONTENT_LIGHT_LEVEL: binding.AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+    A53_CC: binding.AV_PKT_DATA_A53_CC,
+    ENCRYPTION_INIT_INFO: binding.AV_PKT_DATA_ENCRYPTION_INIT_INFO,
+    ENCRYPTION_INFO: binding.AV_PKT_DATA_ENCRYPTION_INFO,
+    AFD: binding.AV_PKT_DATA_AFD,
+    PRFT: binding.AV_PKT_DATA_PRFT,
+    ICC_PROFILE: binding.AV_PKT_DATA_ICC_PROFILE,
+    DOVI_CONF: binding.AV_PKT_DATA_DOVI_CONF,
+    S12M_TIMECODE: binding.AV_PKT_DATA_S12M_TIMECODE,
+    DYNAMIC_HDR10_PLUS: binding.AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
+    IAMF_MIX_GAIN_PARAM: binding.AV_PKT_DATA_IAMF_MIX_GAIN_PARAM,
+    IAMF_DEMIXING_INFO_PARAM: binding.AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM,
+    IAMF_RECON_GAIN_INFO_PARAM: binding.AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM,
+    AMBIENT_VIEWING_ENVIRONMENT:
+      binding.AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
+    FRAME_CROPPING: binding.AV_PKT_DATA_FRAME_CROPPING,
+    LCEVC: binding.AV_PKT_DATA_LCEVC,
+    '3D_REFERENCE_DISPLAYS': binding.AV_PKT_DATA_3D_REFERENCE_DISPLAYS,
+    RTCP_SR: binding.AV_PKT_DATA_RTCP_SR,
+    NB: binding.AV_PKT_DATA_NB
   }
 }
 
@@ -183,3 +234,7 @@ exports.toChannelLayout = function toChannelLayout(layout) {
     `Channel layout must be a number or string. Received ${typeof layout} (${layout})`
   )
 }
+
+exports.getSampleFormatName = function (sampleFormat) {
+  return binding.getSampleFormatNameByID(sampleFormat)
+}

package/lib/packet.js

@@ -1,6 +1,42 @@
 const binding = require('../binding')
 const Rational = require('./rational')
 
+class SideData {
+  constructor(handle, opts = {}) {
+    this._handle = handle
+    this._type = opts.type || null
+    this._data = opts.data || null
+  }
+
+  static fromData(data, type) {
+    return new SideData(null, { data, type })
+  }
+
+  get type() {
+    if (this._type) return this._type
+    return binding.getSideDataType(this._handle)
+  }
+
+  get name() {
+    if (!this._handle) return null
+    return binding.getSideDataName(this._handle)
+  }
+
+  get data() {
+    if (this._data) return this._data
+    return Buffer.from(binding.getSideDataBuffer(this._handle))
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: SideData },
+      type: this.type,
+      name: this.name,
+      data: this.data
+    }
+  }
+}
+
 module.exports = class FFmpegPacket {
   constructor(buffer) {
     if (buffer) {
@@ -44,10 +80,31 @@ module.exports = class FFmpegPacket {
     )
   }
 
+  get sideData() {
+    const handles = binding.getPacketSideData(this._handle)
+    return handles.map((handle) => new SideData(handle))
+  }
+
+  set sideData(values) {
+    binding.setPacketSideData(
+      this._handle,
+      values.map((value) => ({
+        buffer: value.data.buffer,
+        offset: value.data.byteOffset,
+        length: value.data.byteLength,
+        type: value.type
+      }))
+    )
+  }
+
   get isKeyframe() {
     return binding.isPacketKeyframe(this._handle)
   }
 
+  set isKeyframe(value) {
+    binding.setPacketIsKeyFrame(this._handle, value)
+  }
+
   get dts() {
     return binding.getPacketDTS(this._handle)
   }
@@ -115,3 +172,5 @@ module.exports = class FFmpegPacket {
     this.destroy()
   }
 }
+
+module.exports.SideData = SideData

package/package.json

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