@lumen5/beamcoder 0.0.1

package/src/mux.cc

@@ -0,0 +1,834 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+#include "mux.h"
+
+int write_packet(void *opaque, uint8_t *buf, int buf_size)
+{
+  Adaptor *adaptor = (Adaptor *)opaque;
+  return adaptor->write(buf, buf_size);
+}
+
+napi_value muxer(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, prop, subprop;
+  int ret;
+  AVOutputFormat* oformat = nullptr;
+  char* formatName = nullptr;
+  char* filename = nullptr;
+  size_t strLen;
+  napi_valuetype type;
+  bool isArray;
+  AVFormatContext* fmtCtx = nullptr;
+  Adaptor *adaptor = nullptr;
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  CHECK_STATUS;
+  if (argc != 1) {
+    NAPI_THROW_ERROR("Muxer can only be allocated with a single options object.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+  if (isArray || (type != napi_object)) {
+    NAPI_THROW_ERROR("Muxer must be allocated be a single options object.");
+  }
+  status = napi_get_named_property(env, args[0], "format_name", &prop);
+  CHECK_STATUS;
+  status = napi_typeof(env, prop, &type);
+  CHECK_STATUS;
+  if (type == napi_undefined) {
+    status = napi_get_named_property(env, args[0], "name", &prop);
+    CHECK_STATUS;
+    status = napi_typeof(env, prop, &type);
+    CHECK_STATUS;
+  }
+  if (type == napi_string) { // Found a name property
+    status = napi_get_value_string_utf8(env, prop, nullptr, 0, &strLen);
+    CHECK_STATUS;
+    formatName = (char*) malloc(sizeof(char) * (strLen + 1));
+    status = napi_get_value_string_utf8(env, prop, formatName, strLen + 1, &strLen);
+    CHECK_STATUS;
+  }
+
+  status = napi_get_named_property(env, args[0], "filename", &prop);
+  CHECK_STATUS;
+  status = napi_typeof(env, prop, &type);
+  CHECK_STATUS;
+  if (type == napi_string) {
+    status = napi_get_value_string_utf8(env, prop, nullptr, 0, &strLen);
+    CHECK_STATUS;
+    filename = (char*) malloc(sizeof(char) * (strLen + 1));
+    status = napi_get_value_string_utf8(env, prop, filename, strLen + 1, &strLen);
+    CHECK_STATUS;
+  }
+
+  status = napi_get_named_property(env, args[0], "oformat", &prop);
+  CHECK_STATUS;
+  status = napi_typeof(env, prop, &type);
+  CHECK_STATUS;
+  status = napi_is_array(env, prop, &isArray);
+  CHECK_STATUS;
+  if (!isArray && (type == napi_object)) {
+    status = napi_get_named_property(env, prop, "_oformat", &subprop);
+    CHECK_STATUS;
+    status = napi_typeof(env, subprop, &type);
+    CHECK_STATUS;
+    if (type == napi_external) {
+      status = napi_get_value_external(env, subprop, (void**) &oformat);
+      CHECK_STATUS;
+    }
+  }
+
+  status = napi_get_named_property(env, args[0], "governor", &prop);
+  CHECK_STATUS;
+  status = napi_typeof(env, prop, &type);
+  CHECK_STATUS;
+  if (type == napi_object) {
+    napi_value adaptorValue;
+    status = napi_get_named_property(env, prop, "_adaptor", &adaptorValue);
+    CHECK_STATUS;
+    status = napi_typeof(env, adaptorValue, &type);
+    CHECK_STATUS;
+    if (type == napi_external) {
+      status = napi_get_value_external(env, adaptorValue, (void**)&adaptor);
+      CHECK_STATUS;
+    } else if (type != napi_undefined) {
+      NAPI_THROW_ERROR("Adaptor must be of external type when specified.");
+    }
+  }
+
+  AVIOContext* avio_ctx = nullptr;
+  if (adaptor) {
+    avio_ctx = avio_alloc_context(adaptor->buf(), adaptor->bufLen(), 1, adaptor, nullptr, &write_packet, nullptr);
+    if (!avio_ctx) {
+      NAPI_THROW_ERROR("Problem allocating muxer stream output context.");
+    }
+  }
+  ret = avformat_alloc_output_context2(&fmtCtx, oformat, formatName, filename);
+
+  free(formatName);
+  free(filename);
+
+  if (ret < 0) {
+    NAPI_THROW_ERROR(avErrorMsg("Error allocating muxer context: ", ret));
+  }
+
+  fmtCtx->pb = avio_ctx;
+
+  status = fromAVFormatContext(env, fmtCtx, adaptor, &result);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "openIO", NAPI_AUTO_LENGTH,
+    openIO, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "openIO", prop);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "writeHeader", NAPI_AUTO_LENGTH,
+    writeHeader, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "writeHeader", prop);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "initOutput", NAPI_AUTO_LENGTH,
+    initOutput, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "initOutput", prop);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "writeFrame", NAPI_AUTO_LENGTH,
+    writeFrame, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "writeFrame", prop);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "writeTrailer", NAPI_AUTO_LENGTH,
+    writeTrailer, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "writeTrailer", prop);
+  CHECK_STATUS;
+
+  status = napi_create_function(env, "forceClose", NAPI_AUTO_LENGTH,
+    forceClose, nullptr, &prop);
+  CHECK_STATUS;
+  status = napi_set_named_property(env, result, "forceClose", prop);
+  CHECK_STATUS;
+
+  return result;
+}
+
+void openIOExecute(napi_env env, void* data) {
+  openIOCarrier* c = (openIOCarrier*) data;
+  int ret;
+  if (c->format->pb == nullptr) {
+    ret = avio_open2(&c->format->pb, c->format->url, c->flags, nullptr, &c->options);
+    if (ret < 0) {
+      c->status = BEAMCODER_ERROR_OPENIO;
+      c->errorMsg = avErrorMsg("Problem opening IO context: ", ret);
+    }
+  }
+}
+
+void openIOComplete(napi_env env, napi_status asyncStatus, void* data) {
+  napi_value result, unset;
+  openIOCarrier* c = (openIOCarrier*) data;
+  AVDictionaryEntry* tag = nullptr;
+
+  if (asyncStatus != napi_ok) {
+    c->status = asyncStatus;
+    c->errorMsg = "Open IO failed to complete.";
+  }
+  REJECT_STATUS;
+
+  if (c->options != nullptr) {
+    c->status = napi_create_object(env, &result);
+    REJECT_STATUS;
+    c->status = napi_create_object(env, &unset);
+    REJECT_STATUS;
+    c->status = napi_set_named_property(env, result, "unset", unset);
+    REJECT_STATUS;
+    while ((tag = av_dict_get(c->options, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+      c->status = beam_set_string_utf8(env, unset, tag->key, tag->value);
+      REJECT_STATUS;
+    }
+  } else {
+    c->status = napi_get_undefined(env, &result);
+    REJECT_STATUS;
+  }
+
+  napi_status status;
+  status = napi_resolve_deferred(env, c->_deferred, result);
+  FLOATING_STATUS;
+
+  tidyCarrier(env, c);
+}
+
+napi_value openIO(napi_env env, napi_callback_info info) {
+  napi_value promise, formatJS, formatExt, resourceName, prop;
+  napi_valuetype type;
+  bool isArray, present, flag;
+  size_t strLen;
+  openIOCarrier* c = new openIOCarrier;
+
+  c->status = napi_create_promise(env, &c->_deferred, &promise);
+  REJECT_RETURN;
+
+  size_t argc = 0;
+  c->status = napi_get_cb_info(env, info, &argc, nullptr, &formatJS, nullptr);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, formatExt, (void**) &c->format);
+  REJECT_RETURN;
+
+  if (argc > 0) { // Possible options, url and flags
+    napi_value args[1];
+    argc = 1;
+    c->status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, args[0], &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, args[0], &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) {
+      REJECT_ERROR_RETURN("OpenIO can only be provided with a single options object.",
+        BEAMCODER_INVALID_ARGS);
+    }
+
+    c->status = napi_get_named_property(env, args[0], "url", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    if (type == napi_string) {
+      c->status = napi_get_value_string_utf8(env, prop, nullptr, 0, &strLen);
+      REJECT_RETURN;
+      c->format->url = (char*) av_malloc(sizeof(char) * (strLen + 1));
+      c->status = napi_get_value_string_utf8(env, prop, c->format->url, strLen + 1, &strLen);
+      REJECT_RETURN;
+    }
+
+    c->status = napi_get_named_property(env, args[0], "filename", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    if (type == napi_string) {
+      c->status = napi_get_value_string_utf8(env, prop, nullptr, 0, &strLen);
+      REJECT_RETURN;
+      c->format->url = (char*) av_malloc(sizeof(char) * (strLen + 1));
+      c->status = napi_get_value_string_utf8(env, prop, c->format->url, strLen + 1, &strLen);
+      REJECT_RETURN;
+    }
+
+    c->status = napi_get_named_property(env, args[0], "options", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, prop, &isArray);
+    REJECT_RETURN;
+    if (!isArray && (type == napi_object)) {
+      c->status = makeAVDictionary(env, prop, &c->options);
+      REJECT_RETURN;
+    }
+
+    c->status = napi_get_named_property(env, args[0], "flags", &prop);
+    REJECT_RETURN
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, prop, &isArray);
+    REJECT_RETURN;
+    if (!isArray && (type == napi_object)) {
+      c->status = beam_get_bool(env, prop, "READ", &present, &flag);
+      REJECT_RETURN;
+      if (present) { c->flags = (flag) ?
+        c->flags | AVIO_FLAG_READ :
+        c->flags & ~AVIO_FLAG_READ; }
+      c->status = beam_get_bool(env, prop, "WRITE", &present, &flag);
+      REJECT_RETURN;
+      if (present) { c->flags = (flag) ?
+        c->flags | AVIO_FLAG_WRITE :
+        c->flags & ~AVIO_FLAG_WRITE; }
+      c->status = beam_get_bool(env, prop, "NONBLOCK", &present, &flag);
+      REJECT_RETURN;
+      if (present) { c->flags = (flag) ?
+        c->flags | AVIO_FLAG_NONBLOCK :
+        c->flags & ~AVIO_FLAG_NONBLOCK; }
+      c->status = beam_get_bool(env, prop, "DIRECT", &present, &flag);
+      REJECT_RETURN;
+      if (present) { c->flags = (flag) ?
+        c->flags | AVIO_FLAG_DIRECT :
+        c->flags & ~AVIO_FLAG_DIRECT; }
+    }
+  }
+
+  if ((c->format->url == nullptr) && (c->format->pb == nullptr)) {
+    REJECT_ERROR_RETURN("Cannot open muxer IO without a URL or filename.",
+      BEAMCODER_INVALID_ARGS);
+  }
+
+  c->status = napi_create_string_utf8(env, "OpenIO", NAPI_AUTO_LENGTH, &resourceName);
+  REJECT_RETURN;
+  c->status = napi_create_async_work(env, nullptr, resourceName, openIOExecute,
+    openIOComplete, c, &c->_request);
+  REJECT_RETURN;
+  c->status = napi_queue_async_work(env, c->_request);
+  REJECT_RETURN;
+
+  return promise;
+}
+
+void writeHeaderExecute(napi_env env, void* data) {
+  writeHeaderCarrier* c = (writeHeaderCarrier*) data;
+
+  c->result = avformat_write_header(c->format, &c->options);
+  if (c->result < 0) {
+    c->status = BEAMCODER_ERROR_WRITE_HEADER;
+    c->errorMsg = avErrorMsg("Failed to write header: ", c->result);
+    return;
+  }
+}
+
+void writeHeaderComplete(napi_env env, napi_status asyncStatus, void* data) {
+  napi_value result, unset, initIn;
+  writeHeaderCarrier* c = (writeHeaderCarrier*) data;
+  AVDictionaryEntry* tag = nullptr;
+
+  if (asyncStatus != napi_ok) {
+    c->status = asyncStatus;
+    c->errorMsg = "Write header failed to complete.";
+  }
+  REJECT_STATUS;
+
+  c->status = napi_create_object(env, &result);
+  REJECT_STATUS;
+
+  c->status = napi_create_string_utf8(env,
+    (c->result == AVSTREAM_INIT_IN_WRITE_HEADER) ? "WRITE_HEADER" : "INIT_OUTPUT",
+    NAPI_AUTO_LENGTH, &initIn);
+  REJECT_STATUS;
+  c->status = napi_set_named_property(env, result, "INIT_IN", initIn);
+  REJECT_STATUS;
+
+  if (c->options != nullptr) {
+    c->status = napi_create_object(env, &unset);
+    REJECT_STATUS;
+    c->status = napi_set_named_property(env, result, "unset", unset);
+    REJECT_STATUS;
+    while ((tag = av_dict_get(c->options, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+      c->status = beam_set_string_utf8(env, unset, tag->key, tag->value);
+      REJECT_STATUS;
+    }
+  }
+
+  napi_status status;
+  status = napi_resolve_deferred(env, c->_deferred, result);
+  FLOATING_STATUS;
+
+  tidyCarrier(env, c);
+}
+
+napi_value writeHeader(napi_env env, napi_callback_info info) {
+  napi_value promise, formatJS, formatExt, resourceName, prop;
+  napi_valuetype type;
+  bool isArray;
+  writeHeaderCarrier* c = new writeHeaderCarrier;
+
+  c->status = napi_create_promise(env, &c->_deferred, &promise);
+  REJECT_RETURN;
+
+  size_t argc = 0;
+  c->status = napi_get_cb_info(env, info, &argc, nullptr, &formatJS, nullptr);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, formatExt, (void**) &c->format);
+  REJECT_RETURN;
+
+  if (argc > 0) { // Possible options
+    napi_value args[1];
+    argc = 1;
+    c->status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, args[0], &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, args[0], &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) {
+      REJECT_ERROR_RETURN("Write header can only be provided with a single options object.",
+        BEAMCODER_INVALID_ARGS);
+    }
+
+    c->status = napi_get_named_property(env, args[0], "options", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, prop, &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) { // Allow flat or nested options
+      prop = args[0];
+    }
+    c->status = makeAVDictionary(env, prop, &c->options);
+    REJECT_RETURN;
+  }
+
+  c->status = napi_create_string_utf8(env, "WriteHeader", NAPI_AUTO_LENGTH, &resourceName);
+  REJECT_RETURN;
+  c->status = napi_create_async_work(env, nullptr, resourceName, writeHeaderExecute,
+    writeHeaderComplete, c, &c->_request);
+  REJECT_RETURN;
+  c->status = napi_queue_async_work(env, c->_request);
+  REJECT_RETURN;
+
+  return promise;
+}
+
+void initOutputExecute(napi_env env, void* data) {
+  initOutputCarrier* c = (initOutputCarrier*) data;
+
+  c->result = avformat_init_output(c->format, &c->options);
+  if (c->result < 0) {
+    c->status = BEAMCODER_ERROR_INIT_OUTPUT;
+    c->errorMsg = avErrorMsg("Failed to initialize output: ", c->result);
+    return;
+  }
+}
+
+void initOutputComplete(napi_env env, napi_status asyncStatus, void* data) {
+  napi_value result, initIn, unset;
+  AVDictionaryEntry* tag = nullptr;
+  initOutputCarrier* c = (initOutputCarrier*) data;
+
+  if (asyncStatus != napi_ok) {
+    c->status = asyncStatus;
+    c->errorMsg = "Initialize output failed to complete.";
+  }
+  REJECT_STATUS;
+
+  c->status = napi_create_object(env, &result);
+  REJECT_STATUS;
+
+  c->status = napi_create_string_utf8(env,
+    (c->result == AVSTREAM_INIT_IN_WRITE_HEADER) ? "WRITE_HEADER" : "INIT_OUTPUT",
+    NAPI_AUTO_LENGTH, &initIn);
+  REJECT_STATUS;
+  c->status = napi_set_named_property(env, result, "INIT_IN", initIn);
+  REJECT_STATUS;
+
+  if (c->options != nullptr) {
+    c->status = napi_create_object(env, &unset);
+    REJECT_STATUS;
+    c->status = napi_set_named_property(env, result, "unset", unset);
+    REJECT_STATUS;
+    while ((tag = av_dict_get(c->options, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+      c->status = beam_set_string_utf8(env, unset, tag->key, tag->value);
+      REJECT_STATUS;
+    }
+  }
+
+  napi_status status;
+  status = napi_resolve_deferred(env, c->_deferred, result);
+  FLOATING_STATUS;
+
+  tidyCarrier(env, c);
+}
+
+napi_value initOutput(napi_env env, napi_callback_info info) {
+  napi_value promise, formatJS, formatExt, resourceName, prop;
+  napi_valuetype type;
+  bool isArray;
+  initOutputCarrier* c = new initOutputCarrier;
+
+  c->status = napi_create_promise(env, &c->_deferred, &promise);
+  REJECT_RETURN;
+
+  size_t argc = 0;
+  c->status = napi_get_cb_info(env, info, &argc, nullptr, &formatJS, nullptr);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, formatExt, (void**) &c->format);
+  REJECT_RETURN;
+
+  if (argc > 0) { // Possible options
+    napi_value args[1];
+    argc = 1;
+    c->status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, args[0], &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, args[0], &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) {
+      REJECT_ERROR_RETURN("Initialize output can only be provided with a single options object.",
+        BEAMCODER_INVALID_ARGS);
+    }
+
+    c->status = napi_get_named_property(env, args[0], "options", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, prop, &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) { // Allow flat or nested options
+      prop = args[0];
+    }
+    c->status = makeAVDictionary(env, prop, &c->options);
+    REJECT_RETURN;
+  }
+
+  c->status = napi_create_string_utf8(env, "InitOutput", NAPI_AUTO_LENGTH, &resourceName);
+  REJECT_RETURN;
+  c->status = napi_create_async_work(env, nullptr, resourceName, initOutputExecute,
+    initOutputComplete, c, &c->_request);
+  REJECT_RETURN;
+  c->status = napi_queue_async_work(env, c->_request);
+  REJECT_RETURN;
+
+  return promise;
+}
+
+void writeFrameExecute(napi_env env, void* data) {
+  writeFrameCarrier* c = (writeFrameCarrier*) data;
+  int ret;
+
+  if (c->interleaved) {
+    if (c->packet != nullptr) {
+      ret = av_interleaved_write_frame(c->format, c->packet);
+    } else if (c->frame != nullptr) {
+      ret = av_interleaved_write_uncoded_frame(c->format, c->streamIndex, c->frame);
+    } else {
+      ret = av_interleaved_write_frame(c->format, nullptr); // flush
+    }
+  } else {
+    if (c->packet != nullptr) {
+      ret = av_write_frame(c->format, c->packet);
+    } else if (c->frame != nullptr) {
+      ret = av_write_uncoded_frame(c->format, c->streamIndex, c->frame);
+    } else {
+      ret = av_write_frame(c->format, nullptr); // flush
+    }
+  }
+
+  if (ret < 0) {
+    c->status = BEAMCODER_ERROR_WRITE_FRAME;
+    c->errorMsg = avErrorMsg("Error writing frame: ", ret);
+    return;
+  }
+}
+
+void writeFrameComplete(napi_env env, napi_status asyncStatus, void* data) {
+  napi_value result;
+  writeFrameCarrier* c = (writeFrameCarrier*) data;
+
+  if (asyncStatus != napi_ok) {
+    c->status = asyncStatus;
+    c->errorMsg = "Write frame failed to complete.";
+  }
+  REJECT_STATUS;
+
+  // tidy up adaptor chunks if required
+  if (c->adaptor) {
+    c->status = c->adaptor->finaliseBufs(env);
+    REJECT_STATUS;
+  }
+
+  c->status = napi_get_undefined(env, &result);
+  REJECT_STATUS;
+
+  napi_status status;
+  status = napi_resolve_deferred(env, c->_deferred, result);
+  FLOATING_STATUS;
+
+  tidyCarrier(env, c);
+}
+
+napi_value writeFrame(napi_env env, napi_callback_info info) {
+  napi_value promise, formatJS, formatExt, adaptorExt, interleavedJS, resourceName, options, prop;
+  napi_valuetype type;
+  bool isArray;
+  bool hasOptions = false;
+  writeFrameCarrier* c = new writeFrameCarrier;
+  packetData* packetData;
+  frameData* frameData;
+  int ret;
+
+  c->status = napi_create_promise(env, &c->_deferred, &promise);
+  REJECT_RETURN;
+
+  size_t argc = 1;
+  napi_value args[1];
+  c->status = napi_get_cb_info(env, info, &argc, args, &formatJS, nullptr);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, formatExt, (void**) &c->format);
+  REJECT_RETURN;
+
+  c->status = napi_get_named_property(env, formatJS, "_adaptor", &adaptorExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, adaptorExt, (void**)&c->adaptor);
+  REJECT_RETURN;
+
+  c->status = napi_get_named_property(env, formatJS, "interleaved", &interleavedJS);
+  REJECT_RETURN;
+  c->status = napi_get_value_bool(env, interleavedJS, &c->interleaved);
+  REJECT_RETURN;
+
+  if (argc > 0) { // is it a packet, a frame, an options object
+    c->status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, args[0], &type);
+    REJECT_RETURN;
+    c->status = napi_is_array(env, args[0], &isArray);
+    REJECT_RETURN;
+    if (isArray || (type != napi_object)) {
+      REJECT_ERROR_RETURN("Write frame requires a frame, a packet or an options object.",
+        BEAMCODER_INVALID_ARGS);
+    }
+
+    c->status = napi_get_named_property(env, args[0], "packet", &options);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, options, &type);
+    REJECT_RETURN;
+    hasOptions = (type == napi_object);
+    c->status = napi_get_named_property(env,
+      hasOptions ? options : args[0], "_packet", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    if (type == napi_external) {
+      c->status = napi_get_value_external(env, prop, (void**) &packetData);
+      REJECT_RETURN;
+      c->packet = av_packet_alloc();
+      if ((ret = av_packet_ref(c->packet, const_cast<AVPacket*>(packetData->packet)))) {
+        REJECT_ERROR_RETURN(avErrorMsg("Failed to reference packet: ", ret),
+          BEAMCODER_ERROR_ENOMEM);
+      };
+      goto work;
+    }
+
+    c->status = napi_get_named_property(env, args[0], "frame", &options);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, options, &type);
+    REJECT_RETURN;
+    hasOptions = (type == napi_object);
+    c->status = napi_get_named_property(env,
+      hasOptions ? options : args[0], "_frame", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    if (type == napi_external) {
+      c->status = napi_get_value_external(env, prop, (void**) &frameData);
+      REJECT_RETURN;
+      c->frame = av_frame_alloc();
+      if ((ret = av_frame_ref(c->frame, const_cast<AVFrame*>(frameData->frame)))) {
+        REJECT_ERROR_RETURN(avErrorMsg("Failed to reference frame: ", ret),
+          BEAMCODER_ERROR_ENOMEM);
+      };
+    }
+
+    c->status = napi_get_named_property(env,
+      hasOptions ? options : args[0], "stream_index", &prop);
+    REJECT_RETURN;
+    c->status = napi_typeof(env, prop, &type);
+    REJECT_RETURN;
+    if (type == napi_number) {
+      c->status = napi_get_value_int32(env, prop, &c->streamIndex);
+      REJECT_RETURN;
+    }
+    if (c->streamIndex < 0) {
+      REJECT_ERROR_RETURN("Frame for writing must be provided with a stream_index, either as an internal property or in an options object.",
+        BEAMCODER_INVALID_ARGS);
+    }
+  } else {
+    REJECT_ERROR_RETURN("A packet or frame must be provided.",
+      BEAMCODER_INVALID_ARGS);
+  }
+
+work:
+  if ((c->packet != nullptr) || (c->frame != nullptr)) {
+    c->status = napi_create_reference(env, hasOptions ? options : args[0], 1,
+      &c->passthru);
+    REJECT_RETURN;
+  } // Don't garbage collect during write
+
+  c->status = napi_create_string_utf8(env, "WriteFrame", NAPI_AUTO_LENGTH, &resourceName);
+  REJECT_RETURN;
+  c->status = napi_create_async_work(env, nullptr, resourceName, writeFrameExecute,
+    writeFrameComplete, c, &c->_request);
+  REJECT_RETURN;
+  c->status = napi_queue_async_work(env, c->_request);
+  REJECT_RETURN;
+
+  return promise;
+}
+
+void writeTrailerExecute(napi_env env, void* data) {
+  writeTrailerCarrier* c = (writeTrailerCarrier*) data;
+  int retWrite = 0, retClose = 0;
+
+  retWrite = av_write_trailer(c->format);
+  if (c->format->pb != nullptr) {
+    if (c->adaptor) {
+      c->adaptor->finish();
+      avio_context_free(&c->format->pb);
+    }
+    else
+      retClose = avio_closep(&c->format->pb);
+  }
+  if ((retWrite < 0) && (retClose < 0)) {
+    c->status = BEAMCODER_ERROR_WRITE_TRAILER;
+    c->errorMsg = "Errors writing trailer and closing IO.";
+    return;
+  }
+  if (retWrite < 0) {
+    c->status = BEAMCODER_ERROR_WRITE_TRAILER;
+    c->errorMsg = avErrorMsg("Error writing trailer: ", retWrite);
+    return;
+  }
+  if (retClose < 0) {
+    c->status = BEAMCODER_ERROR_WRITE_TRAILER;
+    c->errorMsg = avErrorMsg("Error closing IO: ", retClose);
+    return;
+  }
+}
+
+void writeTrailerComplete(napi_env env, napi_status asyncStatus, void* data) {
+  napi_value result;
+  writeTrailerCarrier* c = (writeTrailerCarrier*) data;
+
+  if (asyncStatus != napi_ok) {
+    c->status = asyncStatus;
+    c->errorMsg = "Write trailer failed to complete.";
+  }
+  REJECT_STATUS;
+
+  c->status = napi_get_undefined(env, &result);
+  REJECT_STATUS;
+
+  napi_status status;
+  status = napi_resolve_deferred(env, c->_deferred, result);
+  FLOATING_STATUS;
+
+  tidyCarrier(env, c);
+}
+
+napi_value writeTrailer(napi_env env, napi_callback_info info) {
+  napi_value promise, formatJS, formatExt, adaptorExt, resourceName;
+  writeTrailerCarrier* c = new writeTrailerCarrier;
+
+  c->status = napi_create_promise(env, &c->_deferred, &promise);
+  REJECT_RETURN;
+
+  size_t argc = 0;
+  c->status = napi_get_cb_info(env, info, &argc, nullptr, &formatJS, nullptr);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, formatExt, (void**) &c->format);
+  REJECT_RETURN;
+  c->status = napi_get_named_property(env, formatJS, "_adaptor", &adaptorExt);
+  REJECT_RETURN;
+  c->status = napi_get_value_external(env, adaptorExt, (void**) &c->adaptor);
+  REJECT_RETURN;
+
+  c->status = napi_create_string_utf8(env, "WriteTrailer", NAPI_AUTO_LENGTH, &resourceName);
+  REJECT_RETURN;
+  c->status = napi_create_async_work(env, nullptr, resourceName, writeTrailerExecute,
+    writeTrailerComplete, c, &c->_request);
+  REJECT_RETURN;
+  c->status = napi_queue_async_work(env, c->_request);
+  REJECT_RETURN;
+
+  return promise;
+}
+
+napi_value forceClose(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, formatJS, formatExt;
+  AVFormatContext* format;
+  int ret;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, &formatJS, nullptr);
+  CHECK_STATUS;
+  status = napi_get_named_property(env, formatJS, "_formatContext", &formatExt);
+  CHECK_STATUS;
+  status = napi_get_value_external(env, formatExt, (void**) &format);
+  CHECK_STATUS;
+
+  if (format->pb != nullptr) {
+    ret = avio_closep(&format->pb);
+    if (ret < 0) {
+      NAPI_THROW_ERROR(avErrorMsg("Failed to force close muxer resource: ", ret));
+    }
+  } else {
+    printf("DEBUG: Muxer IO resource '%s' already closed or not managed by AVIO.\n",
+      (format->url != nullptr) ? format->url : "unknown");
+  }
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}