@lumen5/beamcoder 0.0.1

package/src/beamcoder_util.cc

@@ -0,0 +1,1129 @@
+/*
+  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 <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <chrono>
+#include <string>
+#include "beamcoder_util.h"
+#include "node_api.h"
+
+napi_status checkStatus(napi_env env, napi_status status,
+  const char* file, uint32_t line) {
+
+  napi_status infoStatus, throwStatus;
+  const napi_extended_error_info *errorInfo;
+
+  if (status == napi_ok) {
+    // printf("Received status OK.\n");
+    return status;
+  }
+
+  infoStatus = napi_get_last_error_info(env, &errorInfo);
+  assert(infoStatus == napi_ok);
+  printf("NAPI error in file %s on line %i. Error %i: %s\n", file, line,
+    errorInfo->error_code, errorInfo->error_message);
+
+  if (status == napi_pending_exception) {
+    printf("NAPI pending exception. Engine error code: %i\n", errorInfo->engine_error_code);
+    return status;
+  }
+
+  char errorCode[20];
+  sprintf(errorCode, "%d", errorInfo->error_code);
+  throwStatus = napi_throw_error(env, errorCode, errorInfo->error_message);
+  assert(throwStatus == napi_ok);
+
+  return napi_pending_exception; // Expect to be cast to void
+}
+
+long long microTime(std::chrono::high_resolution_clock::time_point start) {
+  auto elapsed = std::chrono::high_resolution_clock::now() - start;
+  return std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
+}
+
+const char* getNapiTypeName(napi_valuetype t) {
+  switch (t) {
+    case napi_undefined: return "undefined";
+    case napi_null: return "null";
+    case napi_boolean: return "boolean";
+    case napi_number: return "number";
+    case napi_string: return "string";
+    case napi_symbol: return "symbol";
+    case napi_object: return "object";
+    case napi_function: return "function";
+    case napi_external: return "external";
+    default: return "unknown";
+  }
+}
+
+napi_status checkArgs(napi_env env, napi_callback_info info, char* methodName,
+  napi_value* args, size_t argc, napi_valuetype* types) {
+
+  napi_status status;
+
+  size_t realArgc = argc;
+  status = napi_get_cb_info(env, info, &realArgc, args, nullptr, nullptr);
+  PASS_STATUS;
+
+  if (realArgc != argc) {
+    char errorMsg[100];
+    sprintf(errorMsg, "For method %s, expected %zi arguments and got %zi.",
+      methodName, argc, realArgc);
+    napi_throw_error(env, nullptr, errorMsg);
+    return napi_pending_exception;
+  }
+
+  napi_valuetype t;
+  for ( size_t x = 0 ; x < argc ; x++ ) {
+    status = napi_typeof(env, args[x], &t);
+    PASS_STATUS;
+    if (t != types[x]) {
+      char errorMsg[100];
+      sprintf(errorMsg, "For method %s argument %zu, expected type %s and got %s.",
+        methodName, x + 1, getNapiTypeName(types[x]), getNapiTypeName(t));
+      napi_throw_error(env, nullptr, errorMsg);
+      return napi_pending_exception;
+    }
+  }
+
+  return napi_ok;
+};
+
+
+void tidyCarrier(napi_env env, carrier* c) {
+  napi_status status;
+  if (c->passthru != nullptr) {
+    status = napi_delete_reference(env, c->passthru);
+    FLOATING_STATUS;
+  }
+  if (c->_request != nullptr) {
+    status = napi_delete_async_work(env, c->_request);
+    FLOATING_STATUS;
+  }
+  // printf("Tidying carrier %p %p\n", c->passthru, c->_request);
+  delete c;
+}
+
+int32_t rejectStatus(napi_env env, carrier* c, char* file, int32_t line) {
+  if (c->status != BEAMCODER_SUCCESS) {
+    napi_value errorValue, errorCode, errorMsg;
+    napi_status status;
+    if (c->status < BEAMCODER_ERROR_START) {
+      const napi_extended_error_info *errorInfo;
+      status = napi_get_last_error_info(env, &errorInfo);
+      FLOATING_STATUS;
+      c->errorMsg = std::string(
+        (errorInfo->error_message != nullptr) ? errorInfo->error_message : "(no message)");
+    }
+    char* extMsg = (char *) malloc(sizeof(char) * c->errorMsg.length() + 200);
+    sprintf(extMsg, "In file %s on line %i, found error: %s", file, line, c->errorMsg.c_str());
+    char errorCodeChars[20];
+    sprintf(errorCodeChars, "%d", c->status);
+    status = napi_create_string_utf8(env, errorCodeChars,
+      NAPI_AUTO_LENGTH, &errorCode);
+    FLOATING_STATUS;
+    status = napi_create_string_utf8(env, extMsg, NAPI_AUTO_LENGTH, &errorMsg);
+    FLOATING_STATUS;
+    status = napi_create_error(env, errorCode, errorMsg, &errorValue);
+    FLOATING_STATUS;
+    status = napi_reject_deferred(env, c->_deferred, errorValue);
+    FLOATING_STATUS;
+
+    delete[] extMsg;
+    tidyCarrier(env, c);
+  }
+  return c->status;
+}
+
+// Should never get called
+napi_value nop(napi_env env, napi_callback_info info) {
+  napi_value value;
+  napi_status status;
+  status = napi_get_undefined(env, &value);
+  if (status != napi_ok) NAPI_THROW_ERROR("Failed to retrieve undefined in nop.");
+  return value;
+}
+
+char* avErrorMsg(const char* base, int avError) {
+  char errMsg[AV_ERROR_MAX_STRING_SIZE];
+  char* both;
+  int ret = av_strerror(avError, errMsg, AV_ERROR_MAX_STRING_SIZE);
+  if (ret < 0) {
+    strcpy(errMsg, "Unable to create AV error string.");
+  }
+  size_t len = strlen(base) + strlen(errMsg);
+  both = (char*) malloc(sizeof(char) * (len + 1));
+  both[0] = '\0';
+  strcat(both, base);
+  strcat(both, errMsg);
+  return both;
+}
+
+napi_status beam_set_uint32(napi_env env, napi_value target, const char* name, uint32_t value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_create_uint32(env, value, &prop);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+}
+
+napi_status beam_get_uint32(napi_env env, napi_value target, char* name, uint32_t* value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_uint32(env, prop, value);
+  ACCEPT_STATUS(napi_number_expected);
+  return napi_ok;
+}
+
+napi_status beam_set_int32(napi_env env, napi_value target, const char* name, int32_t value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_create_int32(env, value, &prop);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+}
+
+napi_status beam_get_int32(napi_env env, napi_value target, const char* name, int32_t* value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_int32(env, prop, value);
+  ACCEPT_STATUS(napi_number_expected);
+  return napi_ok;
+}
+
+napi_status beam_set_int64(napi_env env, napi_value target, const char* name, int64_t value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_create_int64(env, value, &prop);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+}
+
+napi_status beam_get_int64(napi_env env, napi_value target, const char* name, int64_t* value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_int64(env, prop, value);
+  ACCEPT_STATUS(napi_number_expected);
+  return napi_ok;
+}
+
+napi_status beam_set_double(napi_env env, napi_value target, const char* name, double value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_create_double(env, value, &prop);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+}
+
+napi_status beam_get_double(napi_env env, napi_value target, const char* name, double* value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_double(env, prop, value);
+  ACCEPT_STATUS(napi_number_expected);
+  return napi_ok;
+}
+
+napi_status beam_set_string_utf8(napi_env env, napi_value target, const char* name, const char* value) {
+  napi_status status;
+  napi_value prop;
+  if (value == nullptr) {
+    status = napi_get_null(env, &prop);
+  }
+  else {
+    status = napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &prop);
+  }
+  ACCEPT_STATUS(napi_string_expected);
+  return napi_set_named_property(env, target, name, prop);
+}
+
+// TODO improve memory management
+napi_status beam_get_string_utf8(napi_env env, napi_value target, const char* name, char** value) {
+  napi_status status;
+  napi_value prop;
+  char* str;
+  size_t len;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_string_utf8(env, prop, nullptr, 0, &len);
+  if (status == napi_string_expected) {
+    *value = nullptr;
+    return napi_ok;
+  }
+  PASS_STATUS;
+  str = (char*) malloc(sizeof(char) * (len + 1));
+  status = napi_get_value_string_utf8(env, prop, str, len + 1, &len);
+  PASS_STATUS;
+  *value = str;
+  return napi_ok;
+}
+
+napi_status beam_set_bool(napi_env env, napi_value target, const char* name, bool value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_boolean(env, value, &prop);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+}
+
+napi_status beam_get_bool(napi_env env, napi_value target, const char* name, bool* present, bool* value) {
+  napi_status status;
+  napi_value prop;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_get_value_bool(env, prop, value);
+  if (status == napi_boolean_expected) {
+    *present = false;
+    status = napi_ok;
+  }
+  else {
+    *present = true;
+  }
+  PASS_STATUS;
+  return napi_ok;
+}
+
+napi_status beam_set_rational(napi_env env, napi_value target, const char* name, AVRational value) {
+  napi_status status;
+  napi_value pair, element;
+  status = napi_create_array(env, &pair);
+  PASS_STATUS;
+  status = napi_create_int32(env, value.num, &element);
+  PASS_STATUS;
+  status = napi_set_element(env, pair, 0, element);
+  PASS_STATUS;
+  status = napi_create_int32(env, value.den, &element);
+  PASS_STATUS;
+  status = napi_set_element(env, pair, 1, element);
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, pair);
+}
+
+napi_status beam_get_rational(napi_env env, napi_value target, const char* name, AVRational* value) {
+  napi_status status;
+  napi_value prop, element;
+  int32_t num = 0, den = 1;
+  bool isArray;
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_is_array(env, prop, &isArray);
+  PASS_STATUS;
+  if (isArray) {
+    status = napi_get_element(env, prop, 0, &element);
+    PASS_STATUS;
+    status = napi_get_value_int32(env, element, &num);
+    ACCEPT_STATUS(napi_number_expected);
+
+    status = napi_get_element(env, prop, 1, &element);
+    PASS_STATUS;
+    status = napi_get_value_int32(env, element, &den);
+    ACCEPT_STATUS(napi_number_expected);
+  }
+  *value = av_make_q(num, den);
+  return napi_ok;
+}
+
+napi_status beam_set_null(napi_env env, napi_value target, const char* name) {
+  napi_status status;
+  napi_value value;
+  status = napi_get_null(env, &value);
+  PASS_STATUS;
+  status = napi_set_named_property(env, target, name, value);
+  PASS_STATUS;
+
+  return napi_ok;
+};
+
+napi_status beam_is_null(napi_env env, napi_value props, const char* name, bool* isNull) {
+  napi_status status;
+  napi_value value;
+  napi_valuetype type;
+  status = napi_get_named_property(env, props, name, &value);
+  PASS_STATUS;
+  status = napi_typeof(env, props, &type);
+  PASS_STATUS;
+  *isNull = (type == napi_null);
+
+  return napi_ok;
+};
+
+napi_status beam_delete_named_property(napi_env env, napi_value props, const char* name, bool* deleted) {
+  napi_status status;
+  napi_value jsName;
+  status = napi_create_string_utf8(env, name, NAPI_AUTO_LENGTH, &jsName);
+  PASS_STATUS;
+  status = napi_delete_property(env, props, jsName, deleted);
+  PASS_STATUS;
+
+  return napi_ok;
+}
+
+
+const char* beam_lookup_name(std::unordered_map<int, std::string> m, int value) {
+  auto search = m.find(value);
+  if (search != m.end()) {
+    return strdup(search->second.c_str());
+  } else {
+    return "unknown";
+  }
+}
+
+int beam_lookup_enum(std::unordered_map<std::string, int> m, char* value) {
+  auto search = m.find(std::string(value));
+  if (search != m.end()) {
+    return search->second;
+  } else {
+    return BEAM_ENUM_UNKNOWN;
+  }
+}
+
+napi_status beam_set_enum(napi_env env, napi_value target, const char* name,
+    const beamEnum* enumDesc, int value) {
+  napi_status status;
+  napi_value prop;
+  auto search = enumDesc->forward.find(value);
+  if (search != enumDesc->forward.end()) {
+    status = napi_create_string_utf8(env, search->second.data(), NAPI_AUTO_LENGTH, &prop);
+  } else {
+    status = napi_create_string_utf8(env, "unknown", NAPI_AUTO_LENGTH, &prop);
+  }
+  PASS_STATUS;
+  return napi_set_named_property(env, target, name, prop);
+};
+
+napi_status beam_get_enum(napi_env env, napi_value target, const char* name,
+    const beamEnum* enumDesc, int* value) {
+  napi_status status;
+  napi_value prop;
+  napi_valuetype type;
+  char* enumStr;
+  size_t len;
+
+  status = napi_get_named_property(env, target, name, &prop);
+  PASS_STATUS;
+  status = napi_typeof(env, prop, &type);
+  PASS_STATUS;
+  if (type == napi_number) {
+    status = napi_get_value_int32(env, prop, value);
+    PASS_STATUS;
+    return napi_ok;
+  }
+  if (type == napi_string) {
+    status = napi_get_value_string_utf8(env, prop, nullptr, 0, &len);
+    PASS_STATUS;
+    enumStr = (char*) malloc((len + 1) * sizeof(char));
+    status = napi_get_value_string_utf8(env, prop, enumStr, len + 1, &len);
+    PASS_STATUS;
+    auto search = enumDesc->inverse.find(std::string(enumStr));
+    if (search != enumDesc->inverse.end()) {
+      *value = search->second;
+    } else {
+      *value = BEAM_ENUM_UNKNOWN;
+    }
+  }
+  return napi_ok;
+};
+
+napi_status fromAVClass(napi_env env, const AVClass* cls, napi_value* result) {
+  napi_status status;
+  napi_value desc, options, units, opt, consts, element, flags;
+  napi_valuetype type;
+  const AVOption* option;
+  uint32_t constCount;
+
+  status = napi_create_object(env, &desc);
+  PASS_STATUS;
+
+  status = beam_set_string_utf8(env, desc, "type", "Class");
+  PASS_STATUS;
+  status = beam_set_string_utf8(env, desc, "class_name", (char*) cls->class_name);
+  PASS_STATUS;
+  status = napi_create_object(env, &options);
+  PASS_STATUS;
+  status = napi_create_object(env, &units);
+  PASS_STATUS;
+  option = cls->option;
+  while ((option != nullptr) && (option->name != nullptr)) {
+    if (option->type != AV_OPT_TYPE_CONST) {
+      status = napi_create_object(env, &opt);
+      PASS_STATUS;
+      status = napi_set_named_property(env, options, option->name, opt);
+      PASS_STATUS;
+      status = beam_set_string_utf8(env, opt, "name", (char*) option->name);
+      PASS_STATUS;
+      status = beam_set_string_utf8(env, opt, "help", (char*) option->help);
+      PASS_STATUS;
+      status = beam_set_string_utf8(env, opt, "option_type",
+        (char*) beam_lookup_name(beam_option_type->forward, option->type));
+      PASS_STATUS;
+      status = napi_create_object(env, &flags);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "ENCODING_PARAM",
+        option->flags & AV_OPT_FLAG_ENCODING_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "DECODING_PARAM",
+        option->flags & AV_OPT_FLAG_DECODING_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "AUDIO_PARAM",
+        option->flags & AV_OPT_FLAG_AUDIO_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "VIDEO_PARAM",
+        option->flags & AV_OPT_FLAG_VIDEO_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "SUBTITLE_PARAM",
+        option->flags & AV_OPT_FLAG_SUBTITLE_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "EXPORT",
+        option->flags & AV_OPT_FLAG_EXPORT);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "READONLY",
+        option->flags & AV_OPT_FLAG_READONLY);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "BSF_PARAM",
+        option->flags & AV_OPT_FLAG_BSF_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "FILTERING_PARAM",
+        option->flags & AV_OPT_FLAG_FILTERING_PARAM);
+      PASS_STATUS;
+      status = beam_set_bool(env, flags, "DEPRECATED",
+        option->flags & AV_OPT_FLAG_DEPRECATED);
+      PASS_STATUS;
+      status = napi_set_named_property(env, opt, "flags", flags);
+      PASS_STATUS;
+      if (option->unit != nullptr) {
+        status = beam_set_string_utf8(env, opt, "unit", (char*) option->unit);
+        PASS_STATUS;
+        status = napi_create_array(env, &consts);
+        PASS_STATUS;
+        status = napi_set_named_property(env, opt, "consts", consts);
+        PASS_STATUS;
+        status = napi_set_named_property(env, units, option->unit, opt);
+        PASS_STATUS;
+      }
+    }
+    option = av_opt_next(&cls, option);
+  }
+  option = cls->option;
+  while ((option != nullptr) && (option->name != nullptr)) {
+    if (option->type == AV_OPT_TYPE_CONST) {
+      status = napi_get_named_property(env, units, option->unit, &opt);
+      PASS_STATUS;
+      status = napi_typeof(env, opt, &type);
+      PASS_STATUS;
+      if (type != napi_object) { // Assume badly described constant property
+        // TODO work with bad params like https://github.com/FFmpeg/FFmpeg/blob/a0ac49e38ee1d1011c394d7be67d0f08b2281526/libavformat/chromaprint.c#L167
+        //      parameter fp_format is missing option->unit
+        option = av_opt_next(&cls, option);
+        continue;
+      }
+      status = napi_get_named_property(env, opt, "consts", &consts);
+      PASS_STATUS;
+      status = napi_get_array_length(env, consts, &constCount);
+      PASS_STATUS;
+      status = napi_create_string_utf8(env, option->name, NAPI_AUTO_LENGTH, &element);
+      PASS_STATUS;
+      status = napi_set_element(env, consts, constCount, element);
+      PASS_STATUS;
+    }
+    option = av_opt_next(&cls, option);
+  }
+  status = napi_set_named_property(env, desc, "options", options);
+  PASS_STATUS;
+
+  *result = desc;
+  return napi_ok;
+}
+
+napi_status makeAVDictionary(napi_env env, napi_value options, AVDictionary** metadata) {
+  napi_status status;
+  napi_value names, key, value, valueS;
+  AVDictionary* dict = nullptr;
+  uint32_t propCount;
+  char *keyStr, *valueStr;
+  size_t strLen;
+  int ret;
+
+  status = napi_get_property_names(env, options, &names);
+  PASS_STATUS;
+  status = napi_get_array_length(env, names, &propCount);
+  PASS_STATUS;
+
+  // Replace all metadata values ... no partial operation
+  for ( uint32_t x = 0 ; x < propCount ; x++ ) {
+    status = napi_get_element(env, names, x, &key);
+    PASS_STATUS;
+    status = napi_get_property(env, options, key, &value);
+    PASS_STATUS;
+    status = napi_coerce_to_string(env, value, &valueS);
+    PASS_STATUS;
+
+    status = napi_get_value_string_utf8(env, key, nullptr, 0, &strLen);
+    PASS_STATUS;
+    keyStr = (char*) malloc(sizeof(char) * (strLen + 1));
+    status = napi_get_value_string_utf8(env, key, keyStr, strLen + 1, &strLen);
+    PASS_STATUS;
+
+    status = napi_get_value_string_utf8(env, valueS, nullptr, 0, &strLen);
+    PASS_STATUS;
+    valueStr = (char*) malloc(sizeof(char) * (strLen + 1));
+    status = napi_get_value_string_utf8(env, valueS, valueStr, strLen + 1, &strLen);
+    PASS_STATUS;
+
+    ret = av_dict_set(&dict, keyStr, valueStr, 0);
+    free(keyStr);
+    free(valueStr);
+    if (ret < 0) {
+      printf("DEBUG: %s\n", avErrorMsg("Problem setting dictionary entry: ", ret));
+      return napi_invalid_arg;
+    }
+  }
+
+  *metadata = dict;
+  return napi_ok;
+}
+
+napi_status fromContextPrivData(napi_env env, void *privData, napi_value* result) {
+  napi_status status;
+  napi_value optionsVal, bufferVal;
+  int64_t iValue;
+  double dValue;
+  uint8_t *data;
+  AVRational qValue;
+  AVPixelFormat pixFmt;
+  AVSampleFormat sampleFmt;
+  struct imageSizeData { int x; int y; };
+  imageSizeData *sizeData;
+  struct offsetData { uint8_t *addr; int len; };
+  offsetData *offData;
+  char chanLayStr[64];
+
+  int ret;
+  const AVOption *option = nullptr;
+  const AVOption *prev = nullptr;
+
+  status = napi_create_object(env, &optionsVal);
+  PASS_STATUS;
+  while ((option = av_opt_next(privData, option))) {
+    switch (option->type) {
+      case AV_OPT_TYPE_FLAGS:
+        printf("fromPrivOptions: flags option %s: %s\n", option->name, "unmapped");
+        status = beam_set_string_utf8(env, optionsVal, option->name, "unmapped type: flags");
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_INT:
+        ret = av_opt_get_int(privData, option->name, 0, &iValue);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        if (nullptr == option->unit) {
+          status = beam_set_int32(env, optionsVal, option->name, (int32_t)iValue);
+          PASS_STATUS;
+        } else {
+          if (iValue < 0) {
+            status = beam_set_string_utf8(env, optionsVal, option->name, "unknown");
+            PASS_STATUS;
+          } else {
+            data = (uint8_t *)option->name;
+            prev = option;
+            option = av_opt_next(privData, option);
+            while (option && (AV_OPT_TYPE_CONST == option->type)) {
+              prev = option;
+              if (option->default_val.i64 == iValue) {
+                // printf("fromPrivOptions: int option %s: %s\n", (const char*) data, option->name);
+                status = beam_set_string_utf8(env, optionsVal, (const char*) data, option->name);
+                PASS_STATUS;
+                break;
+              }
+              option = av_opt_next(privData, option);
+            }
+            option = prev;
+          }
+        }
+        break;
+      case AV_OPT_TYPE_INT64:
+      case AV_OPT_TYPE_UINT64:
+        ret = av_opt_get_int(privData, option->name, 0, &iValue);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        status = beam_set_int64(env, optionsVal, option->name, iValue);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_DOUBLE:
+      case AV_OPT_TYPE_FLOAT:
+        ret = av_opt_get_double(privData, option->name, 0, &dValue);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        status = beam_set_double(env, optionsVal, option->name, dValue);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_STRING:
+        ret = av_opt_get(privData, option->name, 0, &data);
+        if (ret < 0) {
+          return napi_string_expected;
+        }
+        status = beam_set_string_utf8(env, optionsVal, option->name, const_cast<char*>((char*) data));
+        av_free(data);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_RATIONAL:
+        ret = av_opt_get_q(privData, option->name, 0, &qValue);
+        if (ret < 0) {
+          return napi_object_expected;
+        }
+        status = beam_set_rational(env, optionsVal, option->name, qValue);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_BINARY:  ///< offset must point to a pointer immediately followed by an int for the length
+        offData = (offsetData *)((uint8_t*)privData + option->offset);
+        // printf("fromPrivOptions: binary option %s: %p, len 0x%x\n", option->name, offData->addr, offData->len);
+        if ((nullptr != offData->addr) && (0 != offData->len))
+          status = napi_create_buffer_copy(env, offData->len, offData->addr, (void **)&data, &bufferVal);
+        else
+          status = napi_get_null(env, &bufferVal);
+        PASS_STATUS;
+        status = napi_set_named_property(env, optionsVal, option->name, bufferVal);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_DICT:
+        printf("fromPrivOptions: dict option %s: %s\n", option->name, "unmapped");
+        status = beam_set_string_utf8(env, optionsVal, option->name, "unmapped type: dict");
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_CONST:
+        // printf("fromPrivOptions: const option %s: %s\n", option->name, "unmapped");
+        // status = beam_set_string_utf8(env, optionsVal, option->name, "unmapped type: const");
+        // PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_IMAGE_SIZE: ///< offset must point to two consecutive integers
+        sizeData = (imageSizeData *)((uint8_t*)privData + option->offset);
+        // printf("fromPrivOptions: image size option %s: %dx%d\n", option->name, sizeData->x, sizeData->y);
+        status = beam_set_rational(env, optionsVal, option->name, av_make_q(sizeData->x, sizeData->y));
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_PIXEL_FMT:
+        ret = av_opt_get_pixel_fmt(privData, option->name, 0, &pixFmt);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        status = beam_set_string_utf8(env, optionsVal, option->name, av_get_pix_fmt_name(pixFmt));
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_SAMPLE_FMT:
+        ret = av_opt_get_sample_fmt(privData, option->name, 0, &sampleFmt);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        status = beam_set_string_utf8(env, optionsVal, option->name, av_get_sample_fmt_name(sampleFmt));
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_VIDEO_RATE: ///< offset must point to AVRational
+        qValue = *(AVRational *)((uint8_t*)privData + option->offset);
+        // printf("fromPrivOptions: video rate option %s: %d:%d\n", option->name, qValue.num, qValue.den);
+        status = beam_set_rational(env, optionsVal, (char*) option->name, qValue);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_DURATION:
+        printf("fromPrivOptions: duration option %s: %s\n", option->name, "unmapped");
+        status = beam_set_string_utf8(env, optionsVal, option->name, "unmapped type: duration");
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_COLOR:
+        printf("fromPrivOptions: color option %s: %s\n", option->name, "unmapped");
+        status = beam_set_string_utf8(env, optionsVal, option->name, "unmapped type: color");
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_CHANNEL_LAYOUT:
+        ret = av_opt_get_channel_layout(privData, option->name, 0, &iValue);
+        if (ret < 0) {
+          return napi_number_expected;
+        }
+        av_get_channel_layout_string(chanLayStr, 64, 0, iValue);
+        // printf("fromPrivOptions: channel layout option %s: %lli - %s\n", option->name, iValue, chanLayStr);
+        status = beam_set_string_utf8(env, optionsVal, option->name, chanLayStr);
+        PASS_STATUS;
+        break;
+      case AV_OPT_TYPE_BOOL:
+        ret = av_opt_get_int(privData, option->name, 0, &iValue);
+        if (ret < 0) {
+          return napi_boolean_expected;
+        }
+        // printf("fromPrivOptions: bool option %s: %lli\n", option->name, iValue);
+        status = beam_set_bool(env, optionsVal, option->name, iValue);
+        PASS_STATUS;
+        break;
+      default:
+        printf("fromPrivOptions: unknown (type %d) option %s: %s\n", option->type, option->name, "unmapped");
+        status = beam_set_string_utf8(env, optionsVal, option->name, "unknown type");
+        PASS_STATUS;
+        break;
+    }
+  }
+
+  *result = optionsVal;
+  return napi_ok;
+}
+
+napi_status toContextPrivData(napi_env env, napi_value params, void* priv_data) {
+  napi_status status;
+  napi_value names, element, subel;
+  napi_valuetype type, subtype;
+  bool isArray, flag;
+  double dValue;
+  uint32_t uThirtwo;
+  char* sValue;
+  char* strProp;
+  size_t sLen;
+  const AVOption* option;
+  int64_t iValue;
+  int ret;
+  AVRational qValue = {0,0};
+
+  if (priv_data == nullptr) {
+    return napi_invalid_arg;
+  }
+
+  status = napi_typeof(env, params, &type);
+  PASS_STATUS;
+  status = napi_is_array(env, params, &isArray);
+  PASS_STATUS;
+  if ((isArray == false) && (type == napi_object)) {
+    status = napi_get_property_names(env, params, &names);
+    PASS_STATUS;
+    status = napi_get_array_length(env, names, &uThirtwo);
+    PASS_STATUS;
+    for ( uint32_t x = 0 ; x < uThirtwo ; x++ ) {
+      status = napi_get_element(env, names, x, &element);
+      PASS_STATUS;
+      status = napi_get_value_string_utf8(env, element, nullptr, 0, &sLen);
+      PASS_STATUS;
+      sValue = (char*) malloc(sizeof(char) * (sLen + 1));
+      status = napi_get_value_string_utf8(env, element, sValue, sLen + 1, &sLen);
+      PASS_STATUS;
+      option = av_opt_find(priv_data, sValue, nullptr, 0, 0);
+      if (option != nullptr) {
+        if (option->flags & AV_OPT_FLAG_READONLY) { continue; }
+        status = napi_get_named_property(env, params, sValue, &element);
+        PASS_STATUS;
+        status = napi_typeof(env, element, &type);
+        PASS_STATUS;
+        switch (type) {
+          case napi_boolean:
+            status = napi_get_value_bool(env, element, &flag);
+            PASS_STATUS;
+            ret = av_opt_set_int(priv_data, sValue, flag, 0);
+            if (ret < 0) printf("DEBUG: Unable to set %s with a boolean value.\n", sValue);
+            break;
+          case napi_number:
+            if ((option->type == AV_OPT_TYPE_DOUBLE) ||
+                (option->type == AV_OPT_TYPE_FLOAT)) {
+              status = napi_get_value_double(env, element, &dValue);
+              PASS_STATUS;
+              ret = av_opt_set_double(priv_data, sValue, dValue, 0);
+              if (ret < 0) printf("DEBUG: Unable to set %s with a double value %f.\n", sValue, dValue);
+              break;
+            }
+            status = napi_get_value_int64(env, element, &iValue);
+            PASS_STATUS;
+            ret = av_opt_set_int(priv_data, sValue, iValue, 0);
+            if (ret < 0) printf("DEBUG: Unable to set %s with an integer value %" PRId64 ": %s.\n",
+              sValue, iValue, avErrorMsg("", ret));
+            break;
+          case napi_string:
+            status = napi_get_value_string_utf8(env, element, nullptr, 0, &sLen);
+            PASS_STATUS;
+            strProp = (char*) malloc(sizeof(char) * (sLen + 1));
+            PASS_STATUS;
+            status = napi_get_value_string_utf8(env, element, strProp, sLen + 1, &sLen);
+            PASS_STATUS;
+            ret = av_opt_set(priv_data, sValue, strProp, 0);
+            free(strProp);
+            if (ret < 0) printf("DEBUG: Unable to set %s with a string value %s.\n", sValue, strProp);
+            break;
+          case napi_object:
+            status = napi_is_array(env, element, &isArray);
+            PASS_STATUS;
+            if (isArray && (option->type == AV_OPT_TYPE_RATIONAL)) {
+              status = napi_get_element(env, element, 0, &subel);
+              PASS_STATUS;
+              status = napi_typeof(env, subel, &subtype);
+              PASS_STATUS;
+              if (subtype != napi_number) {
+                printf("DEBUG: Non-number value for rational numerator of property %s.\n", sValue);
+                break;
+              }
+              status = napi_get_value_int32(env, subel, &qValue.num);
+              PASS_STATUS;
+              status = napi_get_element(env, element, 1, &subel);
+              PASS_STATUS;
+              status = napi_typeof(env, subel, &subtype);
+              PASS_STATUS;
+              if (subtype != napi_number) {
+                printf("DEBUG: Non-number value for rational denominator of property %s.\n", sValue);
+                qValue.num = 0; qValue.den = 1;
+                break;
+              }
+              status = napi_get_value_int32(env, subel, &qValue.den);
+              PASS_STATUS;
+              ret = av_opt_set_q(priv_data, sValue, qValue, 0);
+              if (ret < 0) {
+                printf("DEBUG: Failed to set rational property %s.\n", sValue);
+              }
+              qValue.num = 0; qValue.den = 1;
+            } else {
+              printf("DEBUG: Non-array for non-rational property %s.\n", sValue);
+            }
+            break;
+          default:
+            printf("DEBUG: Failed to set a private data value %s\n", sValue);
+            break;
+        }
+      } else {
+        printf("DEBUG: Option %s not found.\n", sValue);
+      }
+      free(sValue);
+    }
+  } else {
+    return napi_invalid_arg;
+  }
+
+  return napi_ok;
+}
+
+std::unordered_map<int, std::string> beam_field_order_fmap = {
+  { AV_FIELD_PROGRESSIVE, "progressive" },
+  { AV_FIELD_TT, "top coded first, top displayed first" },
+  { AV_FIELD_BB, "bottom coded first, bottom displayed first" },
+  { AV_FIELD_TB, "top coded first, bottom displayed first" },
+  { AV_FIELD_BT, "bottom coded first, top displayed first" },
+  { AV_FIELD_UNKNOWN, "unknown" }
+};
+const beamEnum* beam_field_order = new beamEnum(beam_field_order_fmap);
+
+std::unordered_map<int, std::string> beam_ff_cmp_fmap = {
+  { FF_CMP_SAD, "sad" },
+  { FF_CMP_SSE, "sse" },
+  { FF_CMP_SATD, "satd" },
+  { FF_CMP_DCT, "dct" },
+  { FF_CMP_PSNR, "psnr" },
+  { FF_CMP_BIT, "bit" },
+  { FF_CMP_RD, "rd" },
+  { FF_CMP_ZERO, "zero" },
+  { FF_CMP_VSAD, "vsad" },
+  { FF_CMP_VSSE, "vsse" },
+  { FF_CMP_NSSE, "nsse" },
+  { FF_CMP_W53, "w53" },
+  { FF_CMP_W97, "w97" },
+  { FF_CMP_DCTMAX, "dctmax" },
+  { FF_CMP_DCT264, "dct264" },
+  { FF_CMP_MEDIAN_SAD, "median_sad" },
+  { FF_CMP_CHROMA, "chroma" },
+};
+const beamEnum* beam_ff_cmp = new beamEnum(beam_ff_cmp_fmap);
+
+std::unordered_map<int, std::string> beam_ff_mb_decision_fmap = {
+  { FF_MB_DECISION_SIMPLE, "simple" }, //  uses mb_cmp
+  { FF_MB_DECISION_BITS, "bits" }, // chooses the one which needs the fewest bits
+  { FF_MB_DECISION_RD, "rd" } // rate distortion
+};
+const beamEnum* beam_ff_mb_decision = new beamEnum(beam_ff_mb_decision_fmap);
+
+std::unordered_map<int, std::string> beam_av_audio_service_type_fmap = {
+  { AV_AUDIO_SERVICE_TYPE_MAIN, "main" },
+  { AV_AUDIO_SERVICE_TYPE_EFFECTS, "effects" },
+  { AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED, "visually-impaired" },
+  { AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED, "hearing-impaired" },
+  { AV_AUDIO_SERVICE_TYPE_DIALOGUE, "dialogue" },
+  { AV_AUDIO_SERVICE_TYPE_COMMENTARY, "commentary" },
+  { AV_AUDIO_SERVICE_TYPE_EMERGENCY, "emergency" },
+  { AV_AUDIO_SERVICE_TYPE_VOICE_OVER, "voice-over" },
+  { AV_AUDIO_SERVICE_TYPE_KARAOKE, "karaoke" },
+  { AV_AUDIO_SERVICE_TYPE_NB, "nb" }
+};
+const beamEnum* beam_av_audio_service_type = new beamEnum(beam_av_audio_service_type_fmap);
+
+std::unordered_map<int, std::string> beam_ff_compliance_fmap = {
+  { FF_COMPLIANCE_VERY_STRICT, "very-strict" },
+  { FF_COMPLIANCE_STRICT, "strict" },
+  { FF_COMPLIANCE_NORMAL, "normal" },
+  { FF_COMPLIANCE_UNOFFICIAL, "unofficial" },
+  { FF_COMPLIANCE_EXPERIMENTAL, "experimental" }
+};
+const beamEnum* beam_ff_compliance = new beamEnum(beam_ff_compliance_fmap);
+
+std::unordered_map<int, std::string> beam_ff_dct_fmap = {
+  { FF_DCT_AUTO, "auto" },
+  { FF_DCT_FASTINT, "fastint "},
+  { FF_DCT_INT, "int" },
+  { FF_DCT_MMX, "mmx" },
+  { FF_DCT_ALTIVEC, "altivec" },
+  { FF_DCT_FAAN, "faan" }
+};
+const beamEnum* beam_ff_dct = new beamEnum(beam_ff_dct_fmap);
+
+std::unordered_map<int, std::string> beam_ff_idct_fmap = {
+  { FF_IDCT_AUTO, "auto" },
+  { FF_IDCT_INT, "int" },
+  { FF_IDCT_SIMPLE, "simple" },
+  { FF_IDCT_SIMPLEMMX, "simplemmx" },
+  { FF_IDCT_ARM, "arm" },
+  { FF_IDCT_ALTIVEC, "altivec" },
+  { FF_IDCT_SIMPLEARM, "simplearm" },
+  { FF_IDCT_XVID, "xvid" },
+  { FF_IDCT_SIMPLEARMV5TE, "simplearmv5te" },
+  { FF_IDCT_SIMPLEARMV6, "simplearmv6" },
+  { FF_IDCT_FAAN, "faan" },
+  { FF_IDCT_SIMPLENEON, "simpleneon" },
+  { FF_IDCT_NONE, "none" },
+  { FF_IDCT_SIMPLEAUTO, "simpleauto" },
+};
+const beamEnum* beam_ff_idct = new beamEnum(beam_ff_idct_fmap);
+
+std::unordered_map<int, std::string> beam_avdiscard_fmap = {
+  { AVDISCARD_NONE, "none" },
+  { AVDISCARD_DEFAULT, "default" },
+  { AVDISCARD_NONREF, "nonref" },
+  { AVDISCARD_BIDIR, "bidir" },
+  { AVDISCARD_NONINTRA, "nonintra" },
+  { AVDISCARD_NONKEY, "nonkey" },
+  { AVDISCARD_ALL, "all" }
+};
+const beamEnum* beam_avdiscard = new beamEnum(beam_avdiscard_fmap);
+
+std::unordered_map<int, std::string> beam_ff_sub_charenc_mode_fmap = {
+  // do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance
+  { FF_SUB_CHARENC_MODE_DO_NOTHING, "do-nothing" },
+  // libavcodec will select the mode itself
+  { FF_SUB_CHARENC_MODE_AUTOMATIC, "automatic" },
+  // the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
+  { FF_SUB_CHARENC_MODE_PRE_DECODER, "pre-decoder" },
+  // neither convert the subtitles, nor check them for valid UTF-8
+  { FF_SUB_CHARENC_MODE_IGNORE, "ignore" }
+};
+const beamEnum* beam_ff_sub_charenc_mode = new beamEnum(beam_ff_sub_charenc_mode_fmap);
+
+std::unordered_map<int, std::string> beam_avmedia_type_fmap = {
+  { AVMEDIA_TYPE_VIDEO, "video" },
+  { AVMEDIA_TYPE_AUDIO, "audio" },
+  { AVMEDIA_TYPE_DATA, "data" },
+  { AVMEDIA_TYPE_SUBTITLE, "subtitle" },
+  { AVMEDIA_TYPE_ATTACHMENT, "attachment" }
+};
+const beamEnum* beam_avmedia_type = new beamEnum(beam_avmedia_type_fmap);
+
+std::unordered_map<int, std::string> beam_option_type_fmap = {
+  { AV_OPT_TYPE_FLAGS, "flags" },
+  { AV_OPT_TYPE_INT, "int" },
+  { AV_OPT_TYPE_INT64, "int64" },
+  { AV_OPT_TYPE_DOUBLE, "double" },
+  { AV_OPT_TYPE_FLOAT, "float" },
+  { AV_OPT_TYPE_STRING, "string" },
+  { AV_OPT_TYPE_RATIONAL, "rational" },
+  { AV_OPT_TYPE_BINARY, "binary" }, ///< offset must point to a pointer immediately followed by an int for the length
+  { AV_OPT_TYPE_DICT, "dict" },
+  { AV_OPT_TYPE_UINT64, "uint64" },
+  { AV_OPT_TYPE_CONST, "const" },
+  { AV_OPT_TYPE_IMAGE_SIZE, "image_size" }, ///< offset must point to two consecutive integers
+  { AV_OPT_TYPE_PIXEL_FMT, "pixel_fmt" },
+  { AV_OPT_TYPE_SAMPLE_FMT, "sample_fmt" },
+  { AV_OPT_TYPE_VIDEO_RATE, "video_rate" }, ///< offset must point to AVRational
+  { AV_OPT_TYPE_DURATION, "duration" },
+  { AV_OPT_TYPE_COLOR, "color" },
+  { AV_OPT_TYPE_CHANNEL_LAYOUT, "channel_layout" },
+  { AV_OPT_TYPE_BOOL, "bool" }
+};
+const beamEnum* beam_option_type = new beamEnum(beam_option_type_fmap);
+
+std::unordered_map<int, std::string> beam_avoid_neg_ts_fmap = {
+  { AVFMT_AVOID_NEG_TS_AUTO, "auto" },
+  { AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE, "make_non_negative" },
+  { AVFMT_AVOID_NEG_TS_MAKE_ZERO, "make_zero" }
+};
+const beamEnum* beam_avoid_neg_ts = new beamEnum(beam_avoid_neg_ts_fmap);
+
+std::unordered_map<int, std::string> beam_avfmt_duration2_fmap = {
+  { AVFMT_DURATION_FROM_PTS, "from_pts" },
+  { AVFMT_DURATION_FROM_STREAM, "from_stream" },
+  { AVFMT_DURATION_FROM_BITRATE, "from_bitrate" }
+};
+const beamEnum* beam_avfmt_duration2 = new beamEnum(beam_avfmt_duration2_fmap);
+
+std::unordered_map<int, std::string> beam_packet_side_data_type_fmap = {
+  { AV_PKT_DATA_PALETTE, "palette" },
+  { AV_PKT_DATA_NEW_EXTRADATA, "new_extradata" },
+  { AV_PKT_DATA_PARAM_CHANGE, "param_change" },
+  { AV_PKT_DATA_H263_MB_INFO, "h263_mb_info" },
+  { AV_PKT_DATA_REPLAYGAIN, "replaygain" },
+  { AV_PKT_DATA_DISPLAYMATRIX, "displaymatrix" },
+  { AV_PKT_DATA_STEREO3D, "stereo3d" },
+  { AV_PKT_DATA_AUDIO_SERVICE_TYPE, "audio_service_type" },
+  { AV_PKT_DATA_QUALITY_STATS, "quality_stats" },
+  { AV_PKT_DATA_FALLBACK_TRACK, "fallback_track" },
+  { AV_PKT_DATA_CPB_PROPERTIES, "cpb_properties" },
+  { AV_PKT_DATA_SKIP_SAMPLES, "skip_samples" },
+  { AV_PKT_DATA_JP_DUALMONO, "jp_dualmono" },
+  { AV_PKT_DATA_STRINGS_METADATA, "strings_metadata" },
+  { AV_PKT_DATA_SUBTITLE_POSITION, "subtitle_position" },
+  { AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, "matroska_blockadditional" },
+  { AV_PKT_DATA_WEBVTT_IDENTIFIER, "webvtt_identifier" },
+  { AV_PKT_DATA_WEBVTT_SETTINGS, "webvtt_settings" },
+  { AV_PKT_DATA_METADATA_UPDATE, "metadata_update" },
+  { AV_PKT_DATA_MPEGTS_STREAM_ID, "mpegts_stream_id" },
+  { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, "mastering_display_metadata" },
+  { AV_PKT_DATA_SPHERICAL, "spherical" },
+  { AV_PKT_DATA_CONTENT_LIGHT_LEVEL, "content_light_level" },
+  { AV_PKT_DATA_A53_CC, "a53_cc" },
+  { AV_PKT_DATA_ENCRYPTION_INIT_INFO, "encryption_init_info" },
+  { AV_PKT_DATA_ENCRYPTION_INFO, "encyption_info" },
+  { AV_PKT_DATA_AFD, "afd" }
+};
+const beamEnum* beam_packet_side_data_type = new beamEnum(beam_packet_side_data_type_fmap);
+
+std::unordered_map<int, std::string> beam_frame_side_data_type_fmap = {
+  { AV_FRAME_DATA_PANSCAN, "panscan" },
+  { AV_FRAME_DATA_A53_CC, "a53_cc" },
+  { AV_FRAME_DATA_STEREO3D, "stereo3d" },
+  { AV_FRAME_DATA_MATRIXENCODING, "matrixencoding" },
+  { AV_FRAME_DATA_DOWNMIX_INFO, "downmix_info" },
+  { AV_FRAME_DATA_REPLAYGAIN, "replaygain" },
+  { AV_FRAME_DATA_DISPLAYMATRIX, "displaymatrix" },
+  { AV_FRAME_DATA_AFD, "afd" },
+  { AV_FRAME_DATA_MOTION_VECTORS, "motion_vectors" },
+  { AV_FRAME_DATA_SKIP_SAMPLES, "skip_samples" },
+  { AV_FRAME_DATA_AUDIO_SERVICE_TYPE, "audio_service_type" },
+  { AV_FRAME_DATA_MASTERING_DISPLAY_METADATA, "mastering_display_metadata" },
+  { AV_FRAME_DATA_GOP_TIMECODE, "gop_timecode" },
+  { AV_FRAME_DATA_SPHERICAL, "spherical" },
+  { AV_FRAME_DATA_CONTENT_LIGHT_LEVEL, "light_level" },
+  { AV_FRAME_DATA_ICC_PROFILE, "icc_profile" },
+  { AV_FRAME_DATA_S12M_TIMECODE, "s12m_timecode" }
+};
+const beamEnum* beam_frame_side_data_type = new beamEnum(beam_frame_side_data_type_fmap);