bare-ffmpeg 1.0.0-20 → 1.0.0-21

package/README.md

@@ -40,6 +40,74 @@ Destroys the `IOContext` and frees all associated resources. Automatically calle
 
 **Returns**: `void`
 
+### `Dictionary`
+
+The `Dictionary` API provides functionality to store and retrieve key-value pairs, commonly used for passing options to various FFmpeg components.
+
+```js
+const dict = new ffmpeg.Dictionary()
+```
+
+**Returns**: A new `Dictionary` instance
+
+Example:
+
+```js
+const dict = new ffmpeg.Dictionary()
+dict.set('video_codec', 'h264')
+dict.set('audio_codec', 'aac')
+dict.set('bitrate', '1000k')
+```
+
+#### Methods
+
+##### `Dictionary.set(key, value)`
+
+Sets a key-value pair in the dictionary. Non-string values are automatically converted to strings.
+
+Parameters:
+
+- `key` (`string`): The dictionary key
+- `value` (`string` | `number`): The value to store
+
+**Returns**: `void`
+
+##### `Dictionary.get(key)`
+
+Retrieves a value from the dictionary by key.
+
+Parameters:
+
+- `key` (`string`): The dictionary key
+
+**Returns**: `string` value or `null` if the key doesn't exist
+
+##### `Dictionary.entries()`
+
+Retrieves all keys and values.
+
+**Returns**: `Array<[string, string]>` value
+
+##### `Dictionary.destroy()`
+
+Destroys the `Dictionary` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
+#### Iteration
+
+The `Dictionary` class implements the iterator protocol, allowing you to iterate over all key-value pairs:
+
+```js
+const dict = new ffmpeg.Dictionary()
+dict.set('foo', 'bar')
+dict.set('baz', 'qux')
+
+for (const [key, value] of dict) {
+  console.log(`${key}: ${value}`)
+}
+```
+
 ### `FormatContext`
 
 The `FormatContext` API provides the base functionality for reading and writing media files.
@@ -400,6 +468,45 @@ Gets or sets the channel layout, see `ffmpeg.constants.channelLayouts`
 
 **Returns**: `ChannelLayout`
 
+##### `CodecParameters.blockAlign`
+
+Audio only. The number of bytes per coded audio frame, required by some
+formats.
+
+Corresponds to `nBlockAlign` in `WAVEFORMATEX`.
+
+**Returns**: `number`
+
+##### `CodecParameters.initalPadding`
+
+Audio only. The amount of padding (in samples) inserted by the encoder at the beginning of the audio. I.e. this number of leading decoded samples must be discarded by the caller to get the original audio without leading padding.
+
+**Returns**: `number`
+
+##### `CodecParameters.trailingPadding`
+
+Audio only. The amount of padding (in samples) appended by the encoder to the end of the audio. I.e. this number of decoded samples must be discarded by the caller from the end of the stream to get the original audio without any trailing padding.
+
+##### `CodecParameters.seekPreroll`
+
+Audio only. Number of samples to skip after a discontinuity.
+
+**Returns**: `number`
+
+##### `CodecParameters.sampleAspectRatio`
+
+Video only. The aspect ratio (width / height) which a single pixel should have when displayed.
+
+When the aspect ratio is unknown / undefined, the numerator should be set to 0 (the denominator may have any value).
+
+**Returns**: `number`
+
+##### `CodecParameters.videoDelay`
+
+Video only. Number of delayed frames.
+
+**Returns**: `number`
+
 #### Methods
 
 ##### `CodecParameters.fromContext(context)`

package/binding.cc

@@ -3,6 +3,8 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+#include <tuple>
+#include <vector>
 
 #include <bare.h>
 #include <js.h>
@@ -504,11 +506,6 @@ bare_ffmpeg_format_context_write_header(
   } else {
     auto dict = *muxer_options;
     err = avformat_write_header(context->handle, &dict->handle);
-
-    const AVDictionaryEntry *option = NULL;
-    while ((option = av_dict_iterate(dict->handle, option))) {
-      av_log(context->handle, AV_LOG_WARNING, "Ignored option key='%s' value='%s'\n", option->key, option->value);
-    }
   }
 
   if (err < 0) {
@@ -1208,6 +1205,32 @@ bare_ffmpeg_codec_parameters_to_context(
   }
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_codec_parameters_alloc(
+  js_env_t *env,
+  js_receiver_t
+) {
+  int err;
+
+  js_arraybuffer_t handle;
+  bare_ffmpeg_codec_parameters_t *parameters;
+  err = js_create_arraybuffer(env, parameters, handle);
+  assert(err == 0);
+
+  parameters->handle = avcodec_parameters_alloc();
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_codec_parameters_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  avcodec_parameters_free(&parameters->handle);
+}
+
 static int64_t
 bare_ffmpeg_codec_parameters_get_bit_rate(
   js_env_t *env,
@@ -1576,6 +1599,132 @@ bare_ffmpeg_codec_parameters_set_extra_data(
   parameters->handle->extradata_size = static_cast<int>(len);
 }
 
+static int
+bare_ffmpeg_codec_parameters_get_block_align(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->block_align;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_block_align(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int block_align
+) {
+  parameters->handle->block_align = block_align;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_initial_padding(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->initial_padding;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_initial_padding(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int initial_padding
+) {
+  parameters->handle->initial_padding = initial_padding;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_trailing_padding(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->trailing_padding;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_trailing_padding(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int trailing_padding
+) {
+  parameters->handle->trailing_padding = trailing_padding;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_seek_preroll(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->seek_preroll;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_seek_preroll(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int seek_preroll
+) {
+  parameters->handle->seek_preroll = seek_preroll;
+}
+
+static js_arraybuffer_t
+bare_ffmpeg_codec_parameters_get_sample_aspect_ratio(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  int err;
+  js_arraybuffer_t result;
+
+  int32_t *data;
+  err = js_create_arraybuffer(env, 2, data, result);
+  assert(err == 0);
+
+  data[0] = parameters->handle->sample_aspect_ratio.num;
+  data[1] = parameters->handle->sample_aspect_ratio.den;
+
+  return result;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_sample_aspect_ratio(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int num,
+  int den
+) {
+  parameters->handle->sample_aspect_ratio.num = num;
+  parameters->handle->sample_aspect_ratio.den = den;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_video_delay(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->video_delay;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_video_delay(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int delay
+) {
+  parameters->handle->video_delay = delay;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_frame_init(js_env_t *env, js_receiver_t) {
   int err;
@@ -2345,6 +2494,22 @@ bare_ffmpeg_dictionary_set_entry(
   assert(err == 0);
 }
 
+static std::vector<std::tuple<const char *, const char *>>
+bare_ffmpeg_dictionary_get_entries(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_dictionary_t, 1> dict
+) {
+  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);
+  }
+
+  return entries;
+}
+
 static std::optional<std::string>
 bare_ffmpeg_dictionary_get_entry(
   js_env_t *env,
@@ -2799,6 +2964,8 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
 
   V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
   V("codecParametersToContext", bare_ffmpeg_codec_parameters_to_context)
+  V("allocCodecParameters", bare_ffmpeg_codec_parameters_alloc)
+  V("destroyCodecParameters", bare_ffmpeg_codec_parameters_destroy)
   V("getCodecParametersBitRate", bare_ffmpeg_codec_parameters_get_bit_rate)
   V("setCodecParametersBitRate", bare_ffmpeg_codec_parameters_set_bit_rate)
   V("getCodecParametersBitsPerCodedSample", bare_ffmpeg_codec_parameters_get_bits_per_coded_sample)
@@ -2831,6 +2998,18 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setCodecParametersHeight", bare_ffmpeg_codec_parameters_set_height)
   V("getCodecParametersExtraData", bare_ffmpeg_codec_parameters_get_extra_data)
   V("setCodecParametersExtraData", bare_ffmpeg_codec_parameters_set_extra_data)
+  V("getCodecParametersBlockAlign", bare_ffmpeg_codec_parameters_get_block_align)
+  V("setCodecParametersBlockAlign", bare_ffmpeg_codec_parameters_set_block_align)
+  V("getCodecParametersInitialPadding", bare_ffmpeg_codec_parameters_get_initial_padding)
+  V("setCodecParametersInitialPadding", bare_ffmpeg_codec_parameters_set_initial_padding)
+  V("getCodecParametersTrailingPadding", bare_ffmpeg_codec_parameters_get_trailing_padding)
+  V("setCodecParametersTrailingPadding", bare_ffmpeg_codec_parameters_set_trailing_padding)
+  V("getCodecParametersSeekPreroll", bare_ffmpeg_codec_parameters_get_seek_preroll)
+  V("setCodecParametersSeekPreroll", bare_ffmpeg_codec_parameters_set_seek_preroll)
+  V("getCodecParametersSampleAspectRatio", bare_ffmpeg_codec_parameters_get_sample_aspect_ratio)
+  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("initFrame", bare_ffmpeg_frame_init)
   V("destroyFrame", bare_ffmpeg_frame_destroy)
@@ -2892,6 +3071,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("destroyDictionary", bare_ffmpeg_dictionary_destroy)
   V("getDictionaryEntry", bare_ffmpeg_dictionary_get_entry)
   V("setDictionaryEntry", bare_ffmpeg_dictionary_set_entry)
+  V("getDictionaryEntries", bare_ffmpeg_dictionary_get_entries)
 
   V("initResampler", bare_ffmpeg_resampler_init)
   V("destroyResampler", bare_ffmpeg_resampler_destroy)

package/lib/codec-parameters.js

@@ -3,10 +3,13 @@ const ChannelLayout = require('./channel-layout')
 const Rational = require('./rational')
 
 module.exports = class FFmpegCodecParameters {
-  constructor(handle) {
+  constructor(handle, owned = false) {
     this._handle = handle
+    this._owned = owned
   }
 
+  // Getters, Setters
+
   get bitRate() {
     return binding.getCodecParametersBitRate(this._handle)
   }
@@ -39,6 +42,21 @@ module.exports = class FFmpegCodecParameters {
     binding.setCodecParametersSampleRate(this._handle, rate)
   }
 
+  get sampleAspectRatio() {
+    const view = new Int32Array(
+      binding.getCodecParametersSampleAspectRatio(this._handle)
+    )
+    return new Rational(view[0], view[1])
+  }
+
+  set sampleAspectRatio(ratio) {
+    binding.setCodecParametersSampleAspectRatio(
+      this._handle,
+      ratio.numerator,
+      ratio.denominator
+    )
+  }
+
   get frameRate() {
     const view = new Int32Array(
       binding.getCodecParametersFramerate(this._handle)
@@ -54,6 +72,14 @@ module.exports = class FFmpegCodecParameters {
     )
   }
 
+  get videoDelay() {
+    return binding.getCodecParametersVideoDelay(this._handle)
+  }
+
+  set videoDelay(delay) {
+    binding.setCodecParametersVideoDelay(this._handle, delay)
+  }
+
   get nbChannels() {
     return binding.getCodecParametersNbChannels(this._handle)
   }
@@ -152,6 +178,40 @@ module.exports = class FFmpegCodecParameters {
     )
   }
 
+  get blockAlign() {
+    return binding.getCodecParametersBlockAlign(this._handle)
+  }
+
+  set blockAlign(value) {
+    binding.setCodecParametersBlockAlign(this._handle, value)
+  }
+
+  get initialPadding() {
+    return binding.getCodecParametersInitialPadding(this._handle)
+  }
+
+  set initialPadding(value) {
+    binding.setCodecParametersInitialPadding(this._handle, value)
+  }
+
+  get trailingPadding() {
+    return binding.getCodecParametersTrailingPadding(this._handle)
+  }
+
+  set trailingPadding(value) {
+    binding.setCodecParametersTrailingPadding(this._handle, value)
+  }
+
+  get seekPreroll() {
+    return binding.getCodecParametersSeekPreroll(this._handle)
+  }
+
+  set seekPreroll(value) {
+    binding.setCodecParametersSeekPreroll(this._handle, value)
+  }
+
+  // Methods
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -160,6 +220,14 @@ module.exports = class FFmpegCodecParameters {
     binding.codecParametersToContext(context._handle, this._handle)
   }
 
+  destroy() {
+    if (this._owned) binding.destroyCodecParameters(this._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
   // TODO: add other props
   [Symbol.for('bare.inspect')]() {
     return {
@@ -178,7 +246,15 @@ module.exports = class FFmpegCodecParameters {
       nbChannels: this.nbChannels,
       channelLayout: this.channelLayout,
       frameRate: this.frameRate,
-      extraData: this.extraData
+      extraData: this.extraData,
+      blockAlign: this.blockAlign,
+      initialPadding: this.initialPadding,
+      trailingPadding: this.trailingPadding,
+      seekPreroll: this.seekPreroll
     }
   }
+
+  static alloc() {
+    return new FFmpegCodecParameters(binding.allocCodecParameters(), true)
+  }
 }

package/lib/dictionary.js

@@ -22,6 +22,14 @@ module.exports = class FFmpegDictionary {
     binding.setDictionaryEntry(this._handle, key, value)
   }
 
+  entries() {
+    return binding.getDictionaryEntries(this._handle)
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.entries()
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }

package/package.json

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