truehear-audio-library-node 1.0.0

package/src/truehear_audio_win.c

@@ -0,0 +1,888 @@
+#include "truehear_audio.h"
+
+#include "ipolicy_config.h"
+#include "mmdevice_guids.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <mmdeviceapi.h>
+#include <propsys.h>
+#include <propidl.h>
+#else
+#error "truehear_audio_win.c must only be built on Windows"
+#endif
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Windows property keys                                                                          */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * PKEY_Device_FriendlyName
+ *
+ * Windows normally exposes this from functiondiscoverykeys_devpkey.h,
+ * but defining it locally keeps this file simple and avoids extra header
+ * dependency surprises.
+ *
+ * This property gives names like:
+ *
+ *   "Speakers (Realtek(R) Audio)"
+ *   "Microphone Array (Intel Smart Sound Technology)"
+ */
+static const PROPERTYKEY TRUEHEAR_PKEY_Device_FriendlyName = {
+  {0xa45c254e, 0xdf1c, 0x4efd, {0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0}},
+  14 };
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Internal error state                                                                             */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Simple library-level last error buffer.
+ *
+ * For now this is enough.
+ * Later, if we need thread-safe errors, we can improve it.
+ */
+static char g_truehear_audio_last_error[512] = "No error";
+
+/*
+ * Store a plain error message.
+ */
+static void truehear_audio_set_error(const char* message) {
+  if (message == NULL) {
+    snprintf(
+      g_truehear_audio_last_error,
+      sizeof(g_truehear_audio_last_error),
+      "Unknown error");
+    return;
+  }
+
+  snprintf(
+    g_truehear_audio_last_error,
+    sizeof(g_truehear_audio_last_error),
+    "%s",
+    message);
+}
+
+/*
+ * Store an HRESULT error message.
+ *
+ * Windows COM functions usually return HRESULT.
+ */
+static void truehear_audio_set_hresult_error(
+  const char* operation,
+  HRESULT hr) {
+  snprintf(
+    g_truehear_audio_last_error,
+    sizeof(g_truehear_audio_last_error),
+    "%s failed with HRESULT 0x%08lx",
+    operation,
+    (unsigned long)hr);
+}
+
+/*
+ * Public error getter.
+ */
+const char* truehear_audio_get_last_error(void) {
+  return g_truehear_audio_last_error;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Small string helpers                                                                             */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * C standard strdup replacement.
+ *
+ * strdup is common, but not part of older ISO C standards everywhere.
+ */
+static char* truehear_audio_strdup(const char* value) {
+  if (value == NULL) {
+    return NULL;
+  }
+
+  size_t length = strlen(value);
+  char* copy = (char*)malloc(length + 1);
+
+  if (copy == NULL) {
+    return NULL;
+  }
+
+  memcpy(copy, value, length + 1);
+  return copy;
+}
+
+/*
+ * Convert a Windows wide string to UTF-8.
+ *
+ * Windows device IDs and friendly names usually come as wchar_t / LPWSTR.
+ * Our public C API uses UTF-8 char* because that maps cleanly to Node.js later.
+ */
+static char* truehear_audio_wide_to_utf8(const wchar_t* value) {
+  if (value == NULL) {
+    return NULL;
+  }
+
+  int required_size = WideCharToMultiByte(
+    CP_UTF8,
+    0,
+    value,
+    -1,
+    NULL,
+    0,
+    NULL,
+    NULL);
+
+  if (required_size <= 0) {
+    return NULL;
+  }
+
+  char* out = (char*)malloc((size_t)required_size);
+
+  if (out == NULL) {
+    return NULL;
+  }
+
+  int written = WideCharToMultiByte(
+    CP_UTF8,
+    0,
+    value,
+    -1,
+    out,
+    required_size,
+    NULL,
+    NULL);
+
+  if (written <= 0) {
+    free(out);
+    return NULL;
+  }
+
+  return out;
+}
+
+/*
+ * Convert UTF-8 char* to Windows wide string.
+ *
+ * IPolicyConfig::SetDefaultEndpoint expects PCWSTR, so device IDs from our
+ * public API must be converted back to wide strings.
+ */
+static wchar_t* truehear_audio_utf8_to_wide(const char* value) {
+  if (value == NULL) {
+    return NULL;
+  }
+
+  int required_size = MultiByteToWideChar(
+    CP_UTF8,
+    0,
+    value,
+    -1,
+    NULL,
+    0);
+
+  if (required_size <= 0) {
+    return NULL;
+  }
+
+  wchar_t* out = (wchar_t*)malloc(sizeof(wchar_t) * (size_t)required_size);
+
+  if (out == NULL) {
+    return NULL;
+  }
+
+  int written = MultiByteToWideChar(
+    CP_UTF8,
+    0,
+    value,
+    -1,
+    out,
+    required_size);
+
+  if (written <= 0) {
+    free(out);
+    return NULL;
+  }
+
+  return out;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Type mapping helpers                                                                             */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Map our public device type to Windows Core Audio flow.
+ *
+ * TRUEHEAR_AUDIO_DEVICE_TYPE_PLAYBACK  -> eRender
+ * TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING -> eCapture
+ */
+static EDataFlow truehear_audio_to_windows_data_flow(
+  TruehearAudioDeviceType type) {
+  if (type == TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING) {
+    return eCapture;
+  }
+
+  return eRender;
+}
+
+/*
+ * Validate the public audio device type.
+ */
+static int truehear_audio_is_valid_device_type(
+  TruehearAudioDeviceType type) {
+  return type == TRUEHEAR_AUDIO_DEVICE_TYPE_PLAYBACK ||
+    type == TRUEHEAR_AUDIO_DEVICE_TYPE_RECORDING;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* COM lifecycle helpers                                                                            */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Initialize COM for this thread.
+ *
+ * Windows Core Audio APIs are COM-based.
+ * Before using IMMDeviceEnumerator or IPolicyConfig, COM must be initialized.
+ *
+ * should_uninitialize:
+ *   1 = this function initialized COM, so we should call CoUninitialize later
+ *   0 = COM was already initialized in a compatible/usable way
+ */
+static int truehear_audio_com_initialize(int* should_uninitialize) {
+  if (should_uninitialize == NULL) {
+    truehear_audio_set_error("should_uninitialize pointer is NULL");
+    return -1;
+  }
+
+  *should_uninitialize = 0;
+
+  HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+
+  if (SUCCEEDED(hr)) {
+    /*
+     * This includes S_OK and S_FALSE.
+     *
+     * S_FALSE means COM was already initialized on this thread with the same
+     * apartment model. A successful CoInitializeEx call should still be matched
+     * with CoUninitialize.
+     */
+    *should_uninitialize = 1;
+    return 0;
+  }
+
+  /*
+   * RPC_E_CHANGED_MODE means COM was already initialized on this thread
+   * using another apartment model.
+   *
+   * This can happen if the host app already called CoInitializeEx.
+   *
+   * For this implementation, we accept this and try to continue using the
+   * existing COM context.
+   */
+  if (hr == RPC_E_CHANGED_MODE) {
+    *should_uninitialize = 0;
+    return 0;
+  }
+
+  truehear_audio_set_hresult_error("CoInitializeEx", hr);
+  return -1;
+}
+
+/*
+ * Uninitialize COM only when this library initialized it.
+ */
+static void truehear_audio_com_uninitialize(int should_uninitialize) {
+  if (should_uninitialize) {
+    CoUninitialize();
+  }
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Device list cleanup helpers                                                                      */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Free only the contents of one device item.
+ */
+static void truehear_audio_free_device_item(
+  TruehearAudioDeviceInfo* item) {
+  if (item == NULL) {
+    return;
+  }
+
+  free(item->name);
+  free(item->id);
+
+  item->name = NULL;
+  item->id = NULL;
+}
+
+/*
+ * Free a partial device list inside this file.
+ *
+ * Useful when truehear_audio_list_devices fails halfway.
+ */
+static void truehear_audio_free_partial_device_list(
+  TruehearAudioDeviceInfoList* list) {
+  if (list == NULL || list->items == NULL) {
+    return;
+  }
+
+  for (int i = 0; i < list->count; i++) {
+    truehear_audio_free_device_item(&list->items[i]);
+  }
+
+  free(list->items);
+
+  list->items = NULL;
+  list->count = 0;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Windows Core Audio helpers                                                                       */
+/* ---------------------------------------------------------------------------------------------- */
+
+/*
+ * Create the Windows MMDevice enumerator.
+ *
+ * This is the entry point for listing and querying Windows audio devices.
+ */
+static int truehear_audio_create_device_enumerator(
+  IMMDeviceEnumerator** out_enumerator) {
+  if (out_enumerator == NULL) {
+    truehear_audio_set_error("out_enumerator pointer is NULL");
+    return -1;
+  }
+
+  *out_enumerator = NULL;
+
+  HRESULT hr = CoCreateInstance(
+    &CLSID_MMDeviceEnumerator,
+    NULL,
+    CLSCTX_ALL,
+    &IID_IMMDeviceEnumerator,
+    (void**)out_enumerator);
+
+  if (FAILED(hr)) {
+    truehear_audio_set_hresult_error(
+      "CoCreateInstance(CLSID_MMDeviceEnumerator)",
+      hr);
+    return -1;
+  }
+
+  return 0;
+}
+
+/*
+ * Get the endpoint ID for a default device role.
+ *
+ * The returned LPWSTR is allocated by COM.
+ * Caller must free it with CoTaskMemFree().
+ */
+static LPWSTR truehear_audio_get_default_endpoint_id(
+  IMMDeviceEnumerator* enumerator,
+  EDataFlow flow,
+  ERole role) {
+  if (enumerator == NULL) {
+    return NULL;
+  }
+
+  IMMDevice* device = NULL;
+  LPWSTR device_id = NULL;
+
+  HRESULT hr = enumerator->lpVtbl->GetDefaultAudioEndpoint(
+    enumerator,
+    flow,
+    role,
+    &device);
+
+  if (FAILED(hr) || device == NULL) {
+    return NULL;
+  }
+
+  hr = device->lpVtbl->GetId(
+    device,
+    &device_id);
+
+  device->lpVtbl->Release(device);
+
+  if (FAILED(hr)) {
+    return NULL;
+  }
+
+  return device_id;
+}
+
+/*
+ * Read the friendly name from an IMMDevice.
+ *
+ * Returns a newly allocated UTF-8 string.
+ * Caller owns the returned string and must free it.
+ */
+static char* truehear_audio_get_device_friendly_name(
+  IMMDevice* device) {
+  if (device == NULL) {
+    return NULL;
+  }
+
+  IPropertyStore* property_store = NULL;
+  PROPVARIANT property_value;
+  char* name = NULL;
+
+  PropVariantInit(&property_value);
+
+  HRESULT hr = device->lpVtbl->OpenPropertyStore(
+    device,
+    STGM_READ,
+    &property_store);
+
+  if (FAILED(hr) || property_store == NULL) {
+    return NULL;
+  }
+
+  hr = property_store->lpVtbl->GetValue(
+    property_store,
+    &TRUEHEAR_PKEY_Device_FriendlyName,
+    &property_value);
+
+  if (SUCCEEDED(hr) && property_value.vt == VT_LPWSTR) {
+    name = truehear_audio_wide_to_utf8(property_value.pwszVal);
+  }
+
+  PropVariantClear(&property_value);
+  property_store->lpVtbl->Release(property_store);
+
+  return name;
+}
+
+/*
+ * Create an IPolicyConfig object.
+ *
+ * This is the undocumented COM object used to change the default endpoint.
+ */
+static int truehear_audio_create_policy_config(
+  IPolicyConfig** out_policy_config) {
+  if (out_policy_config == NULL) {
+    truehear_audio_set_error("out_policy_config pointer is NULL");
+    return -1;
+  }
+
+  *out_policy_config = NULL;
+
+  HRESULT hr = CoCreateInstance(
+    &CLSID_CPolicyConfigClient,
+    NULL,
+    CLSCTX_ALL,
+    &IID_IPolicyConfig,
+    (void**)out_policy_config);
+
+  if (FAILED(hr)) {
+    truehear_audio_set_hresult_error(
+      "CoCreateInstance(CLSID_CPolicyConfigClient)",
+      hr);
+    return -1;
+  }
+
+  return 0;
+}
+
+/*
+ * Set a default endpoint for one Windows audio role.
+ *
+ * Windows roles:
+ *
+ *   eConsole
+ *   eMultimedia
+ *   eCommunications
+ */
+static int truehear_audio_set_default_endpoint_for_role(
+  const char* device_id,
+  ERole role) {
+  if (device_id == NULL || device_id[0] == '\0') {
+    truehear_audio_set_error("device_id is empty");
+    return -1;
+  }
+
+  wchar_t* wide_device_id = truehear_audio_utf8_to_wide(device_id);
+
+  if (wide_device_id == NULL) {
+    truehear_audio_set_error("Failed to convert device_id from UTF-8 to wide string");
+    return -1;
+  }
+
+  IPolicyConfig* policy_config = NULL;
+
+  if (truehear_audio_create_policy_config(&policy_config) != 0) {
+    free(wide_device_id);
+    return -1;
+  }
+
+  HRESULT hr = policy_config->lpVtbl->SetDefaultEndpoint(
+    policy_config,
+    wide_device_id,
+    role);
+
+  policy_config->lpVtbl->Release(policy_config);
+  free(wide_device_id);
+
+  if (FAILED(hr)) {
+    truehear_audio_set_hresult_error(
+      "IPolicyConfig::SetDefaultEndpoint",
+      hr);
+    return -1;
+  }
+
+  return 0;
+}
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Public API implementation                                                                        */
+/* ---------------------------------------------------------------------------------------------- */
+
+int truehear_audio_list_devices(
+  TruehearAudioDeviceType type,
+  TruehearAudioDeviceInfoList* out_list) {
+  if (out_list == NULL) {
+    truehear_audio_set_error("out_list pointer is NULL");
+    return -1;
+  }
+
+  /*
+   * Always reset output first.
+   *
+   * This makes cleanup safe even if the function fails halfway later.
+   */
+  out_list->items = NULL;
+  out_list->count = 0;
+
+  if (!truehear_audio_is_valid_device_type(type)) {
+    truehear_audio_set_error("Invalid audio device type");
+    return -1;
+  }
+
+  int should_uninitialize = 0;
+
+  if (truehear_audio_com_initialize(&should_uninitialize) != 0) {
+    return -1;
+  }
+
+  IMMDeviceEnumerator* enumerator = NULL;
+  IMMDeviceCollection* collection = NULL;
+
+  if (truehear_audio_create_device_enumerator(&enumerator) != 0) {
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  EDataFlow flow = truehear_audio_to_windows_data_flow(type);
+
+  HRESULT hr = enumerator->lpVtbl->EnumAudioEndpoints(
+    enumerator,
+    flow,
+    DEVICE_STATE_ACTIVE,
+    &collection);
+
+  if (FAILED(hr)) {
+    truehear_audio_set_hresult_error(
+      "IMMDeviceEnumerator::EnumAudioEndpoints",
+      hr);
+
+    enumerator->lpVtbl->Release(enumerator);
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  UINT raw_count = 0;
+
+  hr = collection->lpVtbl->GetCount(
+    collection,
+    &raw_count);
+
+  if (FAILED(hr)) {
+    truehear_audio_set_hresult_error(
+      "IMMDeviceCollection::GetCount",
+      hr);
+
+    collection->lpVtbl->Release(collection);
+    enumerator->lpVtbl->Release(enumerator);
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  /*
+   * Allocate enough space for all devices.
+   *
+   * Some entries may be skipped if Windows gives an unusable item, so the
+   * final out_list->count may be smaller than raw_count.
+   */
+  TruehearAudioDeviceInfo* items = NULL;
+
+  if (raw_count > 0) {
+    items = (TruehearAudioDeviceInfo*)calloc(
+      (size_t)raw_count,
+      sizeof(TruehearAudioDeviceInfo));
+
+    if (items == NULL) {
+      truehear_audio_set_error("Failed to allocate audio device list");
+
+      collection->lpVtbl->Release(collection);
+      enumerator->lpVtbl->Release(enumerator);
+      truehear_audio_com_uninitialize(should_uninitialize);
+      return -1;
+    }
+  }
+
+  /*
+   * Get default endpoint IDs for comparison.
+   *
+   * is_default:
+   *   true if the device matches either eConsole or eMultimedia.
+   *
+   * is_default_communication:
+   *   true if the device matches eCommunications.
+   */
+  LPWSTR default_console_id = truehear_audio_get_default_endpoint_id(
+    enumerator,
+    flow,
+    eConsole);
+
+  LPWSTR default_multimedia_id = truehear_audio_get_default_endpoint_id(
+    enumerator,
+    flow,
+    eMultimedia);
+
+  LPWSTR default_communication_id = truehear_audio_get_default_endpoint_id(
+    enumerator,
+    flow,
+    eCommunications);
+
+  int actual_count = 0;
+
+  for (UINT i = 0; i < raw_count; i++) {
+    IMMDevice* device = NULL;
+
+    hr = collection->lpVtbl->Item(
+      collection,
+      i,
+      &device);
+
+    if (FAILED(hr) || device == NULL) {
+      continue;
+    }
+
+    LPWSTR wide_device_id = NULL;
+
+    hr = device->lpVtbl->GetId(
+      device,
+      &wide_device_id);
+
+    if (FAILED(hr) || wide_device_id == NULL) {
+      device->lpVtbl->Release(device);
+      continue;
+    }
+
+    char* id = truehear_audio_wide_to_utf8(wide_device_id);
+    char* name = truehear_audio_get_device_friendly_name(device);
+
+    if (name == NULL) {
+      /*
+       * Fallback: if Windows does not return a friendly name, use the id.
+       */
+      name = truehear_audio_strdup(id != NULL ? id : "(unknown audio device)");
+    }
+
+    if (id == NULL || name == NULL) {
+      free(id);
+      free(name);
+      CoTaskMemFree(wide_device_id);
+      device->lpVtbl->Release(device);
+
+      TruehearAudioDeviceInfoList partial_list;
+      partial_list.items = items;
+      partial_list.count = actual_count;
+
+      truehear_audio_free_partial_device_list(&partial_list);
+
+      if (default_console_id != NULL) {
+        CoTaskMemFree(default_console_id);
+      }
+
+      if (default_multimedia_id != NULL) {
+        CoTaskMemFree(default_multimedia_id);
+      }
+
+      if (default_communication_id != NULL) {
+        CoTaskMemFree(default_communication_id);
+      }
+
+      collection->lpVtbl->Release(collection);
+      enumerator->lpVtbl->Release(enumerator);
+      truehear_audio_com_uninitialize(should_uninitialize);
+
+      truehear_audio_set_error("Failed to allocate audio device strings");
+      return -1;
+    }
+
+    /**
+     * We avoid doing this
+     * items[actual_count].type = type;
+     * items[actual_count].id = id;
+     * items[actual_count].name = name;
+     * items[actual_count].is_default = 0;
+     * items[actual_count].is_default_communication = 0;
+     */
+    TruehearAudioDeviceInfo* item = &items[actual_count];
+
+    item->type = type;
+    item->id = id;
+    item->name = name;
+
+    item->is_default = 0;
+    item->is_default_communication = 0;
+
+    if (default_console_id != NULL &&
+      wcscmp(wide_device_id, default_console_id) == 0) {
+      item->is_default = 1;
+    }
+
+    if (default_multimedia_id != NULL &&
+      wcscmp(wide_device_id, default_multimedia_id) == 0) {
+      item->is_default = 1;
+    }
+
+    if (default_communication_id != NULL &&
+      wcscmp(wide_device_id, default_communication_id) == 0) {
+      item->is_default_communication = 1;
+    }
+
+    actual_count++;
+
+    CoTaskMemFree(wide_device_id);
+    device->lpVtbl->Release(device);
+  }
+
+  if (default_console_id != NULL) {
+    CoTaskMemFree(default_console_id);
+  }
+
+  if (default_multimedia_id != NULL) {
+    CoTaskMemFree(default_multimedia_id);
+  }
+
+  if (default_communication_id != NULL) {
+    CoTaskMemFree(default_communication_id);
+  }
+
+  collection->lpVtbl->Release(collection);
+  enumerator->lpVtbl->Release(enumerator);
+  truehear_audio_com_uninitialize(should_uninitialize);
+
+  out_list->items = items;
+  out_list->count = actual_count;
+
+  truehear_audio_set_error("No error");
+  return 0;
+}
+
+int truehear_audio_set_default_device(
+  TruehearAudioDeviceType type,
+  const char* device_id) {
+  if (!truehear_audio_is_valid_device_type(type)) {
+    truehear_audio_set_error("Invalid audio device type");
+    return -1;
+  }
+
+  if (device_id == NULL || device_id[0] == '\0') {
+    truehear_audio_set_error("device_id is empty");
+    return -1;
+  }
+
+  int should_uninitialize = 0;
+
+  if (truehear_audio_com_initialize(&should_uninitialize) != 0) {
+    return -1;
+  }
+
+  /*
+   * Normal default device:
+   *
+   * eConsole:
+   *   system/default role
+   *
+   * eMultimedia:
+   *   media playback role
+   *
+   * We intentionally do not set eCommunications here.
+   * That is handled by truehear_audio_set_default_communication_device().
+   */
+  if (truehear_audio_set_default_endpoint_for_role(device_id, eConsole) != 0) {
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  if (truehear_audio_set_default_endpoint_for_role(device_id, eMultimedia) != 0) {
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  truehear_audio_com_uninitialize(should_uninitialize);
+
+  truehear_audio_set_error("No error");
+  return 0;
+}
+
+int truehear_audio_set_default_communication_device(
+  TruehearAudioDeviceType type,
+  const char* device_id) {
+  if (!truehear_audio_is_valid_device_type(type)) {
+    truehear_audio_set_error("Invalid audio device type");
+    return -1;
+  }
+
+  if (device_id == NULL || device_id[0] == '\0') {
+    truehear_audio_set_error("device_id is empty");
+    return -1;
+  }
+
+  int should_uninitialize = 0;
+
+  if (truehear_audio_com_initialize(&should_uninitialize) != 0) {
+    return -1;
+  }
+
+  /*
+   * Communication default device:
+   *
+   * eCommunications:
+   *   calls / Teams / Zoom / communication apps
+   */
+  if (truehear_audio_set_default_endpoint_for_role(device_id, eCommunications) != 0) {
+    truehear_audio_com_uninitialize(should_uninitialize);
+    return -1;
+  }
+
+  truehear_audio_com_uninitialize(should_uninitialize);
+
+  truehear_audio_set_error("No error");
+  return 0;
+}
+
+void truehear_audio_free_device_list(
+  TruehearAudioDeviceInfoList* list) {
+  if (list == NULL || list->items == NULL) {
+    return;
+  }
+
+  for (int i = 0; i < list->count; i++) {
+    truehear_audio_free_device_item(&list->items[i]);
+  }
+
+  free(list->items);
+
+  list->items = NULL;
+  list->count = 0;
+}