@lumen5/beamcoder 0.0.1

package/src/frame.cc

@@ -0,0 +1,2681 @@
+/*
+  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 "frame.h"
+#include "hwcontext.h"
+
+napi_value getFrameLinesize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value array, element;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_array(env, &array);
+  CHECK_STATUS;
+
+  for ( int x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+    if (f->frame->linesize[x] == 0) break;
+    status = napi_create_int32(env, f->frame->linesize[x], &element);
+    CHECK_STATUS;
+    status = napi_set_element(env, array, x, element);
+    CHECK_STATUS;
+  }
+
+  return array;
+}
+
+napi_value setFrameLinesize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  napi_valuetype type;
+  frameData* f;
+  bool isArray;
+  uint32_t lineCount;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame linesize must be provided with a value.");
+  }
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+  if (!isArray) {
+    NAPI_THROW_ERROR("Set frame linesize must use an array of numbers.");
+  }
+
+  status = napi_get_array_length(env, args[0], &lineCount);
+  CHECK_STATUS;
+  for ( uint32_t x = 0 ; x < lineCount ; x++ ) {
+    status = napi_get_element(env, args[0], x, &element);
+    CHECK_STATUS;
+    status = napi_typeof(env, element, &type);
+    CHECK_STATUS;
+    if (type != napi_number) {
+      NAPI_THROW_ERROR("Set frame linesize must use an array of numbers.");
+    }
+  }
+
+  for ( uint32_t x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+    if (x >= lineCount) {
+      f->frame->linesize[x] = 0;
+      continue;
+    }
+    status = napi_get_element(env, args[0], x, &element);
+    CHECK_STATUS;
+    status = napi_get_value_int32(env, element, &f->frame->linesize[x]);
+    CHECK_STATUS;
+  }
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameWidth(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->width, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameWidth(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame width must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame width property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->width);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameHeight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->height, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameHeight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame height must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame height property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->height);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameNbSamples(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->nb_samples, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameNbSamples(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame nb_samples must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame nb_samples property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->nb_samples);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameFormat(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* name = nullptr;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  // Assume audio data using FFmpeg's own technique
+  if (f->frame->nb_samples > 0 && (f->frame->channel_layout || f->frame->channels > 0)) {
+    name = av_get_sample_fmt_name((AVSampleFormat) f->frame->format);
+  }
+  if (name == nullptr) { // Assume that it is video data
+    name = av_get_pix_fmt_name((AVPixelFormat) f->frame->format);
+  }
+  if (name == nullptr) {
+    status = napi_get_null(env, &result);
+  } else {
+    status = napi_create_string_utf8(env, (char*) name, NAPI_AUTO_LENGTH, &result);
+  }
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setFrameFormat(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int format = (int) AV_PIX_FMT_NONE;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame format must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type == napi_null) {
+    f->frame->format = -1;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame format property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  // TODO this may give surprising results
+  format = (int) av_get_pix_fmt( name);
+  if (format == AV_PIX_FMT_NONE) {
+    format = (int) av_get_sample_fmt((const char*) name);
+    if ((format != AV_SAMPLE_FMT_NONE) && (f->frame->nb_samples == 0)) {
+      f->frame->nb_samples = 1; // Cludge ... found a sample format ... force audio mode
+      f->frame->channels = 1;
+    }
+  }
+
+  f->frame->format = format;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameKeyFrame(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_get_boolean(env, (f->frame->key_frame == 1), &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameKeyFrame(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool keyFrame;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame key_frame must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_boolean) {
+    NAPI_THROW_ERROR("Frame key_frame property must be set with a Boolean.");
+  }
+  status = napi_get_value_bool(env, args[0], &keyFrame);
+  CHECK_STATUS;
+  f->frame->key_frame = (keyFrame) ? 1 : 0;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePictType(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* name;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  switch (f->frame->pict_type) {
+    case AV_PICTURE_TYPE_I:
+      name = "I";
+      break;
+    case AV_PICTURE_TYPE_P:
+      name = "P";
+      break;
+    case AV_PICTURE_TYPE_B:
+      name = "B";
+      break;
+    case AV_PICTURE_TYPE_S:
+      name = "S";
+      break;
+    case AV_PICTURE_TYPE_SI:
+      name = "SI";
+      break;
+    case AV_PICTURE_TYPE_SP:
+      name = "SP";
+      break;
+    case AV_PICTURE_TYPE_BI:
+      name = "BI";
+      break;
+    default:
+      name = nullptr;
+      break;
+  }
+
+  if (name == nullptr) {
+    status = napi_get_null(env, &result);
+  } else {
+    status = napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &result);
+  }
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFramePictType(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame pict_type must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_undefined) || (type == napi_null)) {
+    f->frame->pict_type = AV_PICTURE_TYPE_NONE;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame pict_type property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  switch (name[0]) {
+    case 'I':
+      f->frame->pict_type = AV_PICTURE_TYPE_I;
+      break;
+    case 'P':
+      f->frame->pict_type = AV_PICTURE_TYPE_P;
+      break;
+    case 'B':
+      f->frame->pict_type = (len == 1) ? AV_PICTURE_TYPE_B : AV_PICTURE_TYPE_BI;
+      break;
+    case 'S':
+      if (len == 1) {
+        f->frame->pict_type = AV_PICTURE_TYPE_S;
+        break;
+      }
+      if (len == 2) {
+        if (name[1] == 'I') {
+          f->frame->pict_type = AV_PICTURE_TYPE_SI;
+          break;
+        }
+        if (name[1] == 'P') {
+          f->frame->pict_type = AV_PICTURE_TYPE_SP;
+          break;
+        }
+      }
+      f->frame->pict_type = AV_PICTURE_TYPE_NONE;
+      break;
+    default:
+      f->frame->pict_type = AV_PICTURE_TYPE_NONE;
+      break;
+  }
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameSampleAR(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_array(env, &result);
+  CHECK_STATUS;
+  status = napi_create_int32(env, f->frame->sample_aspect_ratio.num, &element);
+  CHECK_STATUS;
+  status = napi_set_element(env, result, 0, element);
+  CHECK_STATUS;
+  status = napi_create_int32(env, f->frame->sample_aspect_ratio.den, &element);
+  CHECK_STATUS;
+  status = napi_set_element(env, result, 1, element);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setFrameSampleAR(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  napi_valuetype type;
+  frameData* f;
+  bool isArray;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame sample_aspect_ratio must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_undefined) || (type == napi_null)) {
+    f->frame->sample_aspect_ratio = { 0, 1 };
+    goto done;
+  }
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+  if (!isArray) {
+    NAPI_THROW_ERROR("Frame sample_aspect_ratio property must be set with an array of two numbers.");
+  }
+
+  f->frame->sample_aspect_ratio = { 0, 1 };
+  status = napi_get_element(env, args[0], 0, &element);
+  CHECK_STATUS;
+  status = napi_get_value_int32(env, element, &f->frame->sample_aspect_ratio.num);
+  CHECK_STATUS;
+  status = napi_get_element(env, args[0], 1, &element);
+  CHECK_STATUS;
+  status = napi_get_value_int32(env, element, &f->frame->sample_aspect_ratio.den);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->pts == AV_NOPTS_VALUE) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_int64(env, f->frame->pts, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setFramePTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame PTS must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->pts = AV_NOPTS_VALUE;
+    goto done;
+  }
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame PTS property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->pts);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePktDTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->pkt_dts == AV_NOPTS_VALUE) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_int64(env, f->frame->pkt_dts, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setFramePktDTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame pkt_dts must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->pkt_dts = AV_NOPTS_VALUE;
+    goto done;
+  }
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame pkt_dts property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->pkt_dts);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameCodedPicNum(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->coded_picture_number, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameCodedPicNum(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame coded_picture_number must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame coded_picture_number property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->coded_picture_number);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameDispPicNum(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->display_picture_number, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameDispPicNum(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame display_picture_number must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame display_picture_number property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->display_picture_number);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameQuality(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->quality, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameQuality(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame quality must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame quality property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->quality);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameRepeatPict(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->repeat_pict, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameRepeatPict(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame repeat_pict must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame repeat_pict property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->repeat_pict);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameInterlaced(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_get_boolean(env, f->frame->interlaced_frame == 1, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameInterlaced(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool interlaced;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame interlaced_frame must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_boolean) {
+    NAPI_THROW_ERROR("Frame interlaced_frame property must be set with a Boolean.");
+  }
+  status = napi_get_value_bool(env, args[0], &interlaced);
+  CHECK_STATUS;
+  f->frame->interlaced_frame = (interlaced) ? 1 : 0;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameTopFieldFirst(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_get_boolean(env, f->frame->top_field_first == 1, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameTopFieldFirst(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool topFieldFirst;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame top_field_first must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_boolean) {
+    NAPI_THROW_ERROR("Frame top_field_first property must be set with a Boolean.");
+  }
+  status = napi_get_value_bool(env, args[0], &topFieldFirst);
+  CHECK_STATUS;
+  f->frame->top_field_first = (topFieldFirst) ? 1 : 0;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePalHasChanged(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_get_boolean(env, f->frame->palette_has_changed == 1, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFramePalHasChanged(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool palHasChanged;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame palette_has_changed must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_boolean) {
+    NAPI_THROW_ERROR("Frame palette_has_changed property must be set with a Boolean.");
+  }
+  status = napi_get_value_bool(env, args[0], &palHasChanged);
+  CHECK_STATUS;
+  f->frame->palette_has_changed = (palHasChanged) ? 1 : 0;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameReorderOpq(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->reordered_opaque == AV_NOPTS_VALUE) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_int64(env, f->frame->reordered_opaque, &result);
+    CHECK_STATUS;
+  }
+  return result;
+}
+
+napi_value setFrameReorderOpq(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame reordered_opaque must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->reordered_opaque = AV_NOPTS_VALUE;
+    goto done;
+  }
+
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame reordered_opaque property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->reordered_opaque);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameSampleRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->sample_rate, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameSampleRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame sample_rate must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame sample_rate property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &f->frame->sample_rate);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameChanLayout(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  char channelLayoutName[64];
+  av_get_channel_layout_string(channelLayoutName, 64, 0, 
+    f->frame->channel_layout ? f->frame->channel_layout : av_get_default_channel_layout(f->frame->channels));
+
+  status = napi_create_string_utf8(env, channelLayoutName, NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameChanLayout(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame channel_layout must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->channel_layout = 0;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame channel_layout property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  f->frame->channel_layout = av_get_channel_layout(name);
+  free(name);
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value array, element;
+  frameData* f;
+  uint8_t* data;
+  AVBufferRef* ref;
+  size_t size;
+  int curElem;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_array(env, &array);
+  CHECK_STATUS;
+
+  data = f->frame->data[0];
+  ref = f->frame->buf[0] ? av_buffer_ref(f->frame->buf[0]) : nullptr;
+  size = ref ? ref->size : 0;
+  curElem = 0;
+  // work through frame bufs checking whether allocation refcounts are shared
+  for ( int x = 1 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+    // printf("Buffer %i is %p\n", x, f->frame->data[x]);
+    if (f->frame->data[x] == nullptr) continue;
+    size_t bufSize = size;
+    if (f->frame->buf[x] == nullptr)
+      bufSize = f->frame->data[x] - f->frame->data[x-1];
+    status = napi_create_external_buffer(env, bufSize, data, frameBufferFinalizer, ref, &element);
+    CHECK_STATUS;
+    status = napi_set_element(env, array, curElem, element);
+    CHECK_STATUS;
+    data = f->frame->data[x];
+    if (f->frame->buf[x]) {
+      ref = av_buffer_ref(f->frame->buf[x]);
+      size = ref->size;
+    } else {
+      ref = nullptr;
+      size -= f->frame->data[x] - f->frame->data[x-1];
+    }
+    curElem++;
+  }
+  if (data) {
+    status = napi_create_external_buffer(env, size, data, frameBufferFinalizer, ref, &element);
+    CHECK_STATUS;
+    status = napi_set_element(env, array, curElem, element);
+    CHECK_STATUS;
+  }
+
+  CHECK_STATUS;
+  return array;
+}
+
+napi_value setFrameData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  napi_valuetype type;
+  bool isArray, isBuffer;
+  frameData* f;
+  uint8_t* data;
+  size_t length;
+  avBufRef* avr;
+  uint32_t bufCount;
+  napi_ref dataRef;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set packet data must be provided with an array of buffer values.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    for ( auto it = f->dataRefs.cbegin() ; it != f->dataRefs.cend() ; it++ ) {
+      status = napi_delete_reference(env, *it);
+      CHECK_STATUS;
+    }
+    f->dataRefs.clear();
+    for ( uint32_t x = 0 ; x < AV_NUM_DATA_POINTERS ; x++) {
+      if (f->frame->buf[x] != nullptr) {
+        av_buffer_unref(&f->frame->buf[x]);
+      }
+      f->frame->data[x] = nullptr;
+    }
+    goto done;
+  }
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+  if (!isArray) {
+    NAPI_THROW_ERROR("Packet data property must be set with an array of buffer values.");
+  }
+  status = napi_get_array_length(env, args[0], &bufCount);
+  CHECK_STATUS;
+  for ( uint32_t x = 0 ; x < bufCount ; x++ ) {
+    status = napi_get_element(env, args[0], x, &element);
+    CHECK_STATUS;
+    status = napi_is_buffer(env, element, &isBuffer);
+    CHECK_STATUS;
+    if (!isBuffer) {
+      NAPI_THROW_ERROR("All elements of the packet data array must be buffers.");
+    }
+  }
+
+  for ( auto it = f->dataRefs.cbegin() ; it != f->dataRefs.cend() ; it++ ) {
+    // printf("On new buffers provided, freeing data refs for pts = %i\n", f->frame->pts);
+    status = napi_delete_reference(env, *it);
+    CHECK_STATUS;
+  }
+  f->dataRefs.clear();
+  for ( uint32_t x = 0 ; x < AV_NUM_DATA_POINTERS ; x++) {
+    if (f->frame->buf[x] != nullptr) {
+      av_buffer_unref(&f->frame->buf[x]);
+    }
+  }
+  for ( uint32_t x = 0 ; x < AV_NUM_DATA_POINTERS ; x++) {
+    if (x >= bufCount) {
+      if (f->frame->buf[x] != nullptr) {
+        av_buffer_unref(&f->frame->buf[x]); // sets pointer to null
+      }
+      f->frame->data[x] = nullptr;
+      continue;
+    }
+    status = napi_get_element(env, args[0], x, &element);
+    CHECK_STATUS;
+    // printf("Creating data reference for pts = %i\n", f->frame->pts);
+    status = napi_create_reference(env, element, 1, &dataRef);
+    CHECK_STATUS;
+    f->dataRefs.push_back(dataRef);
+    avr = new avBufRef;
+    avr->pts = f->frame->pts;
+    // printf("Creating AV reference for pts = %i\n", f->frame->pts);
+    status = napi_create_reference(env, element, 1, &avr->ref);
+    CHECK_STATUS;
+    avr->env = env;
+    status = napi_get_buffer_info(env, element, (void**) &data, &length);
+    CHECK_STATUS;
+
+    f->frame->buf[x] = av_buffer_create(data, length, frameBufferFree, avr, 0);
+    CHECK_STATUS;
+    f->frame->data[x] = f->frame->buf[x]->data;
+  }
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameSideData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  void* resultData;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->nb_side_data <= 0) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_object(env, &result);
+    CHECK_STATUS;
+    status = beam_set_string_utf8(env, result, "type", "FrameSideData");
+    for ( int x = 0 ; x < f->frame->nb_side_data ; x++ ) {
+      status = napi_create_buffer_copy(env, f->frame->side_data[x]->size,
+        f->frame->side_data[x]->data, &resultData, &element);
+      CHECK_STATUS;
+      status = napi_set_named_property(env, result,
+        beam_lookup_name(beam_frame_side_data_type->forward,
+          f->frame->side_data[x]->type), element);
+      CHECK_STATUS;
+    }
+  }
+
+  return result;
+}
+
+napi_value setFrameSideData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, names, name, element, arrayData, global, jsBuffer, jsBufferFrom;
+  napi_valuetype type;
+  bool isArray, isBuffer;
+  uint32_t sdCount = 0;
+  AVFrameSideData* fsd;
+  int fsdt;
+  char* typeName;
+  size_t strLen;
+  void* rawdata;
+  size_t rawdataSize;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame flags must be provided with a value.");
+  }
+
+  status = napi_get_global(env, &global);
+  CHECK_STATUS;
+  status = napi_get_named_property(env, global, "Buffer", &jsBuffer);
+  CHECK_STATUS;
+  status = napi_get_named_property(env, jsBuffer, "from", &jsBufferFrom);
+  CHECK_STATUS;
+
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+
+  switch (type) {
+    case napi_object:
+    case napi_null:
+    case napi_undefined:
+      if ((f->frame->side_data != nullptr) && (f->frame->nb_side_data > 0)) {
+        for ( int x = 0 ; x < f->frame->nb_side_data ; x++) {
+          av_frame_remove_side_data(f->frame, f->frame->side_data[x]->type);
+        }
+        av_freep(&f->frame->data);
+        f->frame->nb_side_data = 0;
+      }
+      if (type != napi_object) { goto done; };
+      break;
+    default:
+      NAPI_THROW_ERROR("Frame side_data property requires an object with properties of Buffer type.");
+  }
+
+  status = napi_get_property_names(env, args[0], &names);
+  CHECK_STATUS;
+  status = napi_get_array_length(env, names, &sdCount);
+  CHECK_STATUS;
+
+  for ( uint32_t x = 0 ; x < sdCount ; x++ ) {
+    status = napi_get_element(env, names, x, &name);
+    CHECK_STATUS;
+    status = napi_get_property(env, args[0], name, &element);
+    CHECK_STATUS;
+    status = napi_is_buffer(env, element, &isBuffer);
+    CHECK_STATUS;
+    if (!isBuffer) {
+      status = napi_get_named_property(env, element, "data", &arrayData);
+      CHECK_STATUS;
+      // TODO more checks that this is a buffer from JSON?
+      status = napi_is_array(env, arrayData, &isArray);
+      CHECK_STATUS;
+      if (isArray) {
+        const napi_value fargs[] = { arrayData };
+        status = napi_call_function(env, element, jsBufferFrom, 1, fargs, &element);
+        CHECK_STATUS;
+      } else {
+        continue;
+      }
+    }
+    status = napi_get_value_string_utf8(env, name, nullptr, 0, &strLen);
+    CHECK_STATUS;
+    typeName = (char*) malloc(sizeof(char) * (strLen + 1));
+    status = napi_get_value_string_utf8(env, name, typeName, strLen + 1, &strLen);
+    CHECK_STATUS;
+
+    fsdt = beam_lookup_enum(beam_frame_side_data_type->inverse, typeName);
+    free(typeName);
+    if (fsdt == BEAM_ENUM_UNKNOWN) {
+      continue;
+    } else {
+      status = napi_get_buffer_info(env, element, &rawdata, &rawdataSize);
+      CHECK_STATUS;
+      fsd = av_frame_new_side_data(f->frame, (AVFrameSideDataType) fsdt, rawdataSize);
+      if (fsd != nullptr) {
+        memcpy(fsd->data, rawdata, rawdataSize);
+      }
+    }
+  }
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameFlags(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_object(env, &result);
+  CHECK_STATUS;
+  status = beam_set_bool(env, result, "CORRUPT", (f->frame->flags & AV_FRAME_FLAG_CORRUPT) != 0);
+  CHECK_STATUS;
+  status = beam_set_bool(env, result, "DISCARD", (f->frame->flags & AV_FRAME_FLAG_DISCARD) != 0);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setFrameFlags(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool present, flag;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame flags must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_object) {
+    NAPI_THROW_ERROR("Frame flags property must be set with an object of Boolean flags.");
+  }
+  status = beam_get_bool(env, args[0], "CORRUPT", &present, &flag);
+  CHECK_STATUS;
+  if (present) { f->frame->flags = (flag) ?
+    f->frame->flags | AV_FRAME_FLAG_CORRUPT :
+    f->frame->flags & ~AV_FRAME_FLAG_CORRUPT; }
+  status = beam_get_bool(env, args[0], "DISCARD", &present, &flag);
+  CHECK_STATUS;
+  if (present) { f->frame->flags = (flag) ?
+    f->frame->flags | AV_FRAME_FLAG_DISCARD :
+    f->frame->flags & ~AV_FRAME_FLAG_DISCARD; }
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameColorRange(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  enumName = av_color_range_name(f->frame->color_range);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameColorRange(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int ret;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame color_range must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->color_range = AVCOL_RANGE_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame color_range property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  ret = av_color_range_from_name(name);
+  free(name);
+  if (ret < 0) {
+    NAPI_THROW_ERROR("Color range was not recognised. Try one of 'tv' (MPEG), 'pc' (JPEG) or 'unknown'.");
+  }
+  f->frame->color_range = (AVColorRange) ret;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameColorPrimaries(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  enumName = av_color_primaries_name(f->frame->color_primaries);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameColorPrimaries(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int ret;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame color_primaries must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->color_primaries = AVCOL_PRI_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame color_primaries property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  ret = av_color_primaries_from_name(name);
+  free(name);
+  if (ret < 0) {
+    NAPI_THROW_ERROR("Color primaries not recognised. Did you mean e.g. 'bt709'?");
+  }
+  f->frame->color_primaries = (AVColorPrimaries) ret;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameColorTrc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  enumName = av_color_transfer_name(f->frame->color_trc);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameColorTrc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int ret;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame color_trc must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->color_trc = AVCOL_TRC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame color_trc property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  ret = av_color_transfer_from_name(name);
+  free(name);
+  if (ret < 0) {
+    NAPI_THROW_ERROR("Color transfer characteristic not recognised. Did you mean e.g. 'bt709'?");
+  }
+  f->frame->color_trc = (AVColorTransferCharacteristic) ret;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameColorspace(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  enumName = av_color_space_name(f->frame->colorspace);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameColorspace(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int ret;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame colorspace must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->colorspace = AVCOL_SPC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame colorspace property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  ret = av_color_space_from_name(name);
+  free(name);
+  if (ret < 0) {
+    NAPI_THROW_ERROR("Colorspace not recognised. Did you mean e.g. 'bt709'?");
+  }
+  f->frame->colorspace = (AVColorSpace) ret;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameChromaLoc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  enumName = av_chroma_location_name(f->frame->chroma_location);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unspecified",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameChromaLoc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  char* name;
+  size_t len;
+  int ret;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame chroma_location must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Frame chroma_location property must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &len);
+  CHECK_STATUS;
+  name = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, args[0], name, len + 1, &len);
+  CHECK_STATUS;
+
+  ret = av_chroma_location_from_name(name);
+  free(name);
+  if (ret < 0) {
+    NAPI_THROW_ERROR("Chroma location not recognised. Did you mean e.g. 'left'?");
+  }
+  f->frame->chroma_location = (AVChromaLocation) ret;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameBestEffortTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->best_effort_timestamp == AV_NOPTS_VALUE) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_int64(env, f->frame->best_effort_timestamp, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setFrameBestEffortTS(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame best_effort_timestamp must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    f->frame->best_effort_timestamp = AV_NOPTS_VALUE;
+    goto done;
+  }
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame best_effort_timestamp property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->best_effort_timestamp);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePktPos(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int64(env, f->frame->pkt_pos, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFramePktPos(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame pkt_pos must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame pkt_pos property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->pkt_pos);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePktDuration(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int64(env, f->frame->pkt_duration, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFramePktDuration(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame pkt_duration must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame pkt_duration property must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &f->frame->pkt_duration);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameMetadata(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+  AVDictionaryEntry* tag = nullptr;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->metadata != nullptr) {
+    status = napi_create_object(env, &result);
+    CHECK_STATUS;
+    while((tag = av_dict_get(f->frame->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+      status = beam_set_string_utf8(env, result, tag->key, tag->value);
+      CHECK_STATUS;
+    }
+  } else {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setFrameMetadata(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  AVDictionary* dict = nullptr;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set metadata must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type == napi_null || type == napi_undefined) {
+    f->frame->metadata = nullptr;
+    goto done;
+  }
+  if (type != napi_object) {
+    NAPI_THROW_ERROR("Frame metadata property must be set with a object.");
+  }
+
+  status = makeAVDictionary(env, args[0], &dict);
+  CHECK_STATUS;
+  f->frame->metadata = dict;
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameDecodeErrFlags(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_object(env, &result);
+  CHECK_STATUS;
+
+  status = beam_set_bool(env, result, "INVALID_BITSTREAM",
+    (f->frame->decode_error_flags & FF_DECODE_ERROR_INVALID_BITSTREAM) != 0);
+  CHECK_STATUS;
+  status = beam_set_bool(env, result, "MISSING_REFERENCE",
+    (f->frame->decode_error_flags & FF_DECODE_ERROR_MISSING_REFERENCE) != 0);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setFrameDecodeErrFlags(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+  bool present, flag;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set decode_error_flags must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_object) {
+    NAPI_THROW_ERROR("Frame decode_error_flags property must be set with a object of Boolean-valued properties.");
+  }
+
+  status = beam_get_bool(env, args[0], "INVALID_BITSTREAM", &present, &flag);
+  CHECK_STATUS;
+  if (present) { f->frame->decode_error_flags = (flag) ?
+    f->frame->decode_error_flags | FF_DECODE_ERROR_INVALID_BITSTREAM :
+    f->frame->decode_error_flags & ~FF_DECODE_ERROR_INVALID_BITSTREAM; }
+  status = beam_get_bool(env, args[0], "MISSING_REFERENCE", &present, &flag);
+  CHECK_STATUS;
+  if (present) { f->frame->decode_error_flags = (flag) ?
+    f->frame->decode_error_flags | FF_DECODE_ERROR_INVALID_BITSTREAM :
+    f->frame->decode_error_flags & ~FF_DECODE_ERROR_MISSING_REFERENCE; }
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameChannels(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->channels, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameChannels(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame channels must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame channels property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->channels);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFramePktSize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->pkt_size, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFramePktSize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame pkt_size must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame pkt_size property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->pkt_size);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameHWFramesCtx(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->hw_frames_ctx == nullptr) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = fromHWFramesContext(env, f->frame->hw_frames_ctx, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setFrameHWFramesCtx(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, contextExt;
+  napi_valuetype type;
+  frameData* f;
+  AVBufferRef* contextRef;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("A value is required to set the hw_frames_context property.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_object) {
+    NAPI_THROW_ERROR("An object is required to set the hw_frames_context property.");
+  }
+  status = napi_get_named_property(env, args[0], "_framesContext", &contextExt);
+  CHECK_STATUS;
+  status = napi_get_value_external(env, contextExt, (void**) &contextRef);
+  CHECK_STATUS;
+  f->frame->hw_frames_ctx = av_buffer_ref(contextRef);
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameCropTop(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->crop_top, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameCropTop(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame crop_top must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame crop_top property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->crop_top);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameCropBottom(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->crop_bottom, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameCropBottom(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame crop_bottom must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame crop_bottom property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->crop_bottom);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameCropLeft(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->crop_left, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameCropLeft(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame crop_left must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame crop_left property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->crop_left);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getFrameCropRight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  frameData* f;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, f->frame->crop_right, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setFrameCropRight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  frameData* f;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &f);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Set frame crop_right must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Frame crop_right property must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], (int32_t*) &f->frame->crop_right);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value makeFrame(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, global, jsObject, assign, jsJSON, jsParse;
+  napi_valuetype type;
+  bool isArray, deleted;
+  frameData* f = new frameData;
+  f->frame = av_frame_alloc();
+  int align = 32; // av_cpu_max_align();
+
+  status = napi_get_global(env, &global);
+  CHECK_STATUS;
+
+  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("Frame may be created with zero or one options object argument.");
+  }
+  if (argc == 1) {
+    status = napi_typeof(env, args[0], &type);
+    CHECK_STATUS;
+    if (type == napi_string) {
+      status = napi_get_named_property(env, global, "JSON", &jsJSON);
+      CHECK_STATUS;
+      status =  napi_get_named_property(env, jsJSON, "parse", &jsParse);
+      CHECK_STATUS;
+      const napi_value pargs[] = { args[0] };
+      status = napi_call_function(env, args[0], jsParse, 1, pargs, &args[0]);
+      CHECK_STATUS;
+      status = napi_typeof(env, args[0], &type);
+      CHECK_STATUS;
+      if (type == napi_object) {
+        status = beam_delete_named_property(env, args[0], "type", &deleted);
+        CHECK_STATUS;
+        status = beam_delete_named_property(env, args[0], "buf_sizes", &deleted);
+        CHECK_STATUS;
+      }
+    }
+    status = napi_is_array(env, args[0], &isArray);
+    CHECK_STATUS;
+    if (isArray || (type != napi_object)) {
+      NAPI_THROW_ERROR("Cannot create a frame without an options object.");
+    }
+  }
+
+  status = fromAVFrame(env, f, &result);
+  CHECK_STATUS;
+
+  if (argc == 1) {
+    status = napi_get_named_property(env, global, "Object", &jsObject);
+    CHECK_STATUS;
+    status = napi_get_named_property(env, jsObject, "assign", &assign);
+    CHECK_STATUS;
+    const napi_value fargs[] = { result, args[0] };
+    status = napi_call_function(env, result, assign, 2, fargs, &result);
+    CHECK_STATUS;
+  }
+
+  // MAINTAIN: needs to track FFmpeg
+  if (f->frame->format >= 0) { // set up some useful line sizes.
+    if (f->frame->width > 0 && f->frame->height > 0) { // video
+      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get((AVPixelFormat) f->frame->format);
+      int ret, i;
+      if (!desc)
+        NAPI_THROW_ERROR("Could not determine frame descriptor details.");
+
+      if (!f->frame->linesize[0]) {
+        for( i = 1 ; i <= align ; i += i) {
+          ret = av_image_fill_linesizes(f->frame->linesize, (AVPixelFormat) f->frame->format,
+                                            FFALIGN(f->frame->width, i));
+          if (ret < 0)
+            NAPI_THROW_ERROR("Failed to calculate line sizes.");
+          if (!(f->frame->linesize[0] & (align-1)))
+            break;
+        }
+        for ( i = 0 ; i < 4 && f->frame->linesize[i] ; i++) {
+          f->frame->linesize[i] = FFALIGN(f->frame->linesize[i], align);
+        }
+      }
+    }
+    else if (f->frame->nb_samples > 0 && (f->frame->channel_layout || f->frame->channels > 0)) {
+      int channels;
+      // int planar = av_sample_fmt_is_planar((AVSampleFormat) f->frame->format);
+      // int planes;
+      int ret;
+
+      if (f->frame->channels < 2) { // Bump up from default of 1 if necessary
+        f->frame->channels = av_get_channel_layout_nb_channels(f->frame->channel_layout);
+        // printf("Calculated channel number %i\n", f->frame->channels);
+      }
+
+      channels = f->frame->channels;
+      // planes = planar ? channels : 1;
+
+      // TODO: is this needed? CHECK_CHANNELS_CONSISTENCY(f->frame);
+      if (!f->frame->linesize[0]) {
+        ret = av_samples_get_buffer_size(f->frame->linesize, channels,
+                                         f->frame->nb_samples, (AVSampleFormat) f->frame->format,
+                                         0);
+        if (ret < 0)
+          NAPI_THROW_ERROR("Unable to determine frame line size.");
+      }
+    }
+  } // Format provided
+
+  return result;
+}
+
+napi_value alloc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, extFrame;
+  frameData* f;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, &result, nullptr);
+  CHECK_STATUS;
+  status = napi_get_named_property(env, result, "_frame", &extFrame);
+  CHECK_STATUS;
+  status = napi_get_value_external(env, extFrame, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->format >= 0) {
+    if (f->frame->width > 0 && f->frame->height > 0) {
+      for ( int x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+        if (f->frame->linesize[x] > 0) {
+          int bufSize = f->frame->linesize[x] * f->frame->height;
+          f->frame->buf[x] = av_buffer_alloc(
+            (bufSize > AV_INPUT_BUFFER_MIN_SIZE) ? bufSize : AV_INPUT_BUFFER_MIN_SIZE);
+          f->frame->data[x] = f->frame->buf[x]->data;
+        } else {
+          f->frame->data[x] = nullptr;
+          f->frame->buf[x] = nullptr;
+        }
+      }
+    }
+    else if (f->frame->nb_samples > 0 && (f->frame->channel_layout || f->frame->channels > 0)) {
+      int planar = av_sample_fmt_is_planar((AVSampleFormat) f->frame->format);
+      if (planar) {
+        for ( int x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+          if (x < f->frame->channels) {
+            f->frame->buf[x] = av_buffer_alloc(f->frame->linesize[0]);
+            f->frame->data[x] = f->frame->buf[x]->data;
+          } else {
+            f->frame->buf[x] = nullptr;
+            f->frame->data[x] = nullptr;
+          }
+        }
+      }
+      else {
+        f->frame->buf[0] = av_buffer_alloc(f->frame->linesize[0]);
+        f->frame->data[0] = f->frame->buf[0]->data;
+        for ( int x = 1 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+          f->frame->buf[x] = nullptr;
+          f->frame->data[x] = nullptr;
+        }
+      }
+    }
+    else {
+      NAPI_THROW_ERROR("Data size for frame could not be determined as not video or audio.");
+    }
+  } else {
+    NAPI_THROW_ERROR("Format not set so data sizes for frame could not be computed.")
+  }
+
+  return result;
+}
+
+napi_value getFrameTypeName(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+
+  status = napi_create_string_utf8(env, "Frame", NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value getFrameBufSizes(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value array, element;
+  frameData* f;
+  uint32_t bufLengths;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &f);
+  CHECK_STATUS;
+
+  if (f->frame->buf[0] == nullptr) {
+    status = napi_get_undefined(env, &array);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_array(env, &array);
+    CHECK_STATUS;
+    for ( int x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+    //  printf("Buffer %i is %p\n", x, f->frame->buf[x]);
+      if (f->frame->buf[x] == nullptr) continue;
+      status = napi_create_int32(env, f->frame->buf[x]->size, &element);
+      CHECK_STATUS;
+      status = napi_set_element(env, array, x, element);
+      CHECK_STATUS;
+    }
+    status = napi_get_array_length(env, array, &bufLengths);
+    CHECK_STATUS;
+    if (bufLengths == 0) {
+      status = napi_get_undefined(env, &array);
+      CHECK_STATUS;
+    }
+  }
+
+  CHECK_STATUS;
+  return array;
+}
+
+napi_value frameToJSON(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, base, sizeVal;
+  frameData* f;
+  int count = 0;
+  bool hasBufSizes;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, &base, (void**) &f);
+  CHECK_STATUS;
+
+  status = napi_has_named_property(env, base, "buf_sizes", &hasBufSizes);
+  CHECK_STATUS;
+
+  status = napi_create_object(env, &result);
+  CHECK_STATUS;
+
+  napi_property_descriptor desc[45];
+  DECLARE_GETTER3("type", true, getFrameTypeName, f);
+  DECLARE_GETTER3("linesize", true, getFrameLinesize, f);
+  DECLARE_GETTER3("width", f->frame->width > 0, getFrameWidth, f);
+  DECLARE_GETTER3("height", f->frame->height > 0, getFrameHeight, f);
+  DECLARE_GETTER3("nb_samples", f->frame->nb_samples > 0, getFrameNbSamples, f);
+  DECLARE_GETTER3("format", f->frame->format > 0, getFrameFormat, f);
+  DECLARE_GETTER3("key_frame", f->frame->key_frame != 1, getFrameKeyFrame, f);
+  DECLARE_GETTER3("pict_type", f->frame->pict_type != AV_PICTURE_TYPE_NONE, getFramePictType, f);
+  DECLARE_GETTER3("sample_aspect_ratio",
+      (f->frame->sample_aspect_ratio.num != 0) || (f->frame->sample_aspect_ratio.den != 1),
+      getFrameSampleAR, f);
+    // 10
+  DECLARE_GETTER3("pts", f->frame->pts != AV_NOPTS_VALUE, getFramePTS, f);
+  DECLARE_GETTER3("pkt_dts", f->frame->pkt_dts != AV_NOPTS_VALUE, getFramePktDTS, f);
+  DECLARE_GETTER3("coded_picture_number", f->frame->coded_picture_number > 0, getFrameCodedPicNum, f);
+  DECLARE_GETTER3("display_picture_number", f->frame->display_picture_number > 0, getFrameDispPicNum, f);
+  DECLARE_GETTER3("quality", f->frame->quality > 0, getFrameQuality, f);
+  DECLARE_GETTER3("repeat_pict", f->frame->repeat_pict > 0, getFrameRepeatPict, f);
+  DECLARE_GETTER3("interlaced_frame", f->frame->interlaced_frame != 0, getFrameInterlaced, f);
+  DECLARE_GETTER3("top_field_first", f->frame->top_field_first != 0, getFrameTopFieldFirst, f);
+  DECLARE_GETTER3("palette_has_changed", f->frame->palette_has_changed != 0, getFramePalHasChanged, f);
+  DECLARE_GETTER3("reordered_opaque", f->frame->reordered_opaque != AV_NOPTS_VALUE, getFrameReorderOpq, f);
+    // 20
+  DECLARE_GETTER3("sample_rate", f->frame->sample_rate > 0, getFrameSampleRate, f);
+  DECLARE_GETTER3("channel_layout", f->frame->channel_layout != 0, getFrameChanLayout, f);
+  DECLARE_GETTER3("buf_sizes", f->frame->buf[0] != nullptr, getFrameBufSizes, f);
+  DECLARE_GETTER3("side_data", f->frame->nb_side_data > 0, getFrameSideData, f);
+  DECLARE_GETTER3("flags", f->frame->flags > 0, getFrameFlags, f);
+  DECLARE_GETTER3("color_range", f->frame->color_range != AVCOL_RANGE_UNSPECIFIED, getFrameColorRange, f);
+  DECLARE_GETTER3("color_primaries", f->frame->color_primaries != AVCOL_PRI_UNSPECIFIED, getFrameColorPrimaries, f);
+  DECLARE_GETTER3("color_trc", f->frame->color_trc != AVCOL_TRC_UNSPECIFIED, getFrameColorTrc, f);
+  DECLARE_GETTER3("colorspace", f->frame->colorspace != AVCOL_SPC_UNSPECIFIED, getFrameColorspace, f);
+  DECLARE_GETTER3("chroma_location", f->frame->chroma_location != AVCHROMA_LOC_UNSPECIFIED, getFrameChromaLoc, f);
+    // 30
+  DECLARE_GETTER3("best_effort_timestamp", f->frame->best_effort_timestamp != AV_NOPTS_VALUE, getFrameBestEffortTS, f);
+  DECLARE_GETTER3("pkt_pos", f->frame->pkt_pos >= 0, getFramePktPos, f);
+  DECLARE_GETTER3("pkt_duration", f->frame->pkt_duration > 0, getFramePktDuration, f);
+  DECLARE_GETTER3("metadata", f->frame->metadata != nullptr, getFrameMetadata, f);
+  DECLARE_GETTER3("decode_error_flags", f->frame->decode_error_flags > 0, getFrameDecodeErrFlags, f);
+  DECLARE_GETTER3("channels", f->frame->channels > 0, getFrameChannels, f);
+  DECLARE_GETTER3("pkt_size", f->frame->pkt_size >= 0, getFramePktSize, f);
+  DECLARE_GETTER3("crop_top", f->frame->crop_top > 0, getFrameCropTop, f);
+  DECLARE_GETTER3("crop_bottom", f->frame->crop_bottom > 0, getFrameCropBottom, f);
+  DECLARE_GETTER3("crop_left", f->frame->crop_left > 0, getFrameCropLeft, f);
+    // 40
+  DECLARE_GETTER3("crop_right", f->frame->crop_right > 0, getFrameCropRight, f);
+
+  if (hasBufSizes) {
+    status = napi_get_named_property(env, base, "buf_sizes", &sizeVal);
+    CHECK_STATUS;
+    desc[count++] = { "buf_sizes", nullptr, nullptr, nullptr, nullptr, sizeVal,
+      napi_enumerable, nullptr};
+  }
+
+  status = napi_define_properties(env, result, count, desc);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_status fromAVFrame(napi_env env, frameData* f, napi_value* result) {
+  napi_status status;
+  napi_value jsFrame, extFrame, undef;
+  int64_t externalMemory;
+
+  status = napi_create_object(env, &jsFrame);
+  PASS_STATUS;
+  status = napi_get_undefined(env, &undef);
+  PASS_STATUS;
+  status = napi_create_external(env, f, frameDataFinalizer, nullptr, &extFrame);
+  PASS_STATUS;
+
+  // TODO frame side data
+  napi_property_descriptor desc[] = {
+    { "type", nullptr, nullptr, getFrameTypeName, nop, nullptr, napi_enumerable, nullptr },
+    { "linesize", nullptr, nullptr, getFrameLinesize, setFrameLinesize, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "width", nullptr, nullptr, getFrameWidth, setFrameWidth, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "height", nullptr, nullptr, getFrameHeight, setFrameHeight, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "nb_samples", nullptr, nullptr, getFrameNbSamples, setFrameNbSamples, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "format", nullptr, nullptr, getFrameFormat, setFrameFormat, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "key_frame", nullptr, nullptr, getFrameKeyFrame, setFrameKeyFrame, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "pict_type", nullptr, nullptr, getFramePictType, setFramePictType, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "sample_aspect_ratio", nullptr, nullptr, getFrameSampleAR, setFrameSampleAR, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    // 10
+    { "pts", nullptr, nullptr, getFramePTS, setFramePTS, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "pkt_dts", nullptr, nullptr, getFramePktDTS, setFramePktDTS, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "coded_picture_number", nullptr, nullptr, getFrameCodedPicNum, setFrameCodedPicNum, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "display_picture_number", nullptr, nullptr, getFrameDispPicNum, setFrameDispPicNum, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "quality", nullptr, nullptr, getFrameQuality, setFrameQuality, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "repeat_pict", nullptr, nullptr, getFrameRepeatPict, setFrameRepeatPict, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "interlaced_frame", nullptr, nullptr, getFrameInterlaced, setFrameInterlaced, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "top_field_first", nullptr, nullptr, getFrameTopFieldFirst, setFrameTopFieldFirst, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "palette_has_changed", nullptr, nullptr, getFramePalHasChanged, setFramePalHasChanged, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "reordered_opaque", nullptr, nullptr, getFrameReorderOpq, setFrameReorderOpq, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    // 20
+    { "sample_rate", nullptr, nullptr, getFrameSampleRate, setFrameSampleRate, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "channel_layout", nullptr, nullptr, getFrameChanLayout, setFrameChanLayout, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "data", nullptr, nullptr, getFrameData, setFrameData, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "side_data", nullptr, nullptr, getFrameSideData, setFrameSideData, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "flags", nullptr, nullptr, getFrameFlags, setFrameFlags, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "color_range", nullptr, nullptr, getFrameColorRange, setFrameColorRange, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "color_primaries", nullptr, nullptr, getFrameColorPrimaries, setFrameColorPrimaries, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "color_trc", nullptr, nullptr, getFrameColorTrc, setFrameColorTrc, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "colorspace", nullptr, nullptr, getFrameColorspace, setFrameColorspace, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "chroma_location", nullptr, nullptr, getFrameChromaLoc, setFrameChromaLoc, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    // 30
+    { "best_effort_timestamp", nullptr, nullptr, getFrameBestEffortTS, setFrameBestEffortTS, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "pkt_pos", nullptr, nullptr, getFramePktPos, setFramePktPos, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "pkt_duration", nullptr, nullptr, getFramePktDuration, setFramePktDuration, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "metadata", nullptr, nullptr, getFrameMetadata, setFrameMetadata, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "decode_error_flags", nullptr, nullptr, getFrameDecodeErrFlags, setFrameDecodeErrFlags, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "channels", nullptr, nullptr, getFrameChannels, setFrameChannels, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "pkt_size", nullptr, nullptr, getFramePktSize, setFramePktSize, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "hw_frames_ctx", nullptr, nullptr, getFrameHWFramesCtx, setFrameHWFramesCtx, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f},
+    { "crop_top", nullptr, nullptr, getFrameCropTop, setFrameCropTop, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "crop_bottom", nullptr, nullptr, getFrameCropBottom, setFrameCropBottom, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    // 40
+    { "crop_left", nullptr, nullptr, getFrameCropLeft, setFrameCropLeft, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "crop_right", nullptr, nullptr, getFrameCropRight, setFrameCropRight, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), f },
+    { "alloc", nullptr, alloc, nullptr, nullptr, nullptr, napi_enumerable, nullptr },
+    { "toJSON", nullptr, frameToJSON, nullptr, nullptr, nullptr, napi_default, f },
+    { "_frame", nullptr, nullptr, nullptr, nullptr, extFrame, napi_default, nullptr }
+  };
+  status = napi_define_properties(env, jsFrame, 44, desc);
+  PASS_STATUS;
+
+  for ( int x = 0 ; x < AV_NUM_DATA_POINTERS ; x++ ) {
+    if (f->frame->buf[x] == nullptr) break;
+    f->extSize += f->frame->buf[x]->size;
+  }
+  status = napi_adjust_external_memory(env, f->extSize, &externalMemory);
+  PASS_STATUS;
+
+  *result = jsFrame;
+  return napi_ok;
+}
+
+void frameFinalizer(napi_env env, void* data, void* hint) {
+  AVFrame* frame = (AVFrame*) data;
+  av_frame_free(&frame);
+  // printf("Freeing a frame.\n");
+}
+
+void frameDataFinalizer(napi_env env, void* data, void* hint) {
+  napi_status status;
+  int64_t externalMemory;
+  frameData* f = (frameData*) data;
+  // printf("Freeing frame data for pts = %i\n", f->frame->pts);
+  status = napi_adjust_external_memory(env, -f->extSize, &externalMemory);
+  if (status != napi_ok) {
+    printf("DEBUG: Failed to adjust external memory downwards on frame delete.\n");
+  }
+  for ( auto it = f->dataRefs.cbegin() ; it != f->dataRefs.cend() ; it++) {
+    // printf("Freeing data reference for frame with pts = %i\n", f->frame->pts);
+    status = napi_delete_reference(env, *it);
+    if (status != napi_ok) {
+      printf("DEBUG: Failed to delete data reference for frame data, status %i.\n", status);
+    }
+  }
+  delete f;
+}
+
+void frameBufferFinalizer(napi_env env, void* data, void* hint) {
+  AVBufferRef* hintRef = (AVBufferRef*) hint;
+  av_buffer_unref(&hintRef);
+  // printf("Unreffing an AV buffer.\n");
+}
+
+void frameBufferFree(void* opaque, uint8_t* data) {
+  napi_status status;
+  avBufRef* avr = (avBufRef*) opaque;
+  // printf("AV freeing a frame buffer. pts = %i\n", avr->pts);
+  status = napi_delete_reference(avr->env, (napi_ref) avr->ref);
+  if (status != napi_ok)
+    printf("DEBUG: Failed to delete buffer reference associated with an AVBufferRef.");
+  delete avr;
+}