@stagetimerio/grandiose 0.1.0

package/src/grandiose_send.h

@@ -0,0 +1,47 @@
+/* Copyright 2018 Streampunk Media Ltd.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#ifndef GRANDIOSE_SEND_H
+#define GRANDIOSE_SEND_H
+
+#include "node_api.h"
+#include "grandiose_util.h"
+
+napi_value send(napi_env env, napi_callback_info info);
+
+struct sendCarrier : carrier {
+  char* name = nullptr;
+  char* groups = nullptr;
+  bool clockVideo = false;
+  bool clockAudio = false;
+  NDIlib_send_instance_t send;
+  ~sendCarrier() {
+    free(name);
+  }
+};
+
+struct sendDataCarrier : carrier {
+  NDIlib_send_instance_t send;
+  NDIlib_video_frame_v2_t videoFrame;
+  NDIlib_audio_frame_v3_t audioFrame;
+  NDIlib_metadata_frame_t metadataFrame;
+  napi_ref sourceBufferRef = nullptr;
+  ~sendDataCarrier() {
+    // TODO: free sourceBufferRef
+  }
+};
+
+
+#endif /* GRANDIOSE_SEND_H */

package/src/grandiose_util.cc

@@ -0,0 +1,282 @@
+/* Copyright 2018 Streampunk Media Ltd.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <chrono>
+#include <string>
+#include <algorithm>
+#include <Processing.NDI.Lib.h>
+#include "grandiose_util.h"
+#include "node_api.h"
+using namespace std;
+
+// Implementation of itoa()
+char* custom_itoa(int num, char* str, int base)
+{
+  int i = 0;
+  bool isNegative = false;
+
+  /* Handle 0 explicitely, otherwise empty string is printed for 0 */
+  if (num == 0)
+  {
+    str[i++] = '0';
+    str[i] = '\0';
+    return str;
+  }
+
+  // In standard itoa(), negative numbers are handled only with
+  // base 10. Otherwise numbers are considered unsigned.
+  if (num < 0 && base == 10)
+  {
+    isNegative = true;
+    num = -num;
+  }
+
+  // Process individual digits
+  while (num != 0)
+  {
+    int rem = num % base;
+    str[i++] = (rem > 9)? (rem-10) + 'a' : rem + '0';
+    num = num/base;
+  }
+
+  // If number is negative, append '-'
+  if (isNegative)
+    str[i++] = '-';
+
+  str[i] = '\0'; // Append string terminator
+
+  // Reverse the string
+  std::reverse(std::string(str).begin(), std::string(str).end());
+
+  return str;
+}
+
+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) {
+    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];
+  throwStatus = napi_throw_error(env,
+    custom_itoa(errorInfo->error_code, errorCode, 10), 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);
+  if (status != napi_ok) return status;
+
+  if (realArgc != argc) {
+    char errorMsg[100];
+    snprintf(errorMsg, sizeof(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 ( int x = 0 ; x < (int)argc ; x++ ) {
+    status = napi_typeof(env, args[x], &t);
+    if (status != napi_ok) return status;
+    if (t != types[x]) {
+      char errorMsg[100];
+      snprintf(errorMsg, sizeof(errorMsg), "For method %s argument %i, 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;
+  }
+  delete c;
+}
+
+int32_t rejectStatus(napi_env env, carrier* c, const char* file, int32_t line) {
+  if (c->status != GRANDIOSE_SUCCESS) {
+    napi_value errorValue, errorCode, errorMsg;
+    napi_status status;
+    char errorChars[20];
+    if (c->status < GRANDIOSE_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);
+    }
+    char* extMsg = (char *) malloc(sizeof(char) * c->errorMsg.length() + 200);
+    snprintf(extMsg, sizeof(char) * c->errorMsg.length() + 200, "In file %s on line %i, found error: %s", file, line, c->errorMsg.c_str());
+    status = napi_create_string_utf8(env, custom_itoa(c->status, errorChars, 10),
+      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;
+
+    //free(extMsg);
+    tidyCarrier(env, c);
+  }
+  return c->status;
+}
+
+bool validColorFormat(NDIlib_recv_color_format_e format) {
+  switch (format) {
+    case NDIlib_recv_color_format_BGRX_BGRA:
+    case NDIlib_recv_color_format_UYVY_BGRA:
+    case NDIlib_recv_color_format_RGBX_RGBA:
+    case NDIlib_recv_color_format_UYVY_RGBA:
+    case NDIlib_recv_color_format_fastest:
+  #ifdef _WIN32
+    case 	NDIlib_recv_color_format_BGRX_BGRA_flipped:
+  #endif
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool validBandwidth(NDIlib_recv_bandwidth_e bandwidth) {
+  switch (bandwidth) {
+    case NDIlib_recv_bandwidth_metadata_only:
+    case NDIlib_recv_bandwidth_audio_only:
+    case NDIlib_recv_bandwidth_lowest:
+    case NDIlib_recv_bandwidth_highest:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool validFrameFormat(NDIlib_frame_format_type_e format) {
+  switch (format) {
+    case NDIlib_frame_format_type_progressive:
+    case NDIlib_frame_format_type_interleaved:
+    case NDIlib_frame_format_type_field_0:
+    case NDIlib_frame_format_type_field_1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool validAudioFormat(Grandiose_audio_format_e format) {
+  switch (format) {
+    case Grandiose_audio_format_float_32_separate:
+    case Grandiose_audio_format_int_16_interleaved:
+    case Grandiose_audio_format_float_32_interleaved:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// Make a native source object from components of a source object
+napi_status makeNativeSource(napi_env env, napi_value source, NDIlib_source_t *result) {
+  const char* name = nullptr;
+  const char* url = nullptr;
+  napi_status status;
+  napi_valuetype type;
+  napi_value namev, urlv;
+  size_t namel, urll;
+
+  status = napi_get_named_property(env, source, "name", &namev);
+  PASS_STATUS;
+  status = napi_get_named_property(env, source, "urlAddress", &urlv);
+  PASS_STATUS;
+
+  status = napi_typeof(env, namev, &type);
+  PASS_STATUS;
+  if (type == napi_string) {
+    status = napi_get_value_string_utf8(env, namev, nullptr, 0, &namel);
+    PASS_STATUS;
+    name = (char *) malloc(namel + 1);
+    status = napi_get_value_string_utf8(env, namev, (char*) name, namel + 1, &namel);
+    PASS_STATUS;
+  }
+
+  status = napi_typeof(env, urlv, &type);
+  PASS_STATUS;
+  if (type == napi_string) {
+    status = napi_get_value_string_utf8(env, urlv, nullptr, 0, &urll);
+    PASS_STATUS;
+    url = (char *) malloc(urll + 1);
+    status = napi_get_value_string_utf8(env, urlv, (char*) url, urll + 1, &urll);
+    PASS_STATUS;
+  }
+
+  result->p_ndi_name = name;
+  result->p_url_address = url;
+  return napi_ok;
+}
+

package/src/grandiose_util.h

@@ -0,0 +1,120 @@
+/* Copyright 2018 Streampunk Media Ltd.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#ifndef GRANDIOSE_UTIL_H
+#define GRANDIOSE_UTIL_H
+
+#include <chrono>
+#include <stdio.h>
+#include <string>
+#include <Processing.NDI.Lib.h>
+#include "node_api.h"
+
+// The three different formats of raw audio data supported by NDI utility functions
+typedef enum Grandiose_audio_format_e {
+  // Default NDI audio format
+  // Channels stored one after the other in each block - 32-bit floating point values
+  Grandiose_audio_format_float_32_separate = 0,
+  // Alternative NDI audio foramt
+  // Channels stored as channel-interleaved 32-bit floating point values
+  Grandiose_audio_format_float_32_interleaved = 1,
+  // Alternative NDI audio format
+  // Channels stored as channel-interleaved 16-bit integer values
+  Grandiose_audio_format_int_16_interleaved = 2
+} Grandiose_audio_format_e;
+
+#define DECLARE_NAPI_METHOD(name, func) { name, 0, func, 0, 0, 0, napi_default, 0 }
+
+// Handling NAPI errors - use "napi_status status;" where used
+#define CHECK_STATUS if (checkStatus(env, status, __FILE__, __LINE__ - 1) != napi_ok) return nullptr
+#define PASS_STATUS if (status != napi_ok) return status
+
+napi_status checkStatus(napi_env env, napi_status status,
+  const char * file, uint32_t line);
+
+// High resolution timing
+#define HR_TIME_POINT std::chrono::high_resolution_clock::time_point
+#define NOW std::chrono::high_resolution_clock::now()
+long long microTime(std::chrono::high_resolution_clock::time_point start);
+
+// Argument processing
+napi_status checkArgs(napi_env env, napi_callback_info info, char* methodName,
+  napi_value* args, size_t argc, napi_valuetype* types);
+
+// Async error handling
+#define GRANDIOSE_ERROR_START 4000
+#define GRANDIOSE_INVALID_ARGS 4001
+#define GRANDIOSE_OUT_OF_RANGE 4097
+#define GRANDIOSE_ASYNC_FAILURE 4098
+#define GRANDIOSE_BUILD_ERROR 4099
+#define GRANDIOSE_ALLOCATION_FAILURE 4100
+#define GRANDIOSE_RECEIVE_CREATE_FAIL 4101
+#define GRANDIOSE_SEND_CREATE_FAIL 4102
+#define GRANDIOSE_ROUTING_CREATE_FAIL 4103
+#define GRANDIOSE_FIND_CREATE_FAIL 4104
+#define GRANDIOSE_NOT_FOUND 4040
+#define GRANDIOSE_NOT_VIDEO 4140
+#define GRANDIOSE_NOT_AUDIO 4141
+#define GRANDIOSE_NOT_METADATA 4142
+#define GRANDIOSE_CONNECTION_LOST 4143
+#define GRANDIOSE_SUCCESS 0
+
+struct carrier {
+  virtual ~carrier() {}
+  napi_ref passthru = nullptr;
+  int32_t status = GRANDIOSE_SUCCESS;
+  std::string errorMsg;
+  long long totalTime;
+  napi_deferred _deferred;
+  napi_async_work _request = nullptr;
+};
+
+void tidyCarrier(napi_env env, carrier* c);
+int32_t rejectStatus(napi_env env, carrier* c, const char* file, int32_t line);
+
+#define REJECT_STATUS if (rejectStatus(env, c, __FILE__, __LINE__) != GRANDIOSE_SUCCESS) return;
+#define REJECT_RETURN if (rejectStatus(env, c, __FILE__, __LINE__) != GRANDIOSE_SUCCESS) return promise;
+#define FLOATING_STATUS if (status != napi_ok) { \
+  printf("Unexpected N-API status not OK in file %s at line %d value %i.\n", \
+    __FILE__, __LINE__ - 1, status); \
+}
+
+#define NAPI_THROW_ERROR(msg) { \
+  char errorMsg[100]; \
+  snprintf(errorMsg, sizeof(errorMsg), msg); \
+  napi_throw_error(env, nullptr, errorMsg); \
+  return nullptr; \
+}
+
+#define REJECT_ERROR(msg, status) { \
+  c->errorMsg = msg; \
+  c->status = status; \
+  REJECT_STATUS; \
+}
+
+#define REJECT_ERROR_RETURN(msg, stat) { \
+  c->errorMsg = msg; \
+  c->status = stat; \
+  REJECT_RETURN; \
+}
+
+bool validColorFormat(NDIlib_recv_color_format_e format);
+bool validBandwidth(NDIlib_recv_bandwidth_e bandwidth);
+bool validFrameFormat(NDIlib_frame_format_type_e format);
+bool validAudioFormat(Grandiose_audio_format_e format);
+
+napi_status makeNativeSource(napi_env env, napi_value source, NDIlib_source_t *result);
+
+#endif // GRANDIOSE_UTIL_H