bare-ffmpeg 1.0.0-13 → 1.0.0-15

package/README.md

@@ -573,6 +573,16 @@ Parameters:
 
 **Returns**: void
 
+##### `Image.read(frame)`
+
+Reads image data from a frame into the image buffer.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to read from
+
+**Returns**: `void`
+
 ##### `Image.lineSize([plane])`
 
 Gets the line size for a specific plane.
@@ -803,6 +813,98 @@ Destroys the `Scaler` and frees all associated resources. Automatically called w
 
 **Returns**: `void`
 
+### `AudioFIFO`
+
+The `AudioFIFO` API provides a first in first out buffer for audio samples. This is useful for buffering audio data between different processing stages.
+
+```js
+const fifo = new ffmpeg.AudioFIFO(sampleFormat, channels, nbSamples)
+```
+
+Parameters:
+
+- `sampleFormat` (`number` | `string`): The audio sample format
+- `channels` (`number`): Number of audio channels
+- `nbSamples` (`number`): Initial buffer size in samples
+
+**Returns**: A new `AudioFIFO` instance
+
+Example:
+
+```js
+const fifo = new ffmpeg.AudioFIFO(ffmpeg.constants.sampleFormats.S16, 2, 1024)
+```
+
+#### Properties
+
+##### `AudioFIFO.size`
+
+Gets the number of samples currently in the FIFO.
+
+**Returns**: `number`
+
+##### `AudioFIFO.space`
+
+Gets the number of samples that can be written to the FIFO.
+
+**Returns**: `number`
+
+#### Methods
+
+##### `AudioFIFO.write(frame)`
+
+Writes samples from a frame to the FIFO. The FIFO will automatically grow if needed.
+
+Parameters:
+
+- `frame` (`Frame`): The audio frame containing samples to write
+
+**Returns**: `number` of samples written
+
+##### `AudioFIFO.read(frame, nbSamples)`
+
+Reads samples from the FIFO into a frame.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to read samples into
+- `nbSamples` (`number`): Number of samples to read
+
+**Returns**: `number` of samples actually read
+
+##### `AudioFIFO.peek(frame, nbSamples)`
+
+Reads samples from the FIFO without removing them.
+
+Parameters:
+
+- `frame` (`Frame`): The frame to read samples into
+- `nbSamples` (`number`): Number of samples to peek
+
+**Returns**: `number` of samples peeked
+
+##### `AudioFIFO.drain(nbSamples)`
+
+Removes samples from the FIFO without reading them.
+
+Parameters:
+
+- `nbSamples` (`number`): Number of samples to drain
+
+**Returns**: `void`
+
+##### `AudioFIFO.reset()`
+
+Resets the FIFO to empty state.
+
+**Returns**: `void`
+
+##### `AudioFIFO.destroy()`
+
+Destroys the `AudioFIFO` and frees all associated resources. Automatically called when the object is managed by a `using` declaration.
+
+**Returns**: `void`
+
 ## License
 
 Apache-2.0

package/binding.cc

@@ -16,6 +16,7 @@ extern "C" {
 #include <libavdevice/avdevice.h>
 #include <libavformat/avformat.h>
 #include <libavformat/avio.h>
+#include <libavutil/audio_fifo.h>
 #include <libavutil/channel_layout.h>
 #include <libavutil/dict.h>
 #include <libavutil/error.h>
@@ -86,11 +87,16 @@ typedef struct {
   struct SwrContext *handle;
 } bare_ffmpeg_resampler_t;
 
+typedef struct {
+  AVAudioFifo *handle;
+} bare_ffmpeg_audio_fifo_t;
+
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static void
 bare_ffmpeg__on_init(void) {
   av_log_set_level(AV_LOG_ERROR);
+
   avdevice_register_all();
 }
 
@@ -117,8 +123,7 @@ bare_ffmpeg_io_context_init(
   else {
     io = reinterpret_cast<uint8_t *>(av_malloc(size));
 
-    size_t off = static_cast<size_t>(offset);
-    memcpy(io, &data[off], size);
+    memcpy(io, &data[static_cast<size_t>(offset)], size);
   }
 
   context->handle = avio_alloc_context(io, static_cast<int>(len), 0, NULL, NULL, NULL, NULL);
@@ -128,8 +133,13 @@ bare_ffmpeg_io_context_init(
 }
 
 static void
-bare_ffmpeg_io_context_destroy(js_env_t *env, js_receiver_t, js_arraybuffer_span_of_t<bare_ffmpeg_io_context_t, 1> context) {
+bare_ffmpeg_io_context_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_io_context_t, 1> context
+) {
   av_free(context->handle->buffer);
+
   avio_context_free(&context->handle);
 }
 
@@ -147,6 +157,7 @@ bare_ffmpeg_output_format_init(js_env_t *env, js_receiver_t, std::string name) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_output_format_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -161,6 +172,7 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_receiver_t, std::string name) {
   int err;
 
   const AVInputFormat *format = av_find_input_format(name.c_str());
+
   if (format == NULL) {
     err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name.c_str());
     assert(err == 0);
@@ -169,6 +181,7 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_receiver_t, std::string name) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_input_format_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -280,6 +293,7 @@ bare_ffmpeg_format_context_open_output(
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_format_context_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -344,11 +358,11 @@ bare_ffmpeg_format_context_get_best_stream_index(
   js_arraybuffer_span_of_t<bare_ffmpeg_format_context_t, 1> context,
   int32_t type
 ) {
-  int best_stream = av_find_best_stream(context->handle, static_cast<AVMediaType>(type), -1, -1, NULL, 0);
+  auto i = av_find_best_stream(context->handle, static_cast<AVMediaType>(type), -1, -1, NULL, 0);
 
-  if (best_stream < 0) best_stream = -1;
+  if (i < 0) i = -1;
 
-  return best_stream;
+  return i;
 }
 
 static js_arraybuffer_t
@@ -361,19 +375,13 @@ bare_ffmpeg_format_context_create_stream(
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_stream_t *stream;
   err = js_create_arraybuffer(env, stream, handle);
   assert(err == 0);
 
   stream->handle = avformat_new_stream(context->handle, codec->handle);
 
-  if (stream->handle == NULL) {
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
-
-    throw js_pending_exception;
-  }
-
   return handle;
 }
 
@@ -384,9 +392,11 @@ bare_ffmpeg_format_context_read_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_packet_unref(packet->handle);
 
-  int err = av_read_frame(context->handle, packet->handle);
+  err = av_read_frame(context->handle, packet->handle);
   if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
@@ -439,6 +449,7 @@ bare_ffmpeg_find_decoder_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_codec_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -462,6 +473,7 @@ bare_ffmpeg_find_encoder_by_id(js_env_t *env, js_receiver_t, uint32_t id) {
   }
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_codec_t *context;
   err = js_create_arraybuffer(env, context, handle);
   assert(err == 0);
@@ -566,6 +578,7 @@ bare_ffmpeg_frame_set_channel_layout(
   js_arraybuffer_span_of_t<bare_ffmpeg_channel_layout_t, 1> layout
 ) {
   int err;
+
   err = av_channel_layout_copy(&frame->handle->ch_layout, &layout->handle);
   assert(err == 0);
 }
@@ -672,10 +685,12 @@ bare_ffmpeg_codec_context_get_time_base(
   js_receiver_t,
   js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
 ) {
+  int err;
+
   js_arraybuffer_t result;
-  int32_t *data;
 
-  int err = js_create_arraybuffer(env, data, result);
+  int32_t *data;
+  err = js_create_arraybuffer(env, 2, data, result);
   assert(err == 0);
 
   data[0] = context->handle->time_base.num;
@@ -724,6 +739,7 @@ bare_ffmpeg_codec_context_set_channel_layout(
   js_arraybuffer_span_of_t<bare_ffmpeg_channel_layout_t, 1> layout
 ) {
   int err;
+
   err = av_channel_layout_copy(&context->handle->ch_layout, &layout->handle);
   assert(err == 0);
 }
@@ -747,6 +763,25 @@ bare_ffmpeg_codec_context_set_sample_rate(
   context->handle->sample_rate = sample_rate;
 }
 
+static int
+bare_ffmpeg_codec_context_get_gop_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context
+) {
+  return context->handle->gop_size;
+}
+
+static void
+bare_ffmpeg_codec_context_set_gop_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_context_t, 1> context,
+  int32_t gop_size
+) {
+  context->handle->gop_size = gop_size;
+}
+
 static bool
 bare_ffmpeg_codec_context_send_packet(
   js_env_t *env,
@@ -797,11 +832,7 @@ bare_ffmpeg_codec_context_send_frame(
   int err;
 
   err = avcodec_send_frame(context->handle, frame->handle);
-  if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
-    return false;
-  }
-
-  if (err < 0) {
+  if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
 
@@ -952,10 +983,12 @@ bare_ffmpeg_codec_parameters_get_channel_layout(
 
 static js_arraybuffer_t
 bare_ffmpeg_frame_init(js_env_t *env, js_receiver_t) {
+  int err;
+
   js_arraybuffer_t handle;
 
   bare_ffmpeg_frame_t *frame;
-  int err = js_create_arraybuffer(env, frame, handle);
+  err = js_create_arraybuffer(env, frame, handle);
   assert(err == 0);
 
   frame->handle = av_frame_alloc();
@@ -1049,6 +1082,15 @@ bare_ffmpeg_frame_set_nb_samples(
   frame->handle->nb_samples = nb_samples;
 }
 
+static int32_t
+bare_ffmpeg_frame_get_pict_type(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  return frame->handle->pict_type;
+}
+
 static void
 bare_ffmpeg_frame_alloc(
   js_env_t *env,
@@ -1113,7 +1155,7 @@ bare_ffmpeg_image_fill(
 ) {
   int err;
 
-  err = av_image_fill_arrays(
+  auto len = av_image_fill_arrays(
     frame->handle->data,
     frame->handle->linesize,
     &data[static_cast<size_t>(offset)],
@@ -1123,14 +1165,51 @@ bare_ffmpeg_image_fill(
     align
   );
 
-  if (err < 0) {
-    err = js_throw_error(env, NULL, av_err2str(err));
+  if (len < 0) {
+    err = js_throw_error(env, NULL, av_err2str(len));
     assert(err == 0);
 
     throw js_pending_exception;
   }
 }
 
+static void
+bare_ffmpeg_image_read(
+  js_env_t *env,
+  js_receiver_t,
+  int32_t pixel_format,
+  int32_t width,
+  int32_t height,
+  int32_t align,
+  js_arraybuffer_span_t data,
+  uint64_t offset,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  uint8_t *dst_data[4];
+  int dst_linesize[4];
+
+  int err = av_image_fill_arrays(
+    dst_data,
+    dst_linesize,
+    &data[offset],
+    static_cast<AVPixelFormat>(pixel_format),
+    width,
+    height,
+    align
+  );
+  assert(err >= 0);
+
+  av_image_copy(
+    dst_data,
+    dst_linesize,
+    frame->handle->data,
+    frame->handle->linesize,
+    static_cast<AVPixelFormat>(pixel_format),
+    width,
+    height
+  );
+}
+
 static int
 bare_ffmpeg_image_get_line_size(
   js_env_t *env,
@@ -1218,6 +1297,7 @@ bare_ffmpeg_packet_init(js_env_t *env, js_receiver_t) {
   int err;
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_packet_t *packet;
   err = js_create_arraybuffer(env, packet, handle);
   assert(err == 0);
@@ -1238,7 +1318,6 @@ bare_ffmpeg_packet_init_from_buffer(
   int err;
 
   AVPacket *pkt = av_packet_alloc();
-  assert(pkt != NULL);
 
   err = av_new_packet(pkt, static_cast<int>(len));
   assert(err == 0);
@@ -1246,6 +1325,7 @@ bare_ffmpeg_packet_init_from_buffer(
   memcpy(pkt->data, &data[static_cast<size_t>(offset)], static_cast<size_t>(len));
 
   js_arraybuffer_t handle;
+
   bare_ffmpeg_packet_t *packet;
   err = js_create_arraybuffer(env, packet, handle);
   assert(err == 0);
@@ -1280,9 +1360,11 @@ bare_ffmpeg_packet_get_data(
   js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
 ) {
   int err;
-  size_t size = static_cast<size_t>(packet->handle->size);
+
+  auto size = static_cast<size_t>(packet->handle->size);
 
   js_arraybuffer_t handle;
+
   uint8_t *data;
   err = js_create_arraybuffer(env, size, data, handle);
   assert(err == 0);
@@ -1292,6 +1374,15 @@ bare_ffmpeg_packet_get_data(
   return handle;
 }
 
+static bool
+bare_ffmpeg_packet_is_keyframe(
+  js_env_t *,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_packet_t, 1> packet
+) {
+  return packet->handle->flags & AV_PKT_FLAG_KEY;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_scaler_init(
   js_env_t *env,
@@ -1303,18 +1394,21 @@ bare_ffmpeg_scaler_init(
   int32_t target_width,
   int32_t target_height
 ) {
+  int err;
+
   js_arraybuffer_t handle;
+
   bare_ffmpeg_scaler_t *scaler;
-  int err = js_create_arraybuffer(env, scaler, handle);
+  err = js_create_arraybuffer(env, scaler, handle);
   assert(err == 0);
 
   scaler->handle = sws_getContext(
     source_width,
     source_height,
-    (enum AVPixelFormat) source_format,
+    static_cast<AVPixelFormat>(source_format),
     target_width,
     target_height,
-    (enum AVPixelFormat) target_format,
+    static_cast<AVPixelFormat>(target_format),
     SWS_BICUBIC,
     NULL,
     NULL,
@@ -1345,7 +1439,7 @@ bare_ffmpeg_scaler_scale(
 ) {
   return sws_scale(
     scaler->handle,
-    (const uint8_t *const *) source->handle->data,
+    reinterpret_cast<const uint8_t *const *>(source->handle->data),
     source->handle->linesize,
     y,
     height,
@@ -1359,9 +1453,12 @@ bare_ffmpeg_dictionary_init(
   js_env_t *env,
   js_receiver_t
 ) {
+  int err;
+
   js_arraybuffer_t handle;
+
   bare_ffmpeg_dictionary_t *dict;
-  int err = js_create_arraybuffer(env, dict, handle);
+  err = js_create_arraybuffer(env, dict, handle);
   assert(err == 0);
 
   dict->handle = NULL;
@@ -1386,7 +1483,9 @@ bare_ffmpeg_dictionary_set_entry(
   std::string key,
   std::string value
 ) {
-  int err = av_dict_set(&dict->handle, key.c_str(), value.c_str(), 0);
+  int err;
+
+  err = av_dict_set(&dict->handle, key.c_str(), value.c_str(), 0);
   assert(err == 0);
 }
 
@@ -1449,7 +1548,6 @@ bare_ffmpeg_resampler_init(
   }
 
   err = swr_init(resampler->handle);
-
   if (err < 0) {
     swr_free(&resampler->handle);
 
@@ -1472,7 +1570,7 @@ bare_ffmpeg_resampler_convert_frames(
 ) {
   int err;
 
-  int result = swr_convert(
+  auto result = swr_convert(
     resampler->handle,
     (uint8_t **) out_frame->handle->data,
     out_frame->handle->nb_samples,
@@ -1483,6 +1581,7 @@ bare_ffmpeg_resampler_convert_frames(
   if (result < 0) {
     err = js_throw_error(env, NULL, av_err2str(result));
     assert(err == 0);
+
     throw js_pending_exception;
   }
 
@@ -1510,7 +1609,7 @@ bare_ffmpeg_resampler_flush(
 ) {
   int err;
 
-  int result = swr_convert(
+  auto result = swr_convert(
     resampler->handle,
     out_frame->handle->data,
     out_frame->handle->nb_samples,
@@ -1521,6 +1620,7 @@ bare_ffmpeg_resampler_flush(
   if (result < 0) {
     err = js_throw_error(env, NULL, av_err2str(result));
     assert(err == 0);
+
     throw js_pending_exception;
   }
 
@@ -1587,6 +1687,149 @@ bare_ffmpeg_channel_layout_from_mask(
   return result;
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_audio_fifo_init(
+  js_env_t *env,
+  js_receiver_t,
+  int32_t sample_fmt,
+  int32_t channels,
+  int32_t nb_samples
+) {
+  int err;
+
+  js_arraybuffer_t handle;
+
+  bare_ffmpeg_audio_fifo_t *fifo;
+  err = js_create_arraybuffer(env, fifo, handle);
+  assert(err == 0);
+
+  fifo->handle = av_audio_fifo_alloc(
+    static_cast<AVSampleFormat>(sample_fmt),
+    channels,
+    nb_samples
+  );
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_audio_fifo_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  av_audio_fifo_free(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_write(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame
+) {
+  int err;
+
+  int 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;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_read(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
+  int32_t nb_samples
+) {
+  int err;
+
+  int 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;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_peek(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  js_arraybuffer_span_of_t<bare_ffmpeg_frame_t, 1> frame,
+  int32_t nb_samples
+) {
+  int err;
+
+  int 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;
+  }
+
+  return len;
+}
+
+static int
+bare_ffmpeg_audio_fifo_drain(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo,
+  int32_t nb_samples
+) {
+  int err;
+
+  int 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;
+  }
+
+  return len;
+}
+
+static void
+bare_ffmpeg_audio_fifo_reset(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  av_audio_fifo_reset(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  return av_audio_fifo_size(fifo->handle);
+}
+
+static int
+bare_ffmpeg_audio_fifo_space(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_audio_fifo_t, 1> fifo
+) {
+  return av_audio_fifo_space(fifo->handle);
+}
+
 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);
@@ -1637,6 +1880,9 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setCodecContextChannelLayout", bare_ffmpeg_codec_context_set_channel_layout);
   V("getCodecContextSampleRate", bare_ffmpeg_codec_context_get_sample_rate);
   V("setCodecContextSampleRate", bare_ffmpeg_codec_context_set_sample_rate);
+  V("getCodecContextGOPSize", bare_ffmpeg_codec_context_get_gop_size)
+  V("setCodecContextGOPSize", bare_ffmpeg_codec_context_set_gop_size)
+
   V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
   V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
   V("sendCodecContextFrame", bare_ffmpeg_codec_context_send_frame)
@@ -1667,10 +1913,12 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setFrameChannelLayout", bare_ffmpeg_frame_set_channel_layout)
   V("getFrameNbSamples", bare_ffmpeg_frame_get_nb_samples)
   V("setFrameNbSamples", bare_ffmpeg_frame_set_nb_samples)
+  V("getFramePictType", bare_ffmpeg_frame_get_pict_type)
   V("allocFrame", bare_ffmpeg_frame_alloc)
 
   V("initImage", bare_ffmpeg_image_init)
   V("fillImage", bare_ffmpeg_image_fill)
+  V("readImage", bare_ffmpeg_image_read)
   V("getImageLineSize", bare_ffmpeg_image_get_line_size)
 
   V("initSamples", bare_ffmpeg_samples_init)
@@ -1681,6 +1929,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("unrefPacket", bare_ffmpeg_packet_unref)
   V("getPacketStreamIndex", bare_ffmpeg_packet_get_stream_index)
   V("getPacketData", bare_ffmpeg_packet_get_data)
+  V("isPacketKeyframe", bare_ffmpeg_packet_is_keyframe)
 
   V("initScaler", bare_ffmpeg_scaler_init)
   V("destroyScaler", bare_ffmpeg_scaler_destroy)
@@ -1700,6 +1949,16 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("copyChannelLayout", bare_ffmpeg_channel_layout_copy)
   V("getChannelLayoutNbChannels", bare_ffmpeg_channel_layout_get_nb_channels)
   V("channelLayoutFromMask", bare_ffmpeg_channel_layout_from_mask)
+
+  V("initAudioFifo", bare_ffmpeg_audio_fifo_init)
+  V("destroyAudioFifo", bare_ffmpeg_audio_fifo_destroy)
+  V("writeAudioFifo", bare_ffmpeg_audio_fifo_write)
+  V("readAudioFifo", bare_ffmpeg_audio_fifo_read)
+  V("peekAudioFifo", bare_ffmpeg_audio_fifo_peek)
+  V("drainAudioFifo", bare_ffmpeg_audio_fifo_drain)
+  V("resetAudioFifo", bare_ffmpeg_audio_fifo_reset)
+  V("getAudioFifoSize", bare_ffmpeg_audio_fifo_size)
+  V("getAudioFifoSpace", bare_ffmpeg_audio_fifo_space)
 #undef V
 
 #define V(name) \
@@ -1721,6 +1980,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(AV_PIX_FMT_RGB24)
   V(AV_PIX_FMT_YUVJ420P)
   V(AV_PIX_FMT_YUV420P)
+  V(AV_PIX_FMT_UYVY422)
 
   V(AVMEDIA_TYPE_UNKNOWN)
   V(AVMEDIA_TYPE_VIDEO)
@@ -1753,6 +2013,15 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(AV_CH_LAYOUT_5POINT0)
   V(AV_CH_LAYOUT_5POINT1)
   V(AV_CH_LAYOUT_7POINT1)
+
+  V(AV_PICTURE_TYPE_NONE)
+  V(AV_PICTURE_TYPE_I)
+  V(AV_PICTURE_TYPE_P)
+  V(AV_PICTURE_TYPE_B)
+  V(AV_PICTURE_TYPE_S)
+  V(AV_PICTURE_TYPE_SI)
+  V(AV_PICTURE_TYPE_SP)
+  V(AV_PICTURE_TYPE_BI)
 #undef V
 
   return exports;

package/cmake/ports/opus/port.cmake

@@ -11,6 +11,10 @@ set(args
   -DBUILD_TESTING=OFF
 )
 
+if(WIN32)
+  list(APPEND args -DOPUS_DISABLE_INTRINSICS=ON)
+endif()
+
 declare_port(
   "github:xiph/opus@v1.5.2"
   opus

package/index.js

@@ -1,3 +1,4 @@
+const AudioFIFO = require('./lib/audio-fifo')
 const ChannelLayout = require('./lib/channel-layout')
 const Codec = require('./lib/codec')
 const CodecContext = require('./lib/codec-context')
@@ -21,6 +22,7 @@ const Stream = require('./lib/stream')
 const Rational = require('./lib/rational')
 const Resampler = require('./lib/resampler')
 
+exports.AudioFIFO = AudioFIFO
 exports.ChannelLayout = ChannelLayout
 exports.Codec = Codec
 exports.CodecContext = CodecContext

package/lib/audio-fifo.js

@@ -0,0 +1,47 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = class FFmpegAudioFIFO {
+  constructor(sampleFormat, channels, nbSamples) {
+    sampleFormat = constants.toSampleFormat(sampleFormat)
+
+    this._handle = binding.initAudioFifo(sampleFormat, channels, nbSamples)
+  }
+
+  destroy() {
+    binding.destroyAudioFifo(this._handle)
+    this._handle = null
+  }
+
+  write(frame) {
+    return binding.writeAudioFifo(this._handle, frame._handle)
+  }
+
+  read(frame, nbSamples) {
+    return binding.readAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  peek(frame, nbSamples) {
+    return binding.peekAudioFifo(this._handle, frame._handle, nbSamples)
+  }
+
+  drain(nbSamples) {
+    return binding.drainAudioFifo(this._handle, nbSamples)
+  }
+
+  reset() {
+    binding.resetAudioFifo(this._handle)
+  }
+
+  get size() {
+    return binding.getAudioFifoSize(this._handle)
+  }
+
+  get space() {
+    return binding.getAudioFifoSpace(this._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/codec-context.js

@@ -78,6 +78,14 @@ module.exports = class FFmpegCodecContext {
     )
   }
 
+  get gopSize() {
+    return binding.getCodecContextGOPSize(this._handle)
+  }
+
+  set gopSize(value) {
+    binding.setCodecContextGOPSize(this._handle, value)
+  }
+
   open(options) {
     if (this._opened) return
     this._opened = true

package/lib/constants.js

@@ -56,6 +56,16 @@ module.exports = exports = {
     '5.0': binding.AV_CH_LAYOUT_5POINT0,
     5.1: binding.AV_CH_LAYOUT_5POINT1,
     7.1: binding.AV_CH_LAYOUT_7POINT1
+  },
+  pictureType: {
+    NONE: binding.AV_PICTURE_TYPE_NONE,
+    I: binding.AV_PICTURE_TYPE_I,
+    P: binding.AV_PICTURE_TYPE_P,
+    B: binding.AV_PICTURE_TYPE_B,
+    S: binding.AV_PICTURE_TYPE_S,
+    SI: binding.AV_PICTURE_TYPE_SI,
+    SP: binding.AV_PICTURE_TYPE_SP,
+    BI: binding.AV_PICTURE_TYPE_BI
   }
 }
 

package/lib/frame.js

@@ -62,6 +62,10 @@ module.exports = class FFmpegFrame {
     binding.setFrameNbSamples(this._handle, value)
   }
 
+  get pictType() {
+    return binding.getFramePictType(this._handle)
+  }
+
   alloc() {
     binding.allocFrame(this._handle, 32)
   }

package/lib/image.js

@@ -47,6 +47,18 @@ module.exports = class FFmpegImage {
     )
   }
 
+  read(frame) {
+    binding.readImage(
+      this._pixelFormat,
+      this._width,
+      this._height,
+      this._align,
+      this._data.buffer,
+      this._data.byteOffset,
+      frame._handle
+    )
+  }
+
   lineSize(plane = 0) {
     return binding.getImageLineSize(this._pixelFormat, this._width, plane)
   }

package/lib/input-format.js

@@ -3,6 +3,9 @@ const binding = require('../binding')
 let defaultName = null
 
 switch (Bare.platform) {
+  case 'android':
+    defaultName = 'android_camera'
+    break
   case 'darwin':
   case 'ios':
     defaultName = 'avfoundation'

package/lib/packet.js

@@ -30,6 +30,10 @@ module.exports = class FFmpegPacket {
     return Buffer.from(binding.getPacketData(this._handle))
   }
 
+  get isKeyframe() {
+    return binding.isPacketKeyframe(this._handle)
+  }
+
   [Symbol.dispose]() {
     this.destroy()
   }

package/package.json

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