truehear-audio-library-node 1.0.0

package/src/addon.c

@@ -0,0 +1,612 @@
+#include "truehear_audio.h"
+
+#include <node_api.h>
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ---------------------------------------------------------------------------------------------- */
+/* N-API helpers                                                                                    */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Convert an N-API status into a JavaScript exception.
+ *
+ * Most napi_* functions return napi_status.
+ * If the status is not napi_ok, something failed while talking to Node.js.
+ */
+static int truehear_napi_check(
+  napi_env env,
+  napi_status status,
+  const char *operation) {
+  if (status == napi_ok) {
+    return 1;
+  }
+
+  const napi_extended_error_info *error_info = NULL;
+  napi_get_last_error_info(env, &error_info);
+
+  const char *details = "Unknown N-API error";
+
+  if (error_info != NULL && error_info->error_message != NULL) {
+    details = error_info->error_message;
+  }
+
+  char message[512];
+
+  snprintf(
+    message,
+    sizeof(message),
+    "%s failed: %s",
+    operation,
+    details);
+
+  bool exception_pending = false;
+  napi_is_exception_pending(env, &exception_pending);
+
+  if (!exception_pending) {
+    napi_throw_error(env, NULL, message);
+  }
+
+  return 0;
+}
+
+/*
+ * Throw a TypeError from C.
+ */
+static void truehear_throw_type_error(
+  napi_env env,
+  const char *message) {
+  napi_throw_type_error(env, NULL, message);
+}
+
+/*
+ * Throw a normal Error from C.
+ */
+static void truehear_throw_error(
+  napi_env env,
+  const char *message) {
+  napi_throw_error(env, NULL, message);
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* String helpers                                                                                   */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Read a JavaScript string argument into a newly allocated UTF-8 C string.
+ *
+ * Caller must free the returned pointer.
+ */
+static char *truehear_get_utf8_string(
+  napi_env env,
+  napi_value value,
+  const char *argument_name) {
+  napi_valuetype value_type;
+
+  if (!truehear_napi_check(
+    env,
+    napi_typeof(env, value, &value_type),
+    "napi_typeof")) {
+    return NULL;
+  }
+
+  if (value_type != napi_string) {
+    char message[256];
+
+    snprintf(
+      message,
+      sizeof(message),
+      "%s must be a string",
+      argument_name);
+
+    truehear_throw_type_error(env, message);
+    return NULL;
+  }
+
+  size_t length = 0;
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_value_string_utf8(env, value, NULL, 0, &length),
+    "napi_get_value_string_utf8(length)")) {
+    return NULL;
+  }
+
+  char *buffer = (char *)malloc(length + 1);
+
+  if (buffer == NULL) {
+    truehear_throw_error(env, "Failed to allocate string buffer");
+    return NULL;
+  }
+
+  size_t copied = 0;
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_value_string_utf8(env, value, buffer, length + 1, &copied),
+    "napi_get_value_string_utf8(value)")) {
+    free(buffer);
+    return NULL;
+  }
+
+  return buffer;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Audio type conversion                                                                            */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Convert JavaScript:
+ *
+ *   "playback"
+ *   "recording"
+ *
+ * into the C enum:
+ *
+ *   TRUEHEAR_AUDIO_DEVICE_TYPE_PLAYBACK
+ *   TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING
+ */
+static int truehear_parse_device_type(
+  napi_env env,
+  napi_value value,
+  TruehearAudioDeviceType *out_type) {
+  if (out_type == NULL) {
+    truehear_throw_error(env, "out_type pointer is NULL");
+    return 0;
+  }
+
+  char *type = truehear_get_utf8_string(env, value, "type");
+
+  if (type == NULL) {
+    return 0;
+  }
+
+  if (strcmp(type, "playback") == 0) {
+    *out_type = TRUEHEAR_AUDIO_DEVICE_TYPE_PLAYBACK;
+    free(type);
+    return 1;
+  }
+
+  if (strcmp(type, "recording") == 0) {
+    *out_type = TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING;
+    free(type);
+    return 1;
+  }
+
+  free(type);
+
+  truehear_throw_type_error(
+    env,
+    "type must be either \"playback\" or \"recording\"");
+
+  return 0;
+}
+
+/*
+ * Convert C enum back to JavaScript string.
+ */
+static const char *truehear_device_type_to_string(
+  TruehearAudioDeviceType type) {
+  switch (type) {
+  case TRUEHEAR_AUDIO_DEVICE_TYPE_PLAYBACK:
+    return "playback";
+
+  case TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING:
+    return "recording";
+
+  default:
+    return "unknown";
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* JavaScript object helpers                                                                        */
+/* ---------------------------------------------------------------------------------------------- */
+
+static int truehear_set_string_property(
+  napi_env env,
+  napi_value object,
+  const char *name,
+  const char *value) {
+  napi_value js_value;
+
+  if (value == NULL) {
+    value = "";
+  }
+
+  if (!truehear_napi_check(
+    env,
+    napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &js_value),
+    "napi_create_string_utf8")) {
+    return 0;
+  }
+
+  if (!truehear_napi_check(
+    env,
+    napi_set_named_property(env, object, name, js_value),
+    "napi_set_named_property(string)")) {
+    return 0;
+  }
+
+  return 1;
+}
+
+static int truehear_set_boolean_property(
+  napi_env env,
+  napi_value object,
+  const char *name,
+  int value) {
+  napi_value js_value;
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_boolean(env, value ? true : false, &js_value),
+    "napi_get_boolean")) {
+    return 0;
+  }
+
+  if (!truehear_napi_check(
+    env,
+    napi_set_named_property(env, object, name, js_value),
+    "napi_set_named_property(boolean)")) {
+    return 0;
+  }
+
+  return 1;
+}
+
+/*
+ * Convert one C TruehearAudioDeviceInfo into one JS object:
+ *
+ *   {
+ *     default: boolean,
+ *     defaultCommunication: boolean,
+ *     type: 'playback' | 'recording',
+ *     name: string,
+ *     id: string
+ *   }
+ */
+static int truehear_create_js_device_object(
+  napi_env env,
+  const TruehearAudioDeviceInfo *device,
+  napi_value *out_object) {
+  if (device == NULL || out_object == NULL) {
+    truehear_throw_error(env, "Invalid device object pointer");
+    return 0;
+  }
+
+  napi_value object;
+
+  if (!truehear_napi_check(
+    env,
+    napi_create_object(env, &object),
+    "napi_create_object")) {
+    return 0;
+  }
+
+  if (!truehear_set_boolean_property(
+    env,
+    object,
+    "default",
+    device->is_default)) {
+    return 0;
+  }
+
+  if (!truehear_set_boolean_property(
+    env,
+    object,
+    "defaultCommunication",
+    device->is_default_communication)) {
+    return 0;
+  }
+
+  if (!truehear_set_string_property(
+    env,
+    object,
+    "type",
+    truehear_device_type_to_string(device->type))) {
+    return 0;
+  }
+
+  if (!truehear_set_string_property(
+    env,
+    object,
+    "name",
+    device->name)) {
+    return 0;
+  }
+
+  if (!truehear_set_string_property(
+    env,
+    object,
+    "id",
+    device->id)) {
+    return 0;
+  }
+
+  *out_object = object;
+  return 1;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* JS function: listDevices(type)                                                                   */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * JavaScript:
+ *
+ *   listDevices('playback')
+ *   listDevices('recording')
+ */
+static napi_value truehear_js_list_devices(
+  napi_env env,
+  napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_cb_info(env, info, &argc, argv, NULL, NULL),
+    "napi_get_cb_info")) {
+    return NULL;
+  }
+
+  if (argc < 1) {
+    truehear_throw_type_error(env, "listDevices(type) requires 1 argument");
+    return NULL;
+  }
+
+  TruehearAudioDeviceType type;
+
+  if (!truehear_parse_device_type(env, argv[0], &type)) {
+    return NULL;
+  }
+
+  TruehearAudioDeviceInfoList list;
+
+  int result = truehear_audio_list_devices(type, &list);
+
+  if (result != 0) {
+    truehear_throw_error(env, truehear_audio_get_last_error());
+    return NULL;
+  }
+
+  napi_value js_array;
+
+  if (!truehear_napi_check(
+    env,
+    napi_create_array_with_length(env, (size_t)list.count, &js_array),
+    "napi_create_array_with_length")) {
+    truehear_audio_free_device_list(&list);
+    return NULL;
+  }
+
+  for (int i = 0; i < list.count; i++) {
+    napi_value js_device;
+
+    if (!truehear_create_js_device_object(env, &list.items[i], &js_device)) {
+      truehear_audio_free_device_list(&list);
+      return NULL;
+    }
+
+    if (!truehear_napi_check(
+      env,
+      napi_set_element(env, js_array, (uint32_t)i, js_device),
+      "napi_set_element")) {
+      truehear_audio_free_device_list(&list);
+      return NULL;
+    }
+  }
+
+  truehear_audio_free_device_list(&list);
+
+  return js_array;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* JS function: setDefaultDevice(type, deviceId)                                                    */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * JavaScript:
+ *
+ *   setDefaultDevice('playback', deviceId)
+ *   setDefaultDevice('recording', deviceId)
+ */
+static napi_value truehear_js_set_default_device(
+  napi_env env,
+  napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_cb_info(env, info, &argc, argv, NULL, NULL),
+    "napi_get_cb_info")) {
+    return NULL;
+  }
+
+  if (argc < 2) {
+    truehear_throw_type_error(
+      env,
+      "setDefaultDevice(type, deviceId) requires 2 arguments");
+    return NULL;
+  }
+
+  TruehearAudioDeviceType type;
+
+  if (!truehear_parse_device_type(env, argv[0], &type)) {
+    return NULL;
+  }
+
+  char *device_id = truehear_get_utf8_string(env, argv[1], "deviceId");
+
+  if (device_id == NULL) {
+    return NULL;
+  }
+
+  if (device_id[0] == '\0') {
+    free(device_id);
+    truehear_throw_type_error(env, "deviceId must not be empty");
+    return NULL;
+  }
+
+  int result = truehear_audio_set_default_device(type, device_id);
+
+  free(device_id);
+
+  if (result != 0) {
+    truehear_throw_error(env, truehear_audio_get_last_error());
+    return NULL;
+  }
+
+  napi_value undefined_value;
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_undefined(env, &undefined_value),
+    "napi_get_undefined")) {
+    return NULL;
+  }
+
+  return undefined_value;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* JS function: setDefaultCommunicationDevice(type, deviceId)                                       */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * JavaScript:
+ *
+ *   setDefaultCommunicationDevice('playback', deviceId)
+ *   setDefaultCommunicationDevice('recording', deviceId)
+ */
+static napi_value truehear_js_set_default_communication_device(
+  napi_env env,
+  napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_cb_info(env, info, &argc, argv, NULL, NULL),
+    "napi_get_cb_info")) {
+    return NULL;
+  }
+
+  if (argc < 2) {
+    truehear_throw_type_error(
+      env,
+      "setDefaultCommunicationDevice(type, deviceId) requires 2 arguments");
+    return NULL;
+  }
+
+  TruehearAudioDeviceType type;
+
+  if (!truehear_parse_device_type(env, argv[0], &type)) {
+    return NULL;
+  }
+
+  char *device_id = truehear_get_utf8_string(env, argv[1], "deviceId");
+
+  if (device_id == NULL) {
+    return NULL;
+  }
+
+  if (device_id[0] == '\0') {
+    free(device_id);
+    truehear_throw_type_error(env, "deviceId must not be empty");
+    return NULL;
+  }
+
+  int result = truehear_audio_set_default_communication_device(type, device_id);
+
+  free(device_id);
+
+  if (result != 0) {
+    truehear_throw_error(env, truehear_audio_get_last_error());
+    return NULL;
+  }
+
+  napi_value undefined_value;
+
+  if (!truehear_napi_check(
+    env,
+    napi_get_undefined(env, &undefined_value),
+    "napi_get_undefined")) {
+    return NULL;
+  }
+
+  return undefined_value;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Module registration                                                                              */
+/* ---------------------------------------------------------------------------------------------- */
+
+static int truehear_export_function(
+  napi_env env,
+  napi_value exports,
+  const char *name,
+  napi_callback callback) {
+  napi_value function;
+
+  if (!truehear_napi_check(
+    env,
+    napi_create_function(
+      env,
+      name,
+      NAPI_AUTO_LENGTH,
+      callback,
+      NULL,
+      &function),
+    "napi_create_function")) {
+    return 0;
+  }
+
+  if (!truehear_napi_check(
+    env,
+    napi_set_named_property(env, exports, name, function),
+    "napi_set_named_property(function)")) {
+    return 0;
+  }
+
+  return 1;
+}
+
+static napi_value truehear_audio_init(
+  napi_env env,
+  napi_value exports) {
+  if (!truehear_export_function(
+    env,
+    exports,
+    "listDevices",
+    truehear_js_list_devices)) {
+    return NULL;
+  }
+
+  if (!truehear_export_function(
+    env,
+    exports,
+    "setDefaultDevice",
+    truehear_js_set_default_device)) {
+    return NULL;
+  }
+
+  if (!truehear_export_function(
+    env,
+    exports,
+    "setDefaultCommunicationDevice",
+    truehear_js_set_default_communication_device)) {
+    return NULL;
+  }
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, truehear_audio_init)

package/src/mmdevice_guids.c

@@ -0,0 +1,8 @@
+#include <windows.h>
+#include "mmdevice_guids.h"
+
+const CLSID CLSID_MMDeviceEnumerator =
+    {0xbcde0395, 0xe52f, 0x467c, {0x8e, 0x3d, 0xc4, 0x57, 0x92, 0x91, 0x69, 0x2e}};
+
+const IID IID_IMMDeviceEnumerator =
+    {0xa95664d2, 0x9614, 0x4f35, {0xa7, 0x46, 0xde, 0x8d, 0xb6, 0x36, 0x17, 0xe6}};

package/src/policy_config_guids.c

@@ -0,0 +1,26 @@
+#include <windows.h>
+#include "ipolicy_config.h"
+
+const IID IID_IPolicyConfig = {
+    0xf8679f50,
+    0x850a,
+    0x41cf,
+    {0x9c, 0x72, 0x43, 0x0f, 0x29, 0x02, 0x90, 0xc8}};
+
+const CLSID CLSID_CPolicyConfigClient = {
+    0x870af99c,
+    0x171d,
+    0x4f9e,
+    {0xaf, 0x0d, 0xe6, 0x3d, 0xf4, 0x0c, 0x2b, 0xc9}};
+
+const IID IID_IPolicyConfigVista = {
+    0x568b9108,
+    0x44bf,
+    0x40b4,
+    {0x90, 0x06, 0x86, 0xaf, 0xe5, 0xb5, 0xa6, 0x20}};
+
+const CLSID CLSID_CPolicyConfigVistaClient = {
+    0x294935ce,
+    0xf637,
+    0x4e7c,
+    {0xa4, 0x1b, 0xab, 0x25, 0x54, 0x60, 0xb8, 0x62}};