src/web/client.c

Go to the documentation of this file.

 
#include <emscripten.h>
#include <emscripten/html5.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
 
#include "common/init.h"
 
// JavaScript callback for sending complete ACIP packets from WASM to WebSocket
// This will be called by the WASM transport to send complete packets (header + payload)
// clang-format off
EM_JS(void, js_send_raw_packet, (const uint8_t *packet_data, size_t packet_len), {
  if (!Module.sendPacketCallback) {
    console.error('[WASM] sendPacketCallback not registered - cannot send packet');
    return;
  }
 
  // Copy complete packet from WASM memory to JavaScript
  const packetArray = new Uint8Array(HEAPU8.buffer, packet_data, packet_len);
  const packetCopy = new Uint8Array(packetArray);
 
  var pktType = packetCopy.length >= 10 ? ((packetCopy[8] << 8) | packetCopy[9]) : -1;
  console.error('[WASM->JS] Sending raw packet:', packetCopy.length, 'bytes, type=0x' + pktType.toString(16));
 
  // Send as raw binary packet via WebSocket
  Module.sendPacketCallback(packetCopy);
});
// clang-format on
 
#include <ascii-chat/options/options.h>
#include <ascii-chat/options/rcu.h>
#include <ascii-chat/platform/init.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/crypto/crypto.h>
#include <ascii-chat/crypto/handshake/client.h>
#include <ascii-chat/crypto/handshake/common.h>
#include <ascii-chat/network/packet/packet.h>
#include <ascii-chat/network/packet/parsing.h>
#include <ascii-chat/network/crc32.h>
#include <ascii-chat/network/compression.h>
#include <ascii-chat/network/acip/send.h>
#include <ascii-chat/network/acip/transport.h>
#include <ascii-chat/video/ascii/ascii.h>
#include <ascii-chat/video/terminal/ansi.h>
#include <ascii-chat/font.h>
 
/* Browser terminal rendering reads the embedded font directly from WASM memory. */
const unsigned char *get_font_default_ptr(void) {
  return g_font_default;
}
 
unsigned int get_font_default_size(void) {
  return (unsigned int)g_font_default_size;
}
#include <ascii-chat/common.h>
#include <ascii-chat/buffer_pool.h>
#include <ascii-chat/util/format.h>
#include <ascii-chat/util/magic.h>
#include <opus.h>
#include <sodium.h>
 
// ============================================================================
// WASM Transport Implementation
// ============================================================================
 
static asciichat_error_t wasm_transport_send(acip_transport_t *transport, const void *data, size_t len) {
 
  // Forward complete packet (header + payload) to JavaScript WebSocket bridge
  js_send_raw_packet((const uint8_t *)data, len);
 
  return ASCIICHAT_OK;
}
 
static asciichat_error_t wasm_transport_recv(acip_transport_t *transport, void **buffer, size_t *out_len,
                                             void **out_allocated_buffer) {
  // Not used - packets arrive via JavaScript callbacks
  return SET_ERRNO(ERROR_NOT_SUPPORTED, "recv not supported on WASM transport");
}
 
static asciichat_error_t wasm_transport_close(acip_transport_t *transport) {
  return ASCIICHAT_OK; // Nothing to close
}
 
static acip_transport_type_t wasm_transport_get_type(acip_transport_t *transport) {
  return ACIP_TRANSPORT_WEBSOCKET; // Closest match
}
 
static socket_t wasm_transport_get_socket(acip_transport_t *transport) {
  return INVALID_SOCKET_VALUE;
}
 
static bool wasm_transport_is_connected(acip_transport_t *transport) {
  return true; // Always "connected" from WASM perspective
}
 
static const acip_transport_methods_t wasm_transport_methods = {.send = wasm_transport_send,
                                                                .recv = wasm_transport_recv,
                                                                .close = wasm_transport_close,
                                                                .get_type = wasm_transport_get_type,
                                                                .get_socket = wasm_transport_get_socket,
                                                                .is_connected = wasm_transport_is_connected,
                                                                .destroy_impl = NULL};
 
static acip_transport_t g_wasm_transport = {.methods = &wasm_transport_methods, .crypto_ctx = NULL, .impl_data = NULL};
 
// ============================================================================
// Global State
// ============================================================================
 
// Global state for client session
static crypto_handshake_context_t g_crypto_handshake_ctx = {0};
static bool g_initialized = false;
static bool g_handshake_complete = false;
 
// Opus codec state
static OpusEncoder *g_opus_encoder = NULL;
static OpusDecoder *g_opus_decoder = NULL;
 
// Connection state enum (exposed to JS)
typedef enum {
  CONNECTION_STATE_DISCONNECTED = 0,
  CONNECTION_STATE_CONNECTING = 1,
  CONNECTION_STATE_HANDSHAKE = 2,
  CONNECTION_STATE_CONNECTED = 3,
  CONNECTION_STATE_ERROR = 4
} connection_state_t;
 
static connection_state_t g_connection_state = CONNECTION_STATE_DISCONNECTED;
 
// ============================================================================
// Initialization
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
int client_init_with_args(const char *args_json) {
 
  // Parse space-separated arguments
  char *args_copy = NULL;
  char *argv[64] = {NULL};
  int argc = wasm_parse_args(args_json, argv, 64, &args_copy);
  if (argc < 0) {
    return -1;
  }
 
  // Initialize options (sets up RCU, defaults, etc.)
  asciichat_error_t err = options_init(argc, argv);
  free(args_copy);
 
  if (g_initialized) {
    return -1;
  }
 
  // Initialize platform layer
  err = platform_init();
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Initialize logging to stderr (console.error in browser)
  log_init(NULL, LOG_DEBUG, true, false);
  // Use debug-style format in WASM so browser console shows full log headers
  log_set_format(OPT_LOG_TEMPLATE_DEFAULT_DEBUG, false);
  log_info("WASM client initialized via logging system");
 
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Initialize ANSI color code generation
  ansi_fast_init();
 
  g_initialized = true;
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
void client_cleanup(void) {
 
  // Clean up crypto handshake context
  crypto_handshake_destroy(&g_crypto_handshake_ctx);
  memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
 
  g_handshake_complete = false;
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  g_initialized = false;
  options_state_destroy();
  platform_destroy();
}
 
// ============================================================================
// Cryptography API
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
asciichat_error_t client_acds_join_request(const char *session, const char *password, uint8_t *output) {
  if (!session || !password || !output || strlen(session) == 0 || strlen(session) > 47 || strlen(password) > 127) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery session or password");
  }
  uint8_t public_key[crypto_sign_PUBLICKEYBYTES];
  uint8_t secret_key[crypto_sign_SECRETKEYBYTES];
  if (crypto_sign_keypair(public_key, secret_key) != 0) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to create discovery identity");
  }
  memset(output, 0, 282);
  size_t session_len = strlen(session);
  output[0] = (uint8_t)session_len;
  memcpy(output + 1, session, session_len);
  memcpy(output + 49, public_key, sizeof(public_key));
  uint64_t timestamp = (uint64_t)emscripten_date_now();
  // Packed ACDS structs use host (little-endian) fields; signatures use network order.
  memcpy(output + 145, &timestamp, sizeof(timestamp));
  uint8_t message[9 + 48];
  message[0] = (uint8_t)6004;
  for (size_t i = 0; i < 8; ++i)
    message[1 + i] = (uint8_t)(timestamp >> (56 - i * 8));
  memcpy(message + 9, session, session_len);
  int result = crypto_sign_detached(output + 81, NULL, message, 9 + session_len, secret_key);
  sodium_memzero(secret_key, sizeof(secret_key));
  if (result != 0)
    return SET_ERRNO(ERROR_CRYPTO, "Failed to sign discovery join");
  output[153] = password[0] != '\0';
  memcpy(output + 154, password, strlen(password));
  return ASCIICHAT_OK;
}
 
EMSCRIPTEN_KEEPALIVE
int client_generate_keypair(void) {
 
  if (!g_initialized) {
    return -1;
  }
 
  // Reset handshake context if previously used (reconnection / React Strict Mode remount)
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
    crypto_handshake_destroy(&g_crypto_handshake_ctx);
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    g_handshake_complete = false;
  }
 
  // Initialize crypto handshake context
  asciichat_error_t result = crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false /* is_server */);
  if (result != ASCIICHAT_OK) {
    return -1;
  }
 
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_set_server_address(const char *server_host, int server_port) {
  if (!g_initialized) {
    return -1;
  }
 
  if (!server_host || server_port <= 0 || server_port > 65535) {
    return -1;
  }
 
  // Set server IP and port in handshake context
  SAFE_STRNCPY(g_crypto_handshake_ctx.server_ip, server_host, sizeof(g_crypto_handshake_ctx.server_ip));
  g_crypto_handshake_ctx.server_port = server_port;
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
char *client_get_public_key_hex(void) {
  if (g_crypto_handshake_ctx.state == CRYPTO_HANDSHAKE_DISABLED) {
    return NULL;
  }
 
  // Get public key from handshake context
  const uint8_t *pubkey = g_crypto_handshake_ctx.crypto_ctx.public_key;
  if (!pubkey) {
    return NULL;
  }
 
  // Allocate buffer for hex string (32 bytes = 64 hex chars + null terminator)
  char *hex_buffer = SAFE_MALLOC(65, char *);
  if (!hex_buffer) {
    return NULL;
  }
 
  // Convert public key to hex
  for (int i = 0; i < 32; i++) {
    snprintf(hex_buffer + (i * 2), 3, "%02x", pubkey[i]);
  }
  hex_buffer[64] = '\0';
 
  return hex_buffer;
}
 
EMSCRIPTEN_KEEPALIVE
int client_handle_key_exchange_init(const uint8_t *packet, size_t packet_len) {
 
  // Safety check: if handshake context is not in INIT state, reinitialize it
  // This handles cases where previous handshakes weren't properly cleaned up
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_INIT) {
 
    // Destroy and reset
    if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
      crypto_handshake_destroy(&g_crypto_handshake_ctx);
    }
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
 
    // Reinitialize to INIT state
    asciichat_error_t init_result = crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false);
    if (init_result != ASCIICHAT_OK) {
      return -1;
    }
  }
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer pool (crypto function takes ownership and frees it)
  // The raw packet pointer from JS cannot be passed directly because the crypto
  // handshake function calls buffer_pool_free() on the payload when done.
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process key exchange using transport-abstracted handshake
 
  asciichat_error_t result = crypto_handshake_client_key_exchange(&g_crypto_handshake_ctx, &g_wasm_transport,
                                                                  packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_connection_state = CONNECTION_STATE_HANDSHAKE;
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_handle_crypto_parameters(const uint8_t *packet, size_t packet_len) {
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Discovery sends CRYPTO_PARAMETERS before KEY_EXCHANGE_INIT. Initialize
  // here so the negotiated values survive the subsequent key exchange packet.
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_INIT) {
    if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
      crypto_handshake_destroy(&g_crypto_handshake_ctx);
    }
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    if (crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false) != ASCIICHAT_OK) {
      return -1;
    }
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer pool
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process crypto parameters
  asciichat_error_t result =
      crypto_handshake_set_parameters(&g_crypto_handshake_ctx, (const crypto_parameters_packet_t *)payload);
 
  // Free payload
  if (payload) {
    buffer_pool_free(NULL, payload, payload_len);
  }
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_handle_auth_challenge(const uint8_t *packet, size_t packet_len) {
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer pool (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process auth challenge
  asciichat_error_t result = crypto_handshake_client_auth_response(&g_crypto_handshake_ctx, &g_wasm_transport,
                                                                   packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_handle_handshake_complete(const uint8_t *packet, size_t packet_len) {
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer pool (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Complete handshake (takes ownership of payload and will free it)
  asciichat_error_t result =
      crypto_handshake_client_complete(&g_crypto_handshake_ctx, &g_wasm_transport, packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_handshake_complete = true;
  g_connection_state = CONNECTION_STATE_CONNECTED;
 
  // Update transport with the crypto context so ACIP can encrypt/decrypt packets
  g_wasm_transport.crypto_ctx = &g_crypto_handshake_ctx.crypto_ctx;
 
  return 0;
}
 
// ============================================================================
// Packet Processing API
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
int client_encrypt_packet(const uint8_t *plaintext, size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size,
                          size_t *out_len) {
  if (!g_handshake_complete) {
    return -1;
  }
 
  // Encrypt the packet using handshake context's crypto context
  size_t ciphertext_len = 0;
  crypto_result_t result = crypto_encrypt(&g_crypto_handshake_ctx.crypto_ctx, plaintext, plaintext_len, ciphertext,
                                          ciphertext_size, &ciphertext_len);
  if (result != CRYPTO_OK) {
    return -1;
  }
 
  *out_len = ciphertext_len;
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_decrypt_packet(const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size,
                          size_t *out_len) {
  if (!g_handshake_complete) {
    return -1;
  }
 
  // Decrypt the packet using handshake context's crypto context
  size_t plaintext_len = 0;
  crypto_result_t result = crypto_decrypt(&g_crypto_handshake_ctx.crypto_ctx, ciphertext, ciphertext_len, plaintext,
                                          plaintext_size, &plaintext_len);
  if (result != CRYPTO_OK) {
    return -1;
  }
 
  *out_len = plaintext_len;
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
char *client_parse_packet(const uint8_t *raw_packet, size_t packet_len) {
  if (!raw_packet || packet_len < sizeof(packet_header_t)) {
    return NULL;
  }
 
  // Parse packet header directly from bytes
  const packet_header_t *header = (const packet_header_t *)raw_packet;
 
  // Validate magic number (convert from network byte order)
  uint64_t magic = NET_TO_HOST_U64(header->magic);
  if (magic != PACKET_MAGIC) {
    return NULL;
  }
 
  // Convert header fields from network byte order
  uint16_t type = NET_TO_HOST_U16(header->type);
  uint32_t length = NET_TO_HOST_U32(header->length);
  uint32_t client_id = NET_TO_HOST_U32(header->client_id);
  uint32_t crc32 = NET_TO_HOST_U32(header->crc32);
 
  if (length != packet_len - sizeof(packet_header_t) ||
      (length > 0 && asciichat_crc32_sw(raw_packet + sizeof(packet_header_t), length) != crc32)) {
    return NULL;
  }
 
  // Build JSON response with packet metadata
  char *json = SAFE_MALLOC(1024, char *);
  if (!json) {
    return NULL;
  }
 
  snprintf(json, 1024, "{\"type\":%u,\"length\":%u,\"client_id\":%u,\"crc32\":%u}", type, length, client_id, crc32);
 
  return json;
}
 
EMSCRIPTEN_KEEPALIVE
int client_serialize_packet(uint16_t packet_type, const uint8_t *payload, size_t payload_len, uint32_t client_id,
                            uint8_t *output, size_t *out_len) {
  if (!output || !out_len) {
    return -1;
  }
 
  // Calculate CRC32 of payload (use software version for WASM)
  uint32_t crc = payload && payload_len > 0 ? asciichat_crc32_sw(payload, payload_len) : 0;
 
  // Build packet header (convert to network byte order)
  packet_header_t header = {.magic = HOST_TO_NET_U64(PACKET_MAGIC),
                            .type = HOST_TO_NET_U16(packet_type),
                            .length = HOST_TO_NET_U32((uint32_t)payload_len),
                            .crc32 = HOST_TO_NET_U32(crc),
                            .client_id = HOST_TO_NET_U32(client_id)};
 
  // Copy header to output
  memcpy(output, &header, sizeof(packet_header_t));
 
  // Copy payload to output
  if (payload && payload_len > 0) {
    memcpy(output + sizeof(packet_header_t), payload, payload_len);
  }
 
  *out_len = sizeof(packet_header_t) + payload_len;
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_send_video_frame(const uint8_t *rgba_data, int width, int height) {
  if (!g_initialized) {
    return -1;
  }
 
  // This is a placeholder - actual implementation would:
  // 1. Convert RGBA to target format (e.g., compress with libjpeg-turbo)
  // 2. Build frame packet
  // 3. Encrypt if handshake complete
  // 4. Return serialized packet via callback to JS
 
  return 0;
}
 
// ============================================================================
// Connection State API
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
int client_get_connection_state(void) {
  return (int)g_connection_state;
}
 
// ============================================================================
// Memory Management
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
void client_free_string(char *ptr) {
  SAFE_FREE(ptr);
}
 
// ============================================================================
// Opus Audio Codec API
// ============================================================================
 
EMSCRIPTEN_KEEPALIVE
int client_opus_encoder_init(int sample_rate, int channels, int bitrate) {
  if (g_opus_encoder) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
  }
 
  int error;
  g_opus_encoder = opus_encoder_create(sample_rate, channels, OPUS_APPLICATION_VOIP, &error);
  if (error != OPUS_OK || !g_opus_encoder) {
    return -1;
  }
 
  // Set bitrate
  opus_encoder_ctl(g_opus_encoder, OPUS_SET_BITRATE(bitrate));
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_opus_decoder_init(int sample_rate, int channels) {
  if (g_opus_decoder) {
    opus_decoder_destroy(g_opus_decoder);
    g_opus_decoder = NULL;
  }
 
  int error;
  g_opus_decoder = opus_decoder_create(sample_rate, channels, &error);
  if (error != OPUS_OK || !g_opus_decoder) {
    return -1;
  }
 
  return 0;
}
 
EMSCRIPTEN_KEEPALIVE
int client_opus_encode(const int16_t *pcm_data, int frame_size, uint8_t *opus_data, int max_opus_bytes) {
  if (!g_opus_encoder) {
    return -1;
  }
 
  int encoded_bytes = opus_encode(g_opus_encoder, pcm_data, frame_size, opus_data, max_opus_bytes);
  if (encoded_bytes < 0) {
    return -1;
  }
 
  return encoded_bytes;
}
 
EMSCRIPTEN_KEEPALIVE
int client_opus_decode(const uint8_t *opus_data, int opus_bytes, int16_t *pcm_data, int frame_size, int decode_fec) {
  if (!g_opus_decoder) {
    return -1;
  }
 
  int decoded_samples = opus_decode(g_opus_decoder, opus_data, opus_bytes, pcm_data, frame_size, decode_fec);
  if (decoded_samples < 0) {
    return -1;
  }
 
  return decoded_samples;
}
 
EMSCRIPTEN_KEEPALIVE
void client_opus_encoder_cleanup(void) {
  if (g_opus_encoder) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
  }
}
 
EMSCRIPTEN_KEEPALIVE
void client_opus_decoder_cleanup(void) {
  if (g_opus_decoder) {
    opus_decoder_destroy(g_opus_decoder);
    g_opus_decoder = NULL;
  }
}