@lumen5/beamcoder 0.0.1

package/src/codec_par.cc

@@ -0,0 +1,1818 @@
+/*
+  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 "codec_par.h"
+
+napi_value getCodecParCodecType(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_get_media_type_string(c->codec_type);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "data",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParCodecType(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  int mtype;
+  char * typeName;
+  size_t typeNameLen;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters codec_type must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameter codec_type must be set using a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &typeNameLen);
+  CHECK_STATUS;
+  typeName = (char*) malloc(sizeof(char) * (typeNameLen + 1));
+  status = napi_get_value_string_utf8(env, args[0], typeName, typeNameLen + 1, &typeNameLen);
+  CHECK_STATUS;
+
+  mtype = beam_lookup_enum(beam_avmedia_type->inverse, typeName);
+  c->codec_type = (mtype == BEAM_ENUM_UNKNOWN) ?
+    AVMEDIA_TYPE_UNKNOWN : (AVMediaType) mtype;
+
+//SET_BODY codec_type AVMediaType CodecType
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParCodecID(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->codec_id, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParCodecID(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters codec_id must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameters codec_id must be set by a number.");
+  }
+
+  status = napi_get_value_int32(env, args[0], (int32_t*) &c->codec_id);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParName(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_string_utf8(env, (char*) avcodec_get_name(c->codec_id),
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParName(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* codecName;
+  size_t nameLen;
+  const AVCodecDescriptor* codecDesc;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters name must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters name must be provided with a value.");
+  }
+
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &nameLen);
+  CHECK_STATUS;
+  codecName = (char*) malloc(sizeof(char) * (nameLen + 1));
+  status = napi_get_value_string_utf8(env, args[0], codecName, nameLen + 1, &nameLen);
+  CHECK_STATUS;
+  codecDesc = avcodec_descriptor_get_by_name((const char *) codecName);
+  CHECK_STATUS;
+  if (codecDesc == nullptr) {
+    c->codec_id = AV_CODEC_ID_NONE;
+    c->codec_type = AVMEDIA_TYPE_DATA;
+  } else {
+    c->codec_id = codecDesc->id;
+    c->codec_type = codecDesc->type;
+  }
+
+  free(codecName);
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParCodecTag(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  char fourcc[AV_FOURCC_MAX_STRING_SIZE];
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  av_fourcc_make_string(fourcc, c->codec_tag);
+  if (strchr(fourcc, '[')) { // not a recognised tag
+    status = napi_create_uint32(env, c->codec_tag, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_string_utf8(env, fourcc, NAPI_AUTO_LENGTH, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setCodecParCodecTag(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters codec_tag must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+
+  if (type == napi_string) {
+    char* tag;
+    size_t tagLen;
+    status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &tagLen);
+    CHECK_STATUS;
+    tag = (char*) malloc(sizeof(char) * (tagLen + 1));
+    status = napi_get_value_string_utf8(env, args[0], tag, tagLen + 1, &tagLen);
+    CHECK_STATUS;
+    c->codec_tag = MKTAG(tag[0], tag[1], tag[2], tag[3]);
+  } else if (type == napi_number) {
+    status = napi_get_value_uint32(env, args[0], &c->codec_tag);
+    CHECK_STATUS;
+  } else {
+    printf("Setting codec parameters codec_tag expects a string or a number - attempting to set from codec_id\n");
+    if ((AVMEDIA_TYPE_VIDEO == c->codec_type) || (AVMEDIA_TYPE_AUDIO == c->codec_type)) {
+      const struct AVCodecTag *table[] = { 
+        (AVMEDIA_TYPE_VIDEO == c->codec_type) ? avformat_get_riff_video_tags() : avformat_get_riff_audio_tags(), 0
+      };
+      if (0 == av_codec_get_tag2(table, c->codec_id, &c->codec_tag))
+        NAPI_THROW_ERROR("Codec parameters codec_tag could not be set.");
+      printf("Setting codec parameters codec_tag to 0x%08x\n", c->codec_tag);
+    } else
+      NAPI_THROW_ERROR("Codec parameters codec_tag expects a string or number value.");
+  }
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParExtraData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* codecPar;
+  void* resultData;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, (void**) &codecPar);
+  CHECK_STATUS;
+  if (codecPar->extradata_size > 0) {
+    status = napi_create_buffer_copy(env, codecPar->extradata_size,
+      codecPar->extradata, &resultData, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setCodecParExtraData(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, global, jsBuffer, jsBufferFrom, arrayData;
+  napi_valuetype type;
+  bool isBuffer, isArray;
+  AVCodecParameters* codecPar;
+  uint8_t* data;
+  size_t dataLen;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &codecPar);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("A value is required to set the extradata property.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type == napi_null) {
+    if (codecPar->extradata_size > 0) { // Tidy up old buffers
+      av_freep(&codecPar->extradata);
+    }
+    codecPar->extradata_size = 0;
+    goto done;
+  }
+  status = napi_is_buffer(env, args[0], &isBuffer);
+  CHECK_STATUS;
+  if (!isBuffer) {
+    status = napi_get_named_property(env, args[0], "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) {
+      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;
+      const napi_value fargs[] = { arrayData };
+      status = napi_call_function(env, args[0], jsBufferFrom, 1, fargs, &args[0]);
+      CHECK_STATUS;
+    } else {
+      NAPI_THROW_ERROR("A buffer is required to set the extradata propeprty.");
+    }
+  }
+
+  status = napi_get_buffer_info(env, args[0], (void**) &data, &dataLen);
+  CHECK_STATUS;
+  if (codecPar->extradata_size > 0) { // Tidy up old buffers
+    av_freep(&codecPar->extradata);
+    codecPar->extradata_size = 0;
+  }
+  codecPar->extradata = (uint8_t*) av_mallocz(dataLen + AV_INPUT_BUFFER_PADDING_SIZE);
+  codecPar->extradata_size = dataLen;
+  memcpy(codecPar->extradata, data, dataLen);
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParFormat(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* fmtName = nullptr;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  switch (c->codec_type) {
+    case AVMEDIA_TYPE_VIDEO:
+      fmtName = av_get_pix_fmt_name((AVPixelFormat) c->format);
+      break;
+    case AVMEDIA_TYPE_AUDIO:
+      fmtName = av_get_sample_fmt_name((AVSampleFormat) c->format);
+      break;
+    default: // Might not have media type set
+      fmtName = av_get_pix_fmt_name((AVPixelFormat) c->format);
+      if (fmtName == nullptr) {
+        fmtName = av_get_sample_fmt_name((AVSampleFormat) c->format);
+      }
+      break;
+  }
+  if (fmtName == nullptr) {
+    status = napi_get_null(env, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_string_utf8(env, (char*) fmtName, NAPI_AUTO_LENGTH, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setCodecParFormat(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* formatName;
+  size_t nameLen;
+  int format;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters format must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_undefined) || (type == napi_null)) {
+    c->format = AV_PIX_FMT_NONE;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters format must be set with a string value");
+  }
+
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &nameLen);
+  CHECK_STATUS;
+  formatName = (char*) malloc(sizeof(char) * (nameLen + 1));
+  status = napi_get_value_string_utf8(env, args[0], formatName, nameLen + 1, &nameLen);
+  CHECK_STATUS;
+
+  switch (c->codec_type) {
+    case AVMEDIA_TYPE_VIDEO:
+      format = (int) av_get_pix_fmt((const char *) formatName);
+      break;
+    case AVMEDIA_TYPE_AUDIO:
+      format = (int) av_get_sample_fmt((const char *) formatName);
+      break;
+    default: // codec_type may not have been set yet ... guess mode
+      format = (int) av_get_pix_fmt((const char *) formatName);
+      if (format == AV_PIX_FMT_NONE) {
+        format = (int) av_get_sample_fmt((const char *) formatName);
+      }
+      break;
+  }
+  c->format = format;
+
+  free(formatName);
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParBitRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int64(env, c->bit_rate, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParBitRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters bit_rate must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameters bit_rate must be set with a number.");
+  }
+  status = napi_get_value_int64(env, args[0], &c->bit_rate);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParSmpAspectRt(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, element;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_array(env, &result);
+  CHECK_STATUS;
+  status = napi_create_int32(env, c->sample_aspect_ratio.num, &element);
+  CHECK_STATUS;
+  status = napi_set_element(env, result, 0, element);
+  CHECK_STATUS;
+  status = napi_create_int32(env, c->sample_aspect_ratio.den, &element);
+  CHECK_STATUS;
+  status = napi_set_element(env, result, 1, element);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParSmpAspectRt(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result, num, den;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  bool isArray;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters sample_aspect_ratio must be provided with a value.");
+  }
+  status = napi_is_array(env, args[0], &isArray);
+  CHECK_STATUS;
+  if (!isArray) {
+    NAPI_THROW_ERROR("Codec parameters sample_aspect_ratio must be set with an array of numbers.");
+  }
+
+  status = napi_get_element(env, args[0], 0, &num);
+  CHECK_STATUS;
+  status = napi_typeof(env, num, &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameters sample_aspect_ratio numerator must be a number.");
+  }
+  CHECK_STATUS;
+
+  status = napi_get_element(env, args[0], 1, &den);
+  CHECK_STATUS;
+  status = napi_typeof(env, den, &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameters sample_aspect_ratio denominator must be a number.");
+  }
+  CHECK_STATUS;
+
+  status = napi_get_value_int32(env, num, &c->sample_aspect_ratio.num);
+  CHECK_STATUS;
+  status = napi_get_value_int32(env, den, &c->sample_aspect_ratio.den);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParFieldOrder(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_string_utf8(env,
+    (char*) beam_lookup_name(beam_field_order->forward, c->field_order),
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParFieldOrder(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters field_order must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters field_order must be set with a string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = beam_lookup_enum(beam_field_order->inverse, enumString);
+  if (enumValue == BEAM_ENUM_UNKNOWN) {
+    NAPI_THROW_ERROR("Codec parameters field_order value unrecognised. Did you mean e.g. 'progressive'?")
+  }
+  c->field_order = (AVFieldOrder) enumValue;
+
+  free(enumString);
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParColorRange(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_color_range_name(c->color_range);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown", NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParColorRange(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters color_range must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->color_range = AVCOL_RANGE_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters color_range must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = av_color_range_from_name((const char *) enumString);
+  free(enumString);
+  if (enumValue < 0) {
+    NAPI_THROW_ERROR("Codec parameter color_range is not recognised. One of 'tv' or 'pc'?");
+  }
+  c->color_range = (AVColorRange) enumValue;
+
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParColorPrims(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_color_primaries_name(c->color_primaries);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParColorPrims(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters color_primaries must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->color_primaries = AVCOL_PRI_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters color_primaries must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = av_color_primaries_from_name((const char *) enumString);
+  free(enumString);
+  if (enumValue < 0) {
+    NAPI_THROW_ERROR("Codec parameter color_primaries is not recognised. Did you mean e.g. 'bt709'?");
+  }
+  c->color_primaries = (AVColorPrimaries) enumValue;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParColorTrc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_color_transfer_name(c->color_trc);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParColorTrc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters color_trc must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->color_trc = AVCOL_TRC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters color_trc must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = av_color_transfer_from_name((const char *) enumString);
+  free(enumString);
+  if (enumValue < 0) {
+    NAPI_THROW_ERROR("Codec parameter color_trc is not recognised. Did you mean e.g. 'bt709'?");
+  }
+  c->color_trc = (AVColorTransferCharacteristic) enumValue;
+
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParColorSpace(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_color_space_name(c->color_space);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unknown",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParColorSpace(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters color_space must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->color_space = AVCOL_SPC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters color_space must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = av_color_space_from_name((const char *) enumString);
+  free(enumString);
+  if (enumValue < 0) {
+    NAPI_THROW_ERROR("Codec parameter color_space is not recognised. Did you mean e.g. 'bt709'?");
+  }
+  c->color_space = (AVColorSpace) enumValue;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParChromaLoc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* enumName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  enumName = av_chroma_location_name(c->chroma_location);
+  status = napi_create_string_utf8(env,
+    (enumName != nullptr) ? (char*) enumName : "unspecified",
+    NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParChromaLoc(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  int enumValue;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameters chroma_location must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameters chroma_location must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  enumValue = av_chroma_location_from_name((const char *) enumString);
+  free(enumString);
+  if (enumValue < 0) {
+    NAPI_THROW_ERROR("Codec parameter chroma_location is not recognised. Did you mean e.g. 'left'?");
+  }
+  c->chroma_location = (AVChromaLocation) enumValue;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParChanLayout(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  char enumName[64];
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  av_get_channel_layout_string(enumName, 64, 0,
+    c->channel_layout ? c->channel_layout : av_get_default_channel_layout(c->channels));
+  status = napi_create_string_utf8(env, enumName, NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value setCodecParChanLayout(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  uint64_t chanLay;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {  NAPI_THROW_ERROR("Codec parameters channel_layout must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->channel_layout = 0;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameter channel_layout must be set with a string value.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  chanLay = av_get_channel_layout((const char *) enumString);
+  free(enumString);
+  if (chanLay != 0) {
+    c->channel_layout = chanLay;
+  } else {
+    NAPI_THROW_ERROR("Channel layout name is not recognized. Set 'null' for '0 channels'.");
+  }
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParBitsPerCodedSmp(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->bits_per_coded_sample, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParBitsPerCodedSmp(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter bits_per_coded_sample must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter bits_per_coded_sample must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->bits_per_coded_sample);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParBitsPerRawSmp(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->bits_per_raw_sample, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParBitsPerRawSmp(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter bits_per_raw_sample must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter bits_per_raw_sample must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->bits_per_raw_sample);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParLevel(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->level, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParLevel(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter level must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->level = FF_LEVEL_UNKNOWN;
+    goto done;
+  }
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter level must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->level);
+  CHECK_STATUS;
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParWidth(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->width, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParWidth(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter width must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter width must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->width);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParHeight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->height, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParHeight(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter height must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter height must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->height);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParVideoDelay(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->video_delay, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParVideoDelay(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter video_delay must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter video_delay must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->video_delay);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+
+napi_value getCodecParChannels(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->channels, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParChannels(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter channels must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter channels must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->channels);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParSampleRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->sample_rate, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParSampleRate(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter sample_rate must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter sample_rate must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->sample_rate);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParBlockAlign(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->block_align, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParBlockAlign(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter block_align must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter block_align must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->block_align);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+
+napi_value getCodecParFrameSize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->frame_size, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParFrameSize(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter frame_size must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter frame_size must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->frame_size);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParInitialPad(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->initial_padding, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParInitialPad(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter initial_padding must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter initial_padding must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->initial_padding);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParTrailingPad(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->trailing_padding, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParTrailingPad(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter trailing_padding must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter trailing_padding must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->trailing_padding);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParSeekPreroll(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_int32(env, c->seek_preroll, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value setCodecParSeekPreroll(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter seek_preroll must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if (type != napi_number) {
+    NAPI_THROW_ERROR("Codec parameter seek_preroll must be set with a number.");
+  }
+  status = napi_get_value_int32(env, args[0], &c->seek_preroll);
+  CHECK_STATUS;
+
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParProfile(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  const char* profName;
+
+  status = napi_get_cb_info(env, info, 0, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  profName = avcodec_profile_name(c->codec_id, c->profile);
+  if (profName != nullptr) {
+    status = napi_create_string_utf8(env, (char*) profName,
+      NAPI_AUTO_LENGTH, &result);
+    CHECK_STATUS;
+  } else {
+    status = napi_create_int32(env, c->profile, &result);
+    CHECK_STATUS;
+  }
+
+  return result;
+}
+
+napi_value setCodecParProfile(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  napi_valuetype type;
+  AVCodecParameters* c;
+  char* enumString;
+  size_t strLen;
+  const AVProfile* profile;
+  const AVCodecDescriptor* codecDesc;
+  bool foundProfile = false;
+
+  size_t argc = 1;
+  napi_value args[1];
+
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, (void**) &c);
+  CHECK_STATUS;
+  if (argc < 1) {
+    NAPI_THROW_ERROR("Codec parameter profile must be provided with a value.");
+  }
+  status = napi_typeof(env, args[0], &type);
+  CHECK_STATUS;
+  if ((type == napi_null) || (type == napi_undefined)) {
+    c->profile = FF_PROFILE_UNKNOWN;
+    goto done;
+  }
+  if (type == napi_number) {
+    status = napi_get_value_int32(env, args[0], &c->profile);
+    CHECK_STATUS;
+    goto done;
+  }
+  if (type != napi_string) {
+    NAPI_THROW_ERROR("Codec parameter profile must be set by integer or string.");
+  }
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &strLen);
+  CHECK_STATUS;
+  enumString = (char*) malloc(sizeof(char) * (strLen + 1));
+  CHECK_STATUS;
+  status = napi_get_value_string_utf8(env, args[0], enumString, strLen + 1, &strLen);
+  CHECK_STATUS;
+
+  codecDesc = avcodec_descriptor_get(c->codec_id);
+  if (codecDesc == nullptr) goto done;
+  profile = codecDesc->profiles;
+  if (!profile) {
+    printf("Failed to set codec profile \'%s\' - recognised profiles not available for codec \'%s\'.\n", enumString, codecDesc->name);
+    printf("Set profile as a numeric value to work around this problem.\n");
+    c->profile = FF_PROFILE_UNKNOWN;
+  } else {
+    while (profile->profile != FF_PROFILE_UNKNOWN) {
+      if (strcmp(enumString, profile->name) == 0) {
+        c->profile = profile->profile;
+        foundProfile = true;
+        break;
+      }
+      profile = profile + 1;
+    }
+    if (!foundProfile) {
+      c->profile = FF_PROFILE_UNKNOWN;
+      printf("Failed to find codec profile \'%s\' in recognised profiles.\n", enumString);
+    }
+  }
+  free(enumString);
+
+done:
+  status = napi_get_undefined(env, &result);
+  CHECK_STATUS;
+  return result;
+}
+
+napi_value getCodecParTypeName(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+
+  status = napi_create_string_utf8(env, "CodecParameters", NAPI_AUTO_LENGTH, &result);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_value makeCodecParameters(napi_env env, napi_callback_info info) {
+  return makeCodecParamsInternal(env, info, true);
+}
+
+napi_value makeCodecParamsInternal(napi_env env, napi_callback_info info, bool ownAlloc) {
+  napi_status status;
+  napi_value result, global, jsObject, assign, jsJSON, jsParse;
+  napi_valuetype type;
+  bool isArray, deleted;
+  AVCodecParameters* c = avcodec_parameters_alloc();
+
+  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("Parameters 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], "name", &deleted);
+        CHECK_STATUS;
+      }
+    }
+    status = napi_is_array(env, args[0], &isArray);
+    CHECK_STATUS;
+    if (isArray || (type != napi_object)) {
+      NAPI_THROW_ERROR("Cannot create codec parameters unless argument is an object.");
+    }
+  }
+
+  status = fromAVCodecParameters(env, c, ownAlloc, &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;
+  }
+
+  if ((c->codec_type == AVMEDIA_TYPE_UNKNOWN) && (c->codec_id != AV_CODEC_ID_NONE)) {
+    c->codec_type = avcodec_get_type(c->codec_id);
+  }
+
+  return result;
+}
+
+napi_value codecParToJSON(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value result;
+  AVCodecParameters* c;
+  int count = 0;
+
+  size_t argc = 0;
+  status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, (void**) &c);
+  CHECK_STATUS;
+
+  status = napi_create_object(env, &result);
+  CHECK_STATUS;
+
+  napi_property_descriptor desc[35];
+  DECLARE_GETTER3("type", true, getCodecParTypeName, c);
+  DECLARE_GETTER3("codec_type", true, getCodecParCodecType, c);
+  DECLARE_GETTER3("codec_id", true, getCodecParCodecID, c);
+  DECLARE_GETTER3("name", true, getCodecParName, c);
+  DECLARE_GETTER3("codec_tag", c->codec_tag > 0, getCodecParCodecTag, c);
+  DECLARE_GETTER3("extradata", c->extradata != nullptr, getCodecParExtraData, c);
+  DECLARE_GETTER3("format", c->format >= 0, getCodecParFormat, c);
+  DECLARE_GETTER3("bit_rate", c->bit_rate > 0, getCodecParBitRate, c);
+  DECLARE_GETTER3("bits_per_coded_sample", c->bits_per_coded_sample > 0, getCodecParBitsPerCodedSmp, c);
+    // 10
+  DECLARE_GETTER3("bits_per_raw_sample", c->bits_per_raw_sample > 0, getCodecParBitsPerRawSmp, c);
+  DECLARE_GETTER3("profile", c->profile != FF_PROFILE_UNKNOWN, getCodecParProfile, c);
+  DECLARE_GETTER3("level", c->level != FF_LEVEL_UNKNOWN, getCodecParLevel, c);
+  DECLARE_GETTER3("width", c->width != 0, getCodecParWidth, c);
+  DECLARE_GETTER3("height", c->height != 0, getCodecParHeight, c);
+  DECLARE_GETTER3("sample_aspect_ratio",
+      (c->sample_aspect_ratio.num != 0) || (c->sample_aspect_ratio.den != 1),
+        getCodecParSmpAspectRt, c);
+  DECLARE_GETTER3("field_order", c->field_order != AV_FIELD_UNKNOWN, getCodecParFieldOrder, c);
+  DECLARE_GETTER3("color_range", c->color_range != AVCOL_RANGE_UNSPECIFIED, getCodecParColorRange, c);
+  DECLARE_GETTER3("color_primaries", c->color_primaries != AVCOL_PRI_UNSPECIFIED, getCodecParColorPrims, c);
+  DECLARE_GETTER3("color_trc", c->color_trc != AVCOL_TRC_UNSPECIFIED, getCodecParColorTrc, c);
+    // 20
+  DECLARE_GETTER3("color_space", c->color_space != AVCOL_SPC_UNSPECIFIED, getCodecParColorSpace, c);
+  DECLARE_GETTER3("chroma_location", c->chroma_location != AVCHROMA_LOC_UNSPECIFIED, getCodecParChromaLoc, c);
+  DECLARE_GETTER3("video_delay", c->video_delay != 0, getCodecParVideoDelay, c);
+  DECLARE_GETTER3("channel_layout", c->channel_layout != 0, getCodecParChanLayout, c);
+  DECLARE_GETTER3("channels", c->channels > 0, getCodecParChannels, c);
+  DECLARE_GETTER3("sample_rate", c->sample_rate > 0, getCodecParSampleRate, c);
+  DECLARE_GETTER3("block_align", c->block_align > 0, getCodecParBlockAlign, c);
+  DECLARE_GETTER3("frame_size", c->frame_size > 0, getCodecParFrameSize, c);
+  DECLARE_GETTER3("initial_padding", c->initial_padding > 0, getCodecParInitialPad, c);
+  DECLARE_GETTER3("trailing_padding", c->trailing_padding > 0, getCodecParTrailingPad, c);
+    // 30
+  DECLARE_GETTER3("seek_preroll", c->seek_preroll > 0, getCodecParSeekPreroll, c);
+
+  status = napi_define_properties(env, result, count, desc);
+  CHECK_STATUS;
+
+  return result;
+}
+
+napi_status fromAVCodecParameters(napi_env env, AVCodecParameters* c, bool ownAlloc, napi_value* result) {
+  napi_status status;
+  napi_value jsCodecPar, extCodecPar;
+
+  status = napi_create_object(env, &jsCodecPar);
+  PASS_STATUS;
+  status = napi_create_external(env, c, ownAlloc?codecParamsFinalizer:nullptr, nullptr, &extCodecPar);
+  PASS_STATUS;
+
+  napi_property_descriptor desc[] = {
+    { "type", nullptr, nullptr, getCodecParTypeName, nop, nullptr, napi_enumerable, nullptr },
+    { "codec_type", nullptr, nullptr, getCodecParCodecType, setCodecParCodecType, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "codec_id", nullptr, nullptr, getCodecParCodecID, setCodecParCodecID, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "name", nullptr, nullptr, getCodecParName, setCodecParName, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "codec_tag", nullptr, nullptr, getCodecParCodecTag, setCodecParCodecTag, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "extradata", nullptr, nullptr, getCodecParExtraData, setCodecParExtraData, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "format", nullptr, nullptr, getCodecParFormat, setCodecParFormat, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "bit_rate", nullptr, nullptr, getCodecParBitRate, setCodecParBitRate, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "bits_per_coded_sample", nullptr, nullptr, getCodecParBitsPerCodedSmp, setCodecParBitsPerCodedSmp, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "bits_per_raw_sample", nullptr, nullptr, getCodecParBitsPerRawSmp, setCodecParBitsPerRawSmp, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c }, // 10
+    { "profile", nullptr, nullptr, getCodecParProfile, setCodecParProfile, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "level", nullptr, nullptr, getCodecParLevel, setCodecParLevel, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "width", nullptr, nullptr, getCodecParWidth, setCodecParWidth, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "height", nullptr, nullptr, getCodecParHeight, setCodecParHeight, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "sample_aspect_ratio", nullptr, nullptr, getCodecParSmpAspectRt, setCodecParSmpAspectRt, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "field_order", nullptr, nullptr, getCodecParFieldOrder, setCodecParFieldOrder, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "color_range", nullptr, nullptr, getCodecParColorRange, setCodecParColorRange, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "color_primaries", nullptr, nullptr, getCodecParColorPrims, setCodecParColorPrims, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "color_trc", nullptr, nullptr, getCodecParColorTrc, setCodecParColorTrc, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "color_space", nullptr, nullptr, getCodecParColorSpace, setCodecParColorSpace, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c }, // 20
+    { "chroma_location", nullptr, nullptr, getCodecParChromaLoc, setCodecParChromaLoc, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "video_delay", nullptr, nullptr, getCodecParVideoDelay, setCodecParVideoDelay, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "channel_layout", nullptr, nullptr, getCodecParChanLayout, setCodecParChanLayout, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "channels", nullptr, nullptr, getCodecParChannels, setCodecParChannels, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "sample_rate", nullptr, nullptr, getCodecParSampleRate, setCodecParSampleRate, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "block_align", nullptr, nullptr, getCodecParBlockAlign, setCodecParBlockAlign, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "frame_size", nullptr, nullptr, getCodecParFrameSize, setCodecParFrameSize, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "initial_padding", nullptr, nullptr, getCodecParInitialPad, setCodecParInitialPad, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "trailing_padding", nullptr, nullptr, getCodecParTrailingPad, setCodecParTrailingPad, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c },
+    { "seek_preroll", nullptr, nullptr, getCodecParSeekPreroll, setCodecParSeekPreroll, nullptr,
+      (napi_property_attributes) (napi_writable | napi_enumerable), c }, // 30
+    { "toJSON", nullptr, codecParToJSON, nullptr, nullptr, nullptr, napi_default, c},
+    { "_codecPar", nullptr, nullptr, nullptr, nullptr, extCodecPar, napi_default, nullptr }
+  };
+  status = napi_define_properties(env, jsCodecPar, 32, desc);
+  PASS_STATUS;
+
+  *result = jsCodecPar;
+  return napi_ok;
+};
+
+void codecParamsFinalizer(napi_env env, void* data, void* hint) {
+  AVCodecParameters* c = (AVCodecParameters*) data;
+  // if ((c->extradata != nullptr) && (c->extradata_size > 0)) {
+  //   av_freep(&c->extradata);
+  //   c->extradata_size = 0;
+  // }
+  avcodec_parameters_free(&c);
+}