bare-ffmpeg 1.0.0-0 → 1.0.0-1

package/binding.c

@@ -6,14 +6,17 @@
 #include <libavcodec/codec_id.h>
 #include <libavcodec/codec_par.h>
 #include <libavcodec/packet.h>
+#include <libavdevice/avdevice.h>
 #include <libavformat/avformat.h>
 #include <libavformat/avio.h>
+#include <libavutil/dict.h>
 #include <libavutil/error.h>
 #include <libavutil/frame.h>
 #include <libavutil/imgutils.h>
 #include <libavutil/log.h>
 #include <libavutil/mem.h>
 #include <libavutil/pixfmt.h>
+#include <libavutil/rational.h>
 #include <libswscale/swscale.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -23,6 +26,14 @@ typedef struct {
   AVIOContext *handle;
 } bare_ffmpeg_io_context_t;
 
+typedef struct {
+  const AVOutputFormat *handle;
+} bare_ffmpeg_output_format_t;
+
+typedef struct {
+  const AVInputFormat *handle;
+} bare_ffmpeg_input_format_t;
+
 typedef struct {
   AVFormatContext *handle;
 } bare_ffmpeg_format_context_t;
@@ -55,11 +66,16 @@ typedef struct {
   struct SwsContext *handle;
 } bare_ffmpeg_scaler_t;
 
+typedef struct {
+  struct AVDictionary *handle;
+} bare_ffmpeg_dictionary_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();
 }
 
 static js_value_t *
@@ -125,7 +141,95 @@ bare_ffmpeg_io_context_destroy(js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-bare_ffmpeg_format_context_init(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_output_format_init(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);
+
+  size_t len;
+  err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *name = malloc(len);
+  err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
+  assert(err == 0);
+
+  const AVOutputFormat *format = av_guess_format((const char *) name, NULL, NULL);
+
+  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;
+
+  bare_ffmpeg_output_format_t *context;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_output_format_t), (void **) &context, &handle);
+  assert(err == 0);
+
+  context->handle = format;
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_input_format_init(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);
+
+  size_t len;
+  err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *name = malloc(len);
+  err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
+  assert(err == 0);
+
+  const AVInputFormat *format = av_find_input_format((const char *) name);
+
+  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;
+
+  bare_ffmpeg_input_format_t *context;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_input_format_t), (void **) &context, &handle);
+  assert(err == 0);
+
+  context->handle = format;
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_format_context_open_input(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -177,7 +281,7 @@ bare_ffmpeg_format_context_init(js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-bare_ffmpeg_format_context_destroy(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_format_context_close_input(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -197,6 +301,68 @@ bare_ffmpeg_format_context_destroy(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
+static js_value_t *
+bare_ffmpeg_format_context_open_output(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_output_format_t *format;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
+  assert(err == 0);
+
+  bare_ffmpeg_io_context_t *io;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &io, 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);
+
+  err = avformat_alloc_output_context2(&context->handle, format->handle, NULL, NULL);
+
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  context->handle->pb = io->handle;
+  context->handle->opaque = (void *) context;
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_format_context_close_output(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_format_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  avformat_free_context(context->handle);
+
+  return NULL;
+}
+
 static js_value_t *
 bare_ffmpeg_format_context_get_streams(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -235,6 +401,44 @@ 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_create_stream(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);
+
+  bare_ffmpeg_codec_t *codec;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &codec, NULL);
+  assert(err == 0);
+
+  js_value_t *handle;
+
+  bare_ffmpeg_stream_t *stream;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &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);
+
+    return NULL;
+  }
+
+  return handle;
+}
+
 static js_value_t *
 bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -259,12 +463,16 @@ bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
 
   err = av_read_frame(context->handle, &packet->handle);
 
-  if (err < 0) {
+  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 *
@@ -393,22 +601,18 @@ static js_value_t *
 bare_ffmpeg_codec_context_init(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  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 == 2);
+  assert(argc == 1);
 
   bare_ffmpeg_codec_t *codec;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &codec, NULL);
   assert(err == 0);
 
-  bare_ffmpeg_codec_parameters_t *parameters;
-  err = js_get_arraybuffer_info(env, argv[1], (void **) &parameters, NULL);
-  assert(err == 0);
-
   js_value_t *handle;
 
   bare_ffmpeg_codec_context_t *context;
@@ -419,33 +623,32 @@ bare_ffmpeg_codec_context_init(js_env_t *env, js_callback_info_t *info) {
 
   context->handle->opaque = (void *) context;
 
-  err = avcodec_parameters_to_context(context->handle, parameters->handle);
-
-  if (err < 0) {
-    avcodec_free_context(&context->handle);
+  return handle;
+}
 
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
+static js_value_t *
+bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
+  int err;
 
-    return NULL;
-  }
+  size_t argc = 1;
+  js_value_t *argv[1];
 
-  err = avcodec_open2(context->handle, codec->handle, NULL);
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
 
-  if (err < 0) {
-    avcodec_free_context(&context->handle);
+  assert(argc == 1);
 
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
+  bare_ffmpeg_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
 
-    return NULL;
-  }
+  avcodec_free_context(&context->handle);
 
-  return handle;
+  return NULL;
 }
 
 static js_value_t *
-bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -460,7 +663,12 @@ bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
   err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
   assert(err == 0);
 
-  avcodec_free_context(&context->handle);
+  err = avcodec_open2(context->handle, context->handle->codec, NULL);
+
+  if (err < 0) {
+    err = js_throw_error(env, NULL, av_err2str(err));
+    assert(err == 0);
+  }
 
   return NULL;
 }
@@ -489,30 +697,32 @@ bare_ffmpeg_codec_context_get_pixel_format(js_env_t *env, js_callback_info_t *in
 }
 
 static js_value_t *
-bare_ffmpeg_codec_context_get_width(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  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 == 1);
+  assert(argc == 2);
 
   bare_ffmpeg_codec_context_t *context;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
   assert(err == 0);
 
-  js_value_t *result;
-  err = js_create_int64(env, context->handle->width, &result);
+  int64_t value;
+  err = js_get_value_int64(env, argv[1], &value);
   assert(err == 0);
 
-  return result;
+  context->handle->pix_fmt = value;
+
+  return NULL;
 }
 
 static js_value_t *
-bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_get_width(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -528,14 +738,14 @@ bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_int64(env, context->handle->height, &result);
+  err = js_create_int64(env, context->handle->width, &result);
   assert(err == 0);
 
   return result;
 }
 
 static js_value_t *
-bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_set_width(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 2;
@@ -550,69 +760,460 @@ bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
   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);
+  int64_t value;
+  err = js_get_value_int64(env, argv[1], &value);
   assert(err == 0);
 
-  err = avcodec_send_packet(context->handle, &packet->handle);
-
-  if (err < 0) {
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
-  }
+  context->handle->width = value;
 
   return NULL;
 }
 
 static js_value_t *
-bare_ffmpeg_codec_context_receive_frame(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  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 == 2);
+  assert(argc == 1);
 
   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);
+  js_value_t *result;
+  err = js_create_int64(env, context->handle->height, &result);
   assert(err == 0);
 
-  err = avcodec_receive_frame(context->handle, frame->handle);
-
-  if (err < 0) {
-    err = js_throw_error(env, NULL, av_err2str(err));
-    assert(err == 0);
-  }
-
-  return NULL;
+  return result;
 }
 
 static js_value_t *
-bare_ffmpeg_frame_init(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_codec_context_set_height(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  js_value_t *handle;
-
+  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);
+
+  int64_t value;
+  err = js_get_value_int64(env, argv[1], &value);
+  assert(err == 0);
+
+  context->handle->height = value;
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_context_get_time_base(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_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+
+  int32_t *data;
+  err = js_create_arraybuffer(env, 2 * sizeof(int32_t), (void **) &data, &result);
+  assert(err == 0);
+
+  data[0] = context->handle->time_base.num;
+  data[1] = context->handle->time_base.den;
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_context_set_time_base(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);
+
+  int32_t *value;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &value, NULL);
+  assert(err == 0);
+
+  context->handle->time_base.num = value[0];
+  context->handle->time_base.den = value[1];
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_context_send_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_send_packet(context->handle, &packet->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_receive_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_receive_frame(context->handle, frame->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_parameters_from_context(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_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  bare_ffmpeg_codec_context_t *context;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &context, NULL);
+  assert(err == 0);
+
+  err = avcodec_parameters_from_context(parameters->handle, context->handle);
+
+  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_codec_parameters_to_context(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_codec_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  err = avcodec_parameters_to_context(context->handle, parameters->handle);
+
+  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_codec_parameters_get_bit_rate(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_codec_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int64(env, parameters->handle->bit_rate, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_parameters_get_bits_per_coded_sample(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_codec_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int64(env, parameters->handle->bits_per_coded_sample, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_parameters_get_bits_per_raw_sample(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_codec_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int64(env, parameters->handle->bits_per_raw_sample, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_codec_parameters_get_sample_rate(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_codec_parameters_t *parameters;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int64(env, parameters->handle->sample_rate, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  js_value_t *handle;
+
+  bare_ffmpeg_frame_t *frame;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_frame_t), (void **) &frame, &handle);
+  assert(err == 0);
+
+  frame->handle = av_frame_alloc();
+
+  frame->handle->opaque = (void *) frame;
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_destroy(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_create_arraybuffer(env, sizeof(bare_ffmpeg_frame_t), (void **) &frame, &handle);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
   assert(err == 0);
 
-  frame->handle = av_frame_alloc();
+  av_frame_free(&frame->handle);
 
-  frame->handle->opaque = (void *) frame;
+  return NULL;
+}
 
-  return handle;
+static js_value_t *
+bare_ffmpeg_frame_get_channel(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 i;
+  err = js_get_value_uint32(env, argv[1], &i);
+  assert(err == 0);
+
+  assert(i < AV_NUM_DATA_POINTERS);
+
+  js_value_t *result;
+
+  size_t len = frame->handle->linesize[i];
+
+  void *data;
+  err = js_create_unsafe_arraybuffer(env, len, &data, &result);
+  assert(err == 0);
+
+  memcpy(data, frame->handle->data[i], len);
+
+  return result;
 }
 
 static js_value_t *
-bare_ffmpeg_frame_destroy(js_env_t *env, js_callback_info_t *info) {
+bare_ffmpeg_frame_get_width(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);
+
+  js_value_t *result;
+  err = js_create_int32(env, frame->handle->width, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_set_width(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);
+
+  int32_t width;
+  err = js_get_value_int32(env, argv[1], &width);
+  assert(err == 0);
+
+  frame->handle->width = width;
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_get_height(js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -620,14 +1221,116 @@ bare_ffmpeg_frame_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_frame_t *frame;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int32(env, frame->handle->height, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_set_height(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);
+
+  int32_t height;
+  err = js_get_value_int32(env, argv[1], &height);
+  assert(err == 0);
 
+  frame->handle->height = height;
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_get_pixel_format(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);
 
-  av_frame_free(&frame->handle);
+  js_value_t *result;
+  err = js_create_int64(env, frame->handle->format, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_set_pixel_format(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);
+
+  int64_t pixel_format;
+  err = js_get_value_int64(env, argv[1], &pixel_format);
+  assert(err == 0);
+
+  frame->handle->format = (enum AVPixelFormat) pixel_format;
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_frame_alloc(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);
+  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;
 }
@@ -892,6 +1595,124 @@ bare_ffmpeg_scaler_scale(js_env_t *env, js_callback_info_t *info) {
   return result;
 }
 
+static js_value_t *
+bare_ffmpeg_dictionary_init(js_env_t *env, js_callback_info_t *info) {
+  int err;
+  js_value_t *handle;
+
+  bare_ffmpeg_dictionary_t *dict;
+  err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_dictionary_t), (void **) &dict, &handle);
+  assert(err == 0);
+
+  dict->handle = NULL;
+
+  return handle;
+}
+
+static js_value_t *
+bare_ffmpeg_dictionary_destroy(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_dictionary_t *dict;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
+  assert(err == 0);
+
+  av_dict_free(&dict->handle);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_dictionary_set_entry(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_dictionary_t *dict;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
+  assert(err == 0);
+
+  size_t len;
+  err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *key = malloc(len);
+  err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
+  assert(err == 0);
+
+  err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *value = malloc(len);
+  err = js_get_value_string_utf8(env, argv[2], value, len, NULL);
+  assert(err == 0);
+
+  err = av_dict_set(&dict->handle, (const char *) key, (const char *) value, 0);
+  assert(err == 0);
+  free(key);
+  free(value);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_ffmpeg_dictionary_get_entry(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_dictionary_t *dict;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
+  assert(err == 0);
+
+  size_t len;
+  err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
+  assert(err == 0);
+
+  len += +1 /* NULL */;
+
+  utf8_t *key = malloc(len);
+  err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
+  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;
+  }
+
+  js_value_t *result;
+  err = js_create_string_utf8(env, (const utf8_t *) entry->value, -1, &result);
+  assert(err == 0);
+
+  return result;
+}
+
 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);
@@ -910,9 +1731,15 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("initIOContext", bare_ffmpeg_io_context_init)
   V("destroyIOContext", bare_ffmpeg_io_context_destroy)
 
-  V("initFormatContext", bare_ffmpeg_format_context_init)
-  V("destroyFormatContext", bare_ffmpeg_format_context_destroy)
+  V("initOutputFormat", bare_ffmpeg_output_format_init)
+  V("initInputFormat", bare_ffmpeg_input_format_init)
+
+  V("openInputFormatContext", bare_ffmpeg_format_context_open_input)
+  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("createFormatContextStream", bare_ffmpeg_format_context_create_stream)
   V("readFormatContextFrame", bare_ffmpeg_format_context_read_frame)
 
   V("getStreamCodec", bare_ffmpeg_stream_get_codec)
@@ -923,14 +1750,35 @@ 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("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)
+  V("setCodecContextWidth", bare_ffmpeg_codec_context_set_width)
   V("getCodecContextHeight", bare_ffmpeg_codec_context_get_height)
+  V("setCodecContextHeight", bare_ffmpeg_codec_context_set_height)
+  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("receiveCodecContextFrame", bare_ffmpeg_codec_context_receive_frame)
 
+  V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
+  V("codecParametersToContext", bare_ffmpeg_codec_parameters_to_context)
+  V("getCodecParametersBitRate", bare_ffmpeg_codec_parameters_get_bit_rate)
+  V("getCodecParametersBitsPerCodedSample", bare_ffmpeg_codec_parameters_get_bits_per_coded_sample)
+  V("getCodecParametersBitsPerRawSample", bare_ffmpeg_codec_parameters_get_bits_per_raw_sample)
+  V("getCodecParametersSampleRate", bare_ffmpeg_codec_parameters_get_sample_rate)
+
   V("initFrame", bare_ffmpeg_frame_init)
   V("destroyFrame", bare_ffmpeg_frame_destroy)
+  V("getFrameChannel", bare_ffmpeg_frame_get_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("allocFrame", bare_ffmpeg_frame_alloc)
 
   V("initImage", bare_ffmpeg_image_init)
   V("fillImage", bare_ffmpeg_image_fill)
@@ -942,6 +1790,11 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("initScaler", bare_ffmpeg_scaler_init)
   V("destroyScaler", bare_ffmpeg_scaler_destroy)
   V("scaleScaler", bare_ffmpeg_scaler_scale)
+
+  V("initDictionary", bare_ffmpeg_dictionary_init)
+  V("destroyDictionary", bare_ffmpeg_dictionary_destroy)
+  V("getDictionaryEntry", bare_ffmpeg_dictionary_get_entry)
+  V("setDictionaryEntry", bare_ffmpeg_dictionary_set_entry)
 #undef V
 
 #define V(name) \
@@ -953,7 +1806,11 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
     assert(err == 0); \
   }
 
+  V(AV_CODEC_ID_MJPEG)
+
   V(AV_PIX_FMT_RGBA)
+  V(AV_PIX_FMT_YUVJ420P)
+  V(AV_PIX_FMT_YUV420P)
 #undef V
 
   return exports;