bare-ffmpeg 1.0.0-23 → 1.0.0-25

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()`

package/binding.cc

@@ -33,9 +33,9 @@ extern "C" {
 #include <libswscale/swscale.h>
 }
 
-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>;
+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, int>;
 
 typedef struct {
   AVIOContext *handle;
@@ -144,13 +144,9 @@ bare_ffmpeg__on_io_context_write(void *opaque, const uint8_t *buf, int len) {
   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, data);
 
-  err = js_call_function(env, callback, view);
-  assert(err == 0);
+  if (err < 0) return AVERROR(EIO);
 
   return 0;
 }
@@ -171,12 +167,8 @@ bare_ffmpeg__on_io_context_read(void *opaque, uint8_t *buf, int len) {
   err = js_create_external_arraybuffer(env, buf, static_cast<size_t>(len), arraybuffer);
   assert(err == 0);
 
-  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);
+  int call_status = js_call_function<js_type_options_t{}, int32_t, js_arraybuffer_t, int32_t>(env, callback, arraybuffer, len, result);
 
   err = js_detach_arraybuffer(env, arraybuffer);
   assert(err == 0);
@@ -190,39 +182,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) {
@@ -400,6 +374,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);
 
@@ -3430,6 +3410,13 @@ 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)
 #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/constants.js

@@ -133,6 +133,13 @@ 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
   }
 }
 

package/lib/io-context.js

@@ -20,8 +20,8 @@ module.exports = class FFmpegIOContext {
       buffer,
       offset,
       len,
-      opts.onwrite,
-      opts.onread,
+      opts.onwrite && onwriteWrapper.bind(null, opts.onwrite),
+      opts.onread && onreadWrapper.bind(null, opts.onread),
       opts.onseek
     )
   }
@@ -35,3 +35,11 @@ module.exports = class FFmpegIOContext {
     this.destroy()
   }
 }
+
+function onwriteWrapper(target, arraybuffer) {
+  return target(Buffer.from(arraybuffer))
+}
+
+function onreadWrapper(target, arraybuffer, requestedLen) {
+  return target(Buffer.from(arraybuffer), requestedLen)
+}

package/package.json

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