bare-ffmpeg 1.0.0-2 → 1.0.0-4

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;
@@ -1366,6 +1373,51 @@ bare_ffmpeg_frame_get_channel(js_env_t *env, js_callback_info_t *info) {
   return result;
 }
 
+static js_value_t *
+bare_ffmpeg_frame_get_image_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_frame_get_width(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -1375,6 +1427,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 +1450,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 +1475,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 +1498,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 +1523,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 +1546,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,6 +1562,37 @@ 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;
@@ -1513,23 +1602,22 @@ 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;
@@ -1636,6 +1724,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;
@@ -1659,6 +1748,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);
@@ -1749,14 +1839,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 *
@@ -1910,6 +2001,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;
@@ -1930,6 +2022,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;
@@ -1957,6 +2050,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);
 
@@ -1972,6 +2066,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;
@@ -1989,12 +2084,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;
   }
 
@@ -2068,13 +2165,15 @@ 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("getFrameImageData", bare_ffmpeg_frame_get_image_data)
   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("initImage", bare_ffmpeg_image_init)
@@ -2110,6 +2209,7 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(AV_CODEC_ID_H264)
 
   V(AV_PIX_FMT_RGBA)
+  V(AV_PIX_FMT_RGB24)
   V(AV_PIX_FMT_YUVJ420P)
   V(AV_PIX_FMT_YUV420P)
 

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,36 +13,44 @@ 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`)
+    }
+
+    return Buffer.from(binding.getFrameAudioChannel(this._handle, i))
+  }
+
+  imageData() {
+    return Buffer.from(binding.getFrameImageData(this._handle))
+  }
+
+  lineSize(channel) {
+    return binding.getFrameLineSize(this._handle, channel)
   }
 
   alloc() {

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-2",
+  "version": "1.0.0-4",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",