bare-ffmpeg 1.0.0-1 → 1.0.0-2

package/CMakeLists.txt

@@ -5,7 +5,7 @@ find_package(cmake-ports REQUIRED PATHS node_modules/cmake-ports)
 
 project(bare_ffmpeg C)
 
-find_port(ffmpeg FEATURES dav1d)
+find_port(ffmpeg FEATURES dav1d x264)
 
 add_bare_module(bare_ffmpeg)
 

package/binding.c

@@ -59,7 +59,7 @@ typedef struct {
 } bare_ffmpeg_frame_t;
 
 typedef struct {
-  AVPacket handle;
+  AVPacket *handle;
 } bare_ffmpeg_packet_t;
 
 typedef struct {
@@ -229,7 +229,7 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-bare_ffmpeg_format_context_open_input(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_format_context_open_input_with_io(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -280,6 +280,70 @@ bare_ffmpeg_format_context_open_input(js_env_t *env, js_callback_info_t *info) {
   return handle;
 }
 
+static js_value_t *
+bare_ffmpeg_format_context_open_input_with_format(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+  assert(argc == 3);
+
+  bare_ffmpeg_input_format_t *format;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
+  assert(err == 0);
+
+  js_value_t *handle;
+
+  bare_ffmpeg_format_context_t *context;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
+  assert(err == 0);
+
+  context->handle = avformat_alloc_context();
+  context->handle->opaque = (void *) context;
+
+  bare_ffmpeg_dictionary_t *options;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
+  assert(err == 0);
+
+  size_t len;
+  err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *url = malloc(len);
+  err = js_get_value_string_utf8(env, argv[2], url, len, NULL);
+  assert(err == 0);
+
+  err = avformat_open_input(&context->handle, (char *) url, format->handle, &options->handle);
+  free(url);
+
+  if (err < 0) {
+    avformat_free_context(context->handle);
+
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  err = avformat_find_stream_info(context->handle, NULL);
+
+  if (err < 0) {
+    avformat_close_input(&context->handle);
+
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  return handle;
+}
+
 static js_value_t *
 bare_ffmpeg_format_context_close_input(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -401,6 +465,38 @@ bare_ffmpeg_format_context_get_streams(js_env_t *env, js_callback_info_t *info)
   return result;
 }
 
+static js_value_t *
+bare_ffmpeg_format_context_get_best_stream_index(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_ffmpeg_format_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  int type;
+  err = js_get_value_int32(env, argv[1], &type);
+  assert(err == 0);
+
+  int stream_index = av_find_best_stream(context->handle, type, -1, -1, NULL, 0);
+  if (stream_index < 0) {
+    stream_index = -1;
+  }
+
+  js_value_t *result;
+  err = js_create_int32(env, stream_index, &result);
+  assert(err == 0);
+
+  return result;
+}
+
 static js_value_t *
 bare_ffmpeg_format_context_create_stream(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -459,9 +555,9 @@ bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
   assert(err == 0);
 
-  av_packet_unref(&packet->handle);
+  av_packet_unref(packet->handle);
 
-  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));
@@ -656,7 +752,6 @@ bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
-
   assert(argc == 1);
 
   bare_ffmpeg_codec_context_t *context;
@@ -673,6 +768,34 @@ bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
+static js_value_t *
+bare_ffmpeg_codec_context_open_with_options(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+  assert(argc == 2);
+
+  bare_ffmpeg_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  bare_ffmpeg_dictionary_t *options;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
+  assert(err == 0);
+
+  err = avcodec_open2(context->handle, context->handle->codec, &options->handle);
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+  }
+
+  return NULL;
+}
+
 static js_value_t *
 bare_ffmpeg_codec_context_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -891,7 +1014,7 @@ bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
   assert(err == 0);
 
-  err = avcodec_send_packet(context->handle, &packet->handle);
+  err = avcodec_send_packet(context->handle, packet->handle);
 
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
@@ -901,6 +1024,83 @@ bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
+static js_value_t *
+bare_ffmpeg_codec_context_receive_packet(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+  assert(argc == 2);
+
+  bare_ffmpeg_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  bare_ffmpeg_packet_t *packet;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
+  assert(err == 0);
+
+  err = avcodec_receive_packet(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);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_get_boolean(env, err == 0, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_context_send_frame(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+  assert(argc == 2);
+
+  bare_ffmpeg_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  bare_ffmpeg_frame_t *frame;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
+  assert(err == 0);
+
+  err = avcodec_send_frame(context->handle, frame->handle);
+
+  if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
+    js_value_t *result;
+    err = js_get_boolean(env, false, &result);
+    assert(err == 0);
+    return result;
+  }
+
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_get_boolean(env, err == 0, &result);
+  assert(err == 0);
+
+  return result;
+}
+
 static js_value_t *
 bare_ffmpeg_codec_context_receive_frame(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1422,6 +1622,49 @@ bare_ffmpeg_packet_init(js_env_t *env, js_callback_info_t *info) {
   err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
   assert(err == 0);
 
+  packet->handle = av_packet_alloc();
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_packet_init_from_buffer(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+  assert(argc == 3);
+
+  uint8_t *data;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
+  assert(err == 0);
+
+  uint32_t offset;
+  err = js_get_value_uint32(env, argv[1], &offset);
+  assert(err == 0);
+
+  uint32_t len;
+  err = js_get_value_uint32(env, argv[2], &len);
+  assert(err == 0);
+
+  AVPacket *pkt = av_packet_alloc();
+  assert(pkt != NULL);
+
+  err = av_new_packet(pkt, len);
+  assert(err == 0);
+
+  memcpy(pkt->data, &data[offset], len);
+
+  js_value_t *handle;
+  bare_ffmpeg_packet_t *packet;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
+  assert(err == 0);
+
+  packet->handle = pkt;
+
   return handle;
 }
 
@@ -1441,7 +1684,7 @@ bare_ffmpeg_packet_destroy(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
   assert(err == 0);
 
-  av_packet_unref(&packet->handle);
+  av_packet_unref(packet->handle);
 
   return NULL;
 }
@@ -1462,11 +1705,60 @@ bare_ffmpeg_packet_unref(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
   assert(err == 0);
 
-  av_packet_unref(&packet->handle);
+  av_packet_unref(packet->handle);
 
   return NULL;
 }
 
+static js_value_t *
+bare_ffmpeg_packet_get_stream_index(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_ffmpeg_packet_t *packet;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int32(env, packet->handle->stream_index, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_packet_get_data(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_ffmpeg_packet_t *packet;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  uint8_t *data;
+  err = js_create_arraybuffer(env, packet->handle->size, (void **) &data, &result);
+  assert(err == 0);
+
+  memcpy(data, packet->handle->data, packet->handle->size);
+
+  return result;
+}
+
 static js_value_t *
 bare_ffmpeg_scaler_init(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1734,11 +2026,13 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("initOutputFormat", bare_ffmpeg_output_format_init)
   V("initInputFormat", bare_ffmpeg_input_format_init)
 
-  V("openInputFormatContext", bare_ffmpeg_format_context_open_input)
+  V("openInputFormatContextWithIO", bare_ffmpeg_format_context_open_input_with_io)
+  V("openInputFormatContextWithFormat", bare_ffmpeg_format_context_open_input_with_format)
   V("closeInputFormatContext", bare_ffmpeg_format_context_close_input)
   V("openOutputFormatContext", bare_ffmpeg_format_context_open_output)
   V("closeOutputFormatContext", bare_ffmpeg_format_context_close_output)
   V("getFormatContextStreams", bare_ffmpeg_format_context_get_streams)
+  V("getFormatContextBestStreamIndex", bare_ffmpeg_format_context_get_best_stream_index)
   V("createFormatContextStream", bare_ffmpeg_format_context_create_stream)
   V("readFormatContextFrame", bare_ffmpeg_format_context_read_frame)
 
@@ -1751,6 +2045,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("initCodecContext", bare_ffmpeg_codec_context_init)
   V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
   V("openCodecContext", bare_ffmpeg_codec_context_open)
+  V("openCodecContextWithOptions", bare_ffmpeg_codec_context_open_with_options)
   V("getCodecContextPixelFormat", bare_ffmpeg_codec_context_get_pixel_format)
   V("setCodecContextPixelFormat", bare_ffmpeg_codec_context_set_pixel_format)
   V("getCodecContextWidth", bare_ffmpeg_codec_context_get_width)
@@ -1760,6 +2055,8 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("getCodecContextTimeBase", bare_ffmpeg_codec_context_get_time_base)
   V("setCodecContextTimeBase", bare_ffmpeg_codec_context_set_time_base)
   V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
+  V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
+  V("sendCodecContextFrame", bare_ffmpeg_codec_context_send_frame)
   V("receiveCodecContextFrame", bare_ffmpeg_codec_context_receive_frame)
 
   V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
@@ -1784,8 +2081,11 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("fillImage", bare_ffmpeg_image_fill)
 
   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("getPacketData", bare_ffmpeg_packet_get_data)
 
   V("initScaler", bare_ffmpeg_scaler_init)
   V("destroyScaler", bare_ffmpeg_scaler_destroy)
@@ -1807,10 +2107,19 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   }
 
   V(AV_CODEC_ID_MJPEG)
+  V(AV_CODEC_ID_H264)
 
   V(AV_PIX_FMT_RGBA)
   V(AV_PIX_FMT_YUVJ420P)
   V(AV_PIX_FMT_YUV420P)
+
+  V(AVMEDIA_TYPE_UNKNOWN)
+  V(AVMEDIA_TYPE_VIDEO)
+  V(AVMEDIA_TYPE_AUDIO)
+  V(AVMEDIA_TYPE_DATA)
+  V(AVMEDIA_TYPE_SUBTITLE)
+  V(AVMEDIA_TYPE_ATTACHMENT)
+  V(AVMEDIA_TYPE_NB)
 #undef V
 
   return exports;

package/lib/codec-context.js

@@ -52,10 +52,14 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
     binding.setCodecContextTimeBase(this._handle, view.buffer)
   }
 
-  open() {
+  open(options) {
     if (this._opened) return
     this._opened = true
-    binding.openCodecContext(this._handle)
+    if (options) {
+      binding.openCodecContextWithOptions(this._handle, options._handle)
+    } else {
+      binding.openCodecContext(this._handle)
+    }
     return this
   }
 
@@ -64,6 +68,16 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
     return this
   }
 
+  receivePacket(packet) {
+    const res = binding.receiveCodecContextPacket(this._handle, packet._handle)
+    if (res) packet._ref()
+    return res
+  }
+
+  sendFrame(frame) {
+    return binding.sendCodecContextFrame(this._handle, frame._handle)
+  }
+
   receiveFrame(frame) {
     return binding.receiveCodecContextFrame(this._handle, frame._handle)
   }

package/lib/codec.js

@@ -35,4 +35,5 @@ module.exports = class FFmpegCodec {
   }
 
   static MJPEG = this.for(constants.codecs.MJPEG)
+  static H264 = this.for(constants.codecs.H264)
 }

package/lib/constants.js

@@ -2,12 +2,24 @@ const binding = require('../binding')
 
 module.exports = exports = {
   codecs: {
-    MJPEG: binding.AV_CODEC_ID_MJPEG
+    MJPEG: binding.AV_CODEC_ID_MJPEG,
+    H264: binding.AV_CODEC_ID_H264
   },
   pixelFormats: {
     RGBA: binding.AV_PIX_FMT_RGBA,
+    RGB24: binding.AV_PIX_FMT_RGB24,
     YUVJ420P: binding.AV_PIX_FMT_YUVJ420P,
+    UYVY422: binding.AV_PIX_FMT_UYVY422,
     YUV420P: binding.AV_PIX_FMT_YUV420P
+  },
+  mediaType: {
+    UNKNOWN: binding.AVMEDIA_TYPE_UNKNOWN,
+    VIDEO: binding.AVMEDIA_TYPE_VIDEO,
+    AUDIO: binding.AVMEDIA_TYPE_AUDIO,
+    DATA: binding.AVMEDIA_TYPE_DATA,
+    SUBTITLE: binding.AVMEDIA_TYPE_SUBTITLE,
+    ATTACHEMENT: binding.AVMEDIA_TYPE_ATTACHMENT,
+    NB: binding.AVMEDIA_TYPE_NB
   }
 }
 

package/lib/format-context.js

@@ -2,18 +2,22 @@ const binding = require('../binding')
 const Stream = require('./stream.js')
 const ReferenceCounted = require('./reference-counted')
 const OutputFormat = require('./output-format')
+const IOContext = require('./io-context')
+const InputFormat = require('./input-format')
 
 class FFmpegFormatContext extends ReferenceCounted {
   constructor(io) {
     super()
 
-    this._io = io._ref()
+    this._io = io ? io._ref() : null
     this._streams = []
   }
 
   _destroy() {
-    this._io._unref()
-    this._io = null
+    if (this._io) {
+      this._io._unref()
+      this._io = null
+    }
 
     for (const stream of this._streams) stream.destroy()
     this._streams = []
@@ -36,15 +40,61 @@ class FFmpegFormatContext extends ReferenceCounted {
     if (result) packet._ref()
     return result
   }
+
+  getBestStream(type) {
+    if (typeof type !== 'number') {
+      throw new TypeError(
+        `Type parameter should be of type number but got: ${typeof type}`
+      )
+    }
+
+    if (this._streams.length == 0) {
+      return null
+    }
+
+    const bestIndex = binding.getFormatContextBestStreamIndex(
+      this._handle,
+      type
+    )
+
+    if (bestIndex < 0 || bestIndex >= this._streams.length) {
+      return null
+    }
+
+    return this._streams[bestIndex]
+  }
+}
+
+let defaultURL = null
+
+switch (Bare.platform) {
+  case 'darwin':
+    defaultURL = '0'
+    break
+  case 'linux':
+    // TODO: test on real machine
+    defaultURL = '/dev/video0'
+    break
+  case 'win32':
+    defaultURL = 'video=Integrated Camera'
+    break
 }
 
 exports.InputFormatContext = class FFmpegInputFormatContext extends (
   FFmpegFormatContext
 ) {
-  constructor(io) {
-    super(io)
-
-    this._handle = binding.openInputFormatContext(io._handle)
+  constructor(io, options, url = defaultURL) {
+    if (io instanceof IOContext) {
+      super(io)
+      this._handle = binding.openInputFormatContextWithIO(io._handle)
+    } else if (io instanceof InputFormat) {
+      super()
+      this._handle = binding.openInputFormatContextWithFormat(
+        io._handle,
+        options._handle,
+        url
+      )
+    }
 
     for (const handle of binding.getFormatContextStreams(this._handle)) {
       this._streams.push(new Stream(handle))

package/lib/packet.js

@@ -2,10 +2,24 @@ const binding = require('../binding')
 const ReferenceCounted = require('./reference-counted')
 
 module.exports = class FFmpegPacket extends ReferenceCounted {
-  constructor() {
+  constructor(buffer) {
     super()
 
-    this._handle = binding.initPacket()
+    if (buffer) {
+      if (!Buffer.isBuffer(buffer)) {
+        throw TypeError(
+          `Buffer parameter should be of type Buffer but got: ${typeof buffer}`
+        )
+      }
+
+      this._handle = binding.initPacketFromBuffer(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      )
+    } else {
+      this._handle = binding.initPacket()
+    }
   }
 
   _destroy() {
@@ -17,4 +31,12 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
     this._unref()
     binding.unrefPacket(this._handle)
   }
+
+  get streamIndex() {
+    return binding.getPacketStreamIndex(this._handle)
+  }
+
+  get data() {
+    return Buffer.from(binding.getPacketData(this._handle))
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-1",
+  "version": "1.0.0-2",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",
@@ -31,7 +31,7 @@
   "devDependencies": {
     "brittle": "^3.4.0",
     "cmake-bare": "^1.1.2",
-    "cmake-ports": "^1.1.7",
+    "cmake-ports": "^1.5.0",
     "prettier": "^3.3.3",
     "prettier-config-standard": "^7.0.0"
   }