bare-ffmpeg 1.0.0-3 → 1.0.0-6

package/binding.c

@@ -167,10 +167,12 @@ bare_ffmpeg_output_format_init(js_env_t *env, js_callback_info_t *info) {
   if (format == NULL) {
     err = js_throw_errorf(env, NULL, "No output format found for name '%s'", name);
     assert(err == 0);
+
     free(name);
 
     return NULL;
   }
+
   free(name);
 
   js_value_t *handle;
@@ -211,10 +213,12 @@ bare_ffmpeg_input_format_init(js_env_t *env, js_callback_info_t *info) {
   if (format == NULL) {
     err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name);
     assert(err == 0);
+
     free(name);
 
     return NULL;
   }
+
   free(name);
 
   js_value_t *handle;
@@ -302,6 +306,7 @@ bare_ffmpeg_format_context_open_input_with_format(js_env_t *env, js_callback_inf
   assert(err == 0);
 
   context->handle = avformat_alloc_context();
+
   context->handle->opaque = (void *) context;
 
   bare_ffmpeg_dictionary_t *options;
@@ -319,6 +324,7 @@ bare_ffmpeg_format_context_open_input_with_format(js_env_t *env, js_callback_inf
   assert(err == 0);
 
   err = avformat_open_input(&context->handle, (char *) url, format->handle, &options->handle);
+
   free(url);
 
   if (err < 0) {
@@ -485,13 +491,12 @@ bare_ffmpeg_format_context_get_best_stream_index(js_env_t *env, js_callback_info
   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;
-  }
+  int i = av_find_best_stream(context->handle, type, -1, -1, NULL, 0);
+
+  if (i < 0) i = -1;
 
   js_value_t *result;
-  err = js_create_int32(env, stream_index, &result);
+  err = js_create_int32(env, i, &result);
   assert(err == 0);
 
   return result;
@@ -752,6 +757,7 @@ 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;
@@ -777,6 +783,7 @@ bare_ffmpeg_codec_context_open_with_options(js_env_t *env, js_callback_info_t *i
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
+
   assert(argc == 2);
 
   bare_ffmpeg_codec_context_t *context;
@@ -788,6 +795,7 @@ bare_ffmpeg_codec_context_open_with_options(js_env_t *env, js_callback_info_t *i
   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);
@@ -1033,6 +1041,7 @@ bare_ffmpeg_codec_context_receive_packet(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 == 2);
 
   bare_ffmpeg_codec_context_t *context;
@@ -1068,6 +1077,7 @@ bare_ffmpeg_codec_context_send_frame(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 == 2);
 
   bare_ffmpeg_codec_context_t *context;
@@ -1084,6 +1094,7 @@ bare_ffmpeg_codec_context_send_frame(js_env_t *env, js_callback_info_t *info) {
     js_value_t *result;
     err = js_get_boolean(env, false, &result);
     assert(err == 0);
+
     return result;
   }
 
@@ -1162,8 +1173,6 @@ bare_ffmpeg_codec_parameters_from_context(js_env_t *env, js_callback_info_t *inf
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
-
-    return NULL;
   }
 
   return NULL;
@@ -1194,8 +1203,6 @@ bare_ffmpeg_codec_parameters_to_context(js_env_t *env, js_callback_info_t *info)
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
-
-    return NULL;
   }
 
   return NULL;
@@ -1332,7 +1339,7 @@ bare_ffmpeg_frame_destroy(js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-bare_ffmpeg_frame_get_channel(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_frame_get_audio_channel(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 2;
@@ -1375,6 +1382,7 @@ bare_ffmpeg_frame_get_width(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_frame_t *frame;
@@ -1397,6 +1405,7 @@ bare_ffmpeg_frame_set_width(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 == 2);
 
   bare_ffmpeg_frame_t *frame;
@@ -1421,6 +1430,7 @@ bare_ffmpeg_frame_get_height(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_frame_t *frame;
@@ -1443,6 +1453,7 @@ bare_ffmpeg_frame_set_height(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 == 2);
 
   bare_ffmpeg_frame_t *frame;
@@ -1467,6 +1478,7 @@ bare_ffmpeg_frame_get_pixel_format(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_frame_t *frame;
@@ -1489,6 +1501,7 @@ bare_ffmpeg_frame_set_pixel_format(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 == 2);
 
   bare_ffmpeg_frame_t *frame;
@@ -1504,35 +1517,6 @@ bare_ffmpeg_frame_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
-static js_value_t *
-bare_ffmpeg_frame_get_linesize(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_frame_t *frame;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
-  assert(err == 0);
-
-  uint32_t channel;
-  err = js_get_value_uint32(env, argv[1], &channel);
-  assert(err == 0);
-  assert(channel < AV_NUM_DATA_POINTERS);
-
-  int32_t linesize = frame->handle->linesize[channel];
-
-  js_value_t *result;
-  err = js_create_int32(env, linesize, &result);
-  assert(err == 0);
-
-  return result;
-}
-
 static js_value_t *
 bare_ffmpeg_frame_alloc(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1542,71 +1526,27 @@ bare_ffmpeg_frame_alloc(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 == 2);
 
   bare_ffmpeg_frame_t *frame;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
   assert(err == 0);
-  assert(frame->handle != NULL);
 
   int align;
   err = js_get_value_int32(env, argv[1], &align);
   assert(err == 0);
-  assert(frame->handle != NULL);
 
   err = av_frame_get_buffer(frame->handle, align);
+
   if (err < 0) {
     err = js_throw_error(env, NULL, av_err2str(err));
     assert(err == 0);
-    return NULL;
   }
 
   return NULL;
 }
 
-static js_value_t *
-bare_ffmpeg_frame_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_frame_t *frame;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
-  assert(err == 0);
-
-  int size = av_image_get_buffer_size(
-    frame->handle->format,
-    frame->handle->width,
-    frame->handle->height,
-    1
-  );
-  assert(size > 0);
-
-  js_value_t *result;
-  uint8_t *buffer;
-  err = js_create_arraybuffer(env, size, (void **) &buffer, &result);
-  assert(err == 0);
-
-  err = av_image_copy_to_buffer(
-    buffer,
-    size,
-    (const uint8_t *const *) frame->handle->data,
-    frame->handle->linesize,
-    frame->handle->format,
-    frame->handle->width,
-    frame->handle->height,
-    1
-  );
-  assert(err >= 0);
-
-  return result;
-}
-
 static js_value_t *
 bare_ffmpeg_image_init(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1684,6 +1624,39 @@ bare_ffmpeg_image_fill(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
+static js_value_t *
+bare_ffmpeg_image_get_line_size(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);
+
+  int64_t pixel_format;
+  err = js_get_value_int64(env, argv[0], &pixel_format);
+  assert(err == 0);
+
+  int32_t width;
+  err = js_get_value_int32(env, argv[1], &width);
+  assert(err == 0);
+
+  int32_t plane;
+  err = js_get_value_int32(env, argv[2], &plane);
+  assert(err == 0);
+
+  int32_t linesize = av_image_get_linesize((enum AVPixelFormat) pixel_format, width, plane);
+
+  js_value_t *result;
+  err = js_create_int32(env, linesize, &result);
+  assert(err == 0);
+
+  return result;
+}
+
 static js_value_t *
 bare_ffmpeg_packet_init(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1708,6 +1681,7 @@ bare_ffmpeg_packet_init_from_buffer(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 == 3);
 
   uint8_t *data;
@@ -1731,6 +1705,7 @@ bare_ffmpeg_packet_init_from_buffer(js_env_t *env, js_callback_info_t *info) {
   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);
@@ -1821,14 +1796,15 @@ bare_ffmpeg_packet_get_data(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
   assert(err == 0);
 
-  js_value_t *result;
+  js_value_t *handle;
+
   uint8_t *data;
-  err = js_create_arraybuffer(env, packet->handle->size, (void **) &data, &result);
+  err = js_create_arraybuffer(env, packet->handle->size, (void **) &data, &handle);
   assert(err == 0);
 
   memcpy(data, packet->handle->data, packet->handle->size);
 
-  return result;
+  return handle;
 }
 
 static js_value_t *
@@ -1982,6 +1958,7 @@ bare_ffmpeg_dictionary_destroy(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_dictionary_t *dict;
@@ -2002,6 +1979,7 @@ bare_ffmpeg_dictionary_set_entry(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 == 3);
 
   bare_ffmpeg_dictionary_t *dict;
@@ -2029,6 +2007,7 @@ bare_ffmpeg_dictionary_set_entry(js_env_t *env, js_callback_info_t *info) {
 
   err = av_dict_set(&dict->handle, (const char *) key, (const char *) value, 0);
   assert(err == 0);
+
   free(key);
   free(value);
 
@@ -2044,6 +2023,7 @@ bare_ffmpeg_dictionary_get_entry(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 == 2);
 
   bare_ffmpeg_dictionary_t *dict;
@@ -2061,12 +2041,14 @@ bare_ffmpeg_dictionary_get_entry(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   AVDictionaryEntry *entry = av_dict_get(dict->handle, (const char *) key, NULL, 0);
+
   free(key);
 
   if (entry == NULL) {
     js_value_t *result;
     err = js_get_null(env, &result);
     assert(err == 0);
+
     return result;
   }
 
@@ -2140,19 +2122,18 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
 
   V("initFrame", bare_ffmpeg_frame_init)
   V("destroyFrame", bare_ffmpeg_frame_destroy)
-  V("getFrameChannel", bare_ffmpeg_frame_get_channel)
+  V("getFrameAudioChannel", bare_ffmpeg_frame_get_audio_channel)
   V("getFrameWidth", bare_ffmpeg_frame_get_width)
   V("setFrameWidth", bare_ffmpeg_frame_set_width)
   V("getFrameHeight", bare_ffmpeg_frame_get_height)
   V("setFrameHeight", bare_ffmpeg_frame_set_height)
   V("getFramePixelFormat", bare_ffmpeg_frame_get_pixel_format)
   V("setFramePixelFormat", bare_ffmpeg_frame_set_pixel_format)
-  V("getFrameLineSize", bare_ffmpeg_frame_get_linesize)
   V("allocFrame", bare_ffmpeg_frame_alloc)
-  V("getFrameData", bare_ffmpeg_frame_get_data)
 
   V("initImage", bare_ffmpeg_image_init)
   V("fillImage", bare_ffmpeg_image_fill)
+  V("getImageLineSize", bare_ffmpeg_image_get_line_size)
 
   V("initPacket", bare_ffmpeg_packet_init)
   V("initPacketFromBuffer", bare_ffmpeg_packet_init_from_buffer)

package/lib/constants.js

@@ -12,7 +12,7 @@ module.exports = exports = {
     UYVY422: binding.AV_PIX_FMT_UYVY422,
     YUV420P: binding.AV_PIX_FMT_YUV420P
   },
-  mediaType: {
+  mediaTypes: {
     UNKNOWN: binding.AVMEDIA_TYPE_UNKNOWN,
     VIDEO: binding.AVMEDIA_TYPE_VIDEO,
     AUDIO: binding.AVMEDIA_TYPE_AUDIO,

package/lib/dictionary.js

@@ -14,20 +14,10 @@ module.exports = class FFmpegDictionary extends ReferenceCounted {
   }
 
   get(key) {
-    if (typeof key !== 'string' || key.length < 1) {
-      throw new TypeError(`Key should be a non empty string`)
-    }
     return binding.getDictionaryEntry(this._handle, key)
   }
 
   set(key, value) {
-    if (typeof key !== 'string' || key.length < 1) {
-      throw new TypeError(`Key should be a non empty string`)
-    }
-
-    if (typeof value !== 'string' || value.length < 1) {
-      throw new TypeError(`Value should be a non empty string`)
-    }
     binding.setDictionaryEntry(this._handle, key, value)
   }
 }

package/lib/format-context.js

@@ -4,6 +4,7 @@ const ReferenceCounted = require('./reference-counted')
 const OutputFormat = require('./output-format')
 const IOContext = require('./io-context')
 const InputFormat = require('./input-format')
+const Dictionary = require('./dictionary')
 
 class FFmpegFormatContext extends ReferenceCounted {
   constructor(io) {
@@ -42,12 +43,6 @@ class FFmpegFormatContext extends ReferenceCounted {
   }
 
   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
     }
@@ -86,14 +81,20 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
   constructor(io, options, url = defaultURL) {
     if (io instanceof IOContext) {
       super(io)
+
       this._handle = binding.openInputFormatContextWithIO(io._handle)
     } else if (io instanceof InputFormat) {
       super()
+
+      options = options || new Dictionary()
+
       this._handle = binding.openInputFormatContextWithFormat(
         io._handle,
         options._handle,
         url
       )
+
+      options.destroy()
     }
 
     for (const handle of binding.getFormatContextStreams(this._handle)) {

package/lib/frame.js

@@ -13,47 +13,39 @@ module.exports = class FFmpegFrame extends ReferenceCounted {
     this._handle = null
   }
 
-  channel(i) {
-    if (i < 0 || i > 7) {
-      throw new RangeError(`Channel index must be between 0 and 7`)
-    }
-
-    return Buffer.from(binding.getFrameChannel(this._handle, i))
+  get width() {
+    return binding.getFrameWidth(this._handle)
   }
 
   set width(value) {
     binding.setFrameWidth(this._handle, value)
   }
 
-  get width() {
-    return binding.getFrameWidth(this._handle)
+  get height() {
+    return binding.getFrameHeight(this._handle)
   }
 
   set height(value) {
     binding.setFrameHeight(this._handle, value)
   }
 
-  get height() {
-    return binding.getFrameHeight(this._handle)
+  get pixelFormat() {
+    return binding.getFramePixelFormat(this._handle)
   }
 
   set pixelFormat(value) {
     binding.setFramePixelFormat(this._handle, value)
   }
 
-  get pixelFormat() {
-    return binding.getFramePixelFormat(this._handle)
-  }
+  audioChannel(i) {
+    if (i < 0 || i > 7) {
+      throw new RangeError(`Channel index must be between 0 and 7`)
+    }
 
-  lineSize(channel) {
-    return binding.getFrameLineSize(this._handle, channel)
+    return Buffer.from(binding.getFrameAudioChannel(this._handle, i))
   }
 
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
-
-  get data() {
-    return Buffer.from(binding.getFrameData(this._handle))
-  }
 }

package/lib/image.js

@@ -44,4 +44,12 @@ module.exports = class FFmpegImage {
       frame._handle
     )
   }
+
+  lineSize(plane = 0) {
+    return binding.getImageLineSize(this._pixelFormat, this._width, plane)
+  }
+
+  static lineSize(pixelFormat, width, plane = 0) {
+    return binding.getImageLineSize(pixelFormat, width, plane)
+  }
 }

package/lib/input-format.js

@@ -16,9 +16,6 @@ switch (Bare.platform) {
 
 module.exports = class FFmpegInputFormat {
   constructor(name = defaultName) {
-    if (typeof name !== 'string' || name.length < 1) {
-      throw new TypeError('Input format name should be a non empty string')
-    }
     this._handle = binding.initInputFormat(name)
   }
 }

package/lib/packet.js

@@ -6,12 +6,6 @@ module.exports = class FFmpegPacket extends ReferenceCounted {
     super()
 
     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,

package/package.json

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