opus.c

Go to the documentation of this file.

 
#include <ascii-chat/otel.h>
#include <ascii-chat/audio/opus.h>
#include <ascii-chat/audio/limits.h>
#include <ascii-chat/common.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/debug/named.h>
#include <opus.h>
#include <stdlib.h>
#include <string.h>
 
/* ============================================================================
 * Encoder Creation
 * ============================================================================ */
 
asciichat_error_t audio_opus_configure_encoder(OpusEncoder *encoder, int bitrate) {
  if (!encoder || bitrate < 6000 || bitrate > 510000)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid Opus encoder or bitrate: %d", bitrate);
  int result = opus_encoder_ctl(encoder, OPUS_SET_BITRATE(bitrate));
  if (result == OPUS_OK)
    result = opus_encoder_ctl(encoder, OPUS_SET_VBR(1));
  // Ordered streams retain silence packets so playout timing remains continuous.
  if (result == OPUS_OK)
    result = opus_encoder_ctl(encoder, OPUS_SET_DTX(0));
  if (result != OPUS_OK)
    return SET_ERRNO(ERROR_AUDIO, "Opus configuration failed: %s", opus_strerror(result));
  return ASCIICHAT_OK;
}
 
opus_codec_t *opus_codec_create_encoder(opus_application_t application, int sample_rate, int bitrate) {
  return opus_codec_create_encoder_channels(application, sample_rate, bitrate, AUDIO_CHANNELS);
}
 
opus_codec_t *opus_codec_create_encoder_channels(opus_application_t application, int sample_rate, int bitrate,
                                                 int channels) {
  ASCII_OTEL_SCOPE(OPUS_ENCODER_CREATE);
  ASCII_OTEL_ATTR_INT("audio.sample_rate", sample_rate);
  ASCII_OTEL_ATTR_INT("audio.bitrate", bitrate);
  if (sample_rate <= 0 || bitrate <= 0 || (channels != 1 && channels != 2)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid codec parameters: sample_rate=%d, bitrate=%d", sample_rate, bitrate);
    return NULL;
  }
 
  opus_codec_t *codec = SAFE_MALLOC(sizeof(opus_codec_t), opus_codec_t *);
  if (!codec) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate opus codec context");
    return NULL;
  }
 
  // Create encoder
  int error = OPUS_OK;
  codec->encoder = opus_encoder_create(sample_rate, channels, (int)application, &error);
  if (error != OPUS_OK || !codec->encoder) {
    SET_ERRNO(ERROR_AUDIO, "Failed to create Opus encoder: %s", opus_strerror(error));
    SAFE_FREE(codec);
    return NULL;
  }
 
  if (audio_opus_configure_encoder(codec->encoder, bitrate) != ASCIICHAT_OK) {
    opus_encoder_destroy(codec->encoder);
    SAFE_FREE(codec);
    return NULL;
  }
 
  codec->decoder = NULL;
  codec->sample_rate = sample_rate;
  codec->channels = channels;
  codec->bitrate = bitrate;
  codec->tmp_buffer = NULL;
 
  log_debug("Opus encoder created: sample_rate=%d, bitrate=%d bps, continuous VBR", sample_rate, bitrate);
 
  // Register Opus encoder for debugging
  NAMED_REGISTER_CONTEXT(codec, "opus_encoder", "opus_codec", NULL);
 
  return codec;
}
 
/* ============================================================================
 * Decoder Creation
 * ============================================================================ */
 
opus_codec_t *opus_codec_create_decoder(int sample_rate) {
  return opus_codec_create_decoder_channels(sample_rate, AUDIO_CHANNELS);
}
 
opus_codec_t *opus_codec_create_decoder_channels(int sample_rate, int channels) {
  ASCII_OTEL_SCOPE(OPUS_DECODER_CREATE);
  ASCII_OTEL_ATTR_INT("audio.sample_rate", sample_rate);
  if (sample_rate <= 0 || (channels != 1 && channels != 2)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid sample rate: %d", sample_rate);
    return NULL;
  }
 
  opus_codec_t *codec = SAFE_MALLOC(sizeof(opus_codec_t), opus_codec_t *);
  if (!codec) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate opus codec context");
    return NULL;
  }
 
  // Create decoder
  int error = OPUS_OK;
  codec->decoder = opus_decoder_create(sample_rate, channels, &error);
  if (error != OPUS_OK || !codec->decoder) {
    SET_ERRNO(ERROR_AUDIO, "Failed to create Opus decoder: %s", opus_strerror(error));
    SAFE_FREE(codec);
    return NULL;
  }
 
  codec->encoder = NULL;
  codec->sample_rate = sample_rate;
  codec->channels = channels;
  codec->bitrate = 0; // N/A for decoder
  codec->tmp_buffer = NULL;
 
  log_debug("Opus decoder created: sample_rate=%d", sample_rate);
 
  // Register Opus decoder for debugging
  NAMED_REGISTER_CONTEXT(codec, "opus_decoder", "opus_codec", NULL);
 
  return codec;
}
 
/* ============================================================================
 * Encoding
 * ============================================================================ */
 
size_t opus_codec_encode(opus_codec_t *codec, const float *samples, int num_samples, uint8_t *out_data,
                         size_t out_size) {
  ASCII_OTEL_SCOPE(OPUS_CODEC_ENCODE);
  ASCII_OTEL_ATTR_STRING("audio.codec", "opus");
  ASCII_OTEL_ATTR_INT("audio.frame.samples", num_samples);
  ASCII_OTEL_ATTR_INT("audio.output.capacity", (int64_t)out_size);
  if (!codec || !codec->encoder || !samples || num_samples <= 0 || !out_data || out_size == 0 ||
      num_samples % codec->channels != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM,
              "Invalid encode parameters: codec=%p, encoder=%p, samples=%p, num_samples=%d, out_data=%p, "
              "out_size=%zu",
              (void *)codec, (void *)(codec ? codec->encoder : NULL), (const void *)samples, num_samples,
              (void *)out_data, out_size);
    return 0;
  }
 
  ASCII_OTEL_ATTR_INT("audio.sample_rate", codec->sample_rate);
  ASCII_OTEL_ATTR_INT("audio.bitrate", codec->bitrate);
  ASCII_OTEL_ATTR_INT("audio.channels", codec->channels);
  // Encode frame
  opus_int32 encoded_bytes =
      opus_encode_float(codec->encoder, samples, num_samples / codec->channels, out_data, (opus_int32)out_size);
 
  if (encoded_bytes < 0) {
    SET_ERRNO(ERROR_AUDIO, "Opus encoding failed: %s", opus_strerror((int)encoded_bytes));
    return 0;
  }
 
  if (encoded_bytes == 0) {
    // DTX frame (silence) - encoder produced zero bytes
    log_debug_every(LOG_RATE_VERY_FAST, "Opus DTX frame (silence detected)");
  }
 
  ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_BYTES, encoded_bytes);
  ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_ENCODE_SAMPLES, num_samples);
  ASCII_OTEL_ATTR_INT("audio.packet.size", encoded_bytes);
  return (size_t)encoded_bytes;
}
 
/* ============================================================================
 * Decoding
 * ============================================================================ */
 
int opus_codec_decode(opus_codec_t *codec, const uint8_t *data, size_t data_len, float *out_samples,
                      int out_num_samples) {
  ASCII_OTEL_SCOPE(OPUS_CODEC_DECODE);
  ASCII_OTEL_ATTR_STRING("audio.codec", "opus");
  ASCII_OTEL_ATTR_INT("audio.packet.size", (int64_t)data_len);
  ASCII_OTEL_ATTR_INT("audio.packet_loss_concealment", !data || !data_len);
  if (!codec || !codec->decoder || !out_samples || out_num_samples <= 0 || out_num_samples % codec->channels != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM,
              "Invalid decode parameters: codec=%p, decoder=%p, out_samples=%p, out_num_samples=%d", (void *)codec,
              (void *)(codec ? codec->decoder : NULL), (void *)out_samples, out_num_samples);
    return -1;
  }
 
  ASCII_OTEL_ATTR_INT("audio.sample_rate", codec->sample_rate);
  ASCII_OTEL_ATTR_INT("audio.channels", codec->channels);
  ASCII_OTEL_ATTR_INT("audio.output.capacity_samples", out_num_samples);
  // If data is NULL, use PLC (Packet Loss Concealment)
  if (!data || data_len == 0) {
    log_debug_every(LOG_RATE_VERY_FAST, "Opus PLC (Packet Loss Concealment)");
    int samples = opus_decode_float(codec->decoder, NULL, 0, out_samples, out_num_samples / codec->channels, 0);
    if (samples < 0) {
      SET_ERRNO(ERROR_AUDIO, "Opus PLC failed: %s", opus_strerror(samples));
      return -1;
    }
    ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_DECODE_SAMPLES, samples);
    ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_PLC_FRAMES, 1);
    ASCII_OTEL_ATTR_INT("audio.frame.samples", samples);
    return samples * codec->channels;
  }
 
  // Decode frame
  int samples =
      opus_decode_float(codec->decoder, data, (opus_int32)data_len, out_samples, out_num_samples / codec->channels, 0);
 
  if (samples < 0) {
    SET_ERRNO(ERROR_AUDIO, "Opus decoding failed: %s", opus_strerror(samples));
    return -1;
  }
 
  ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_DECODE_BYTES, (double)data_len);
  ASCII_OTEL_ATTR_INT("audio.frame.samples", samples);
  ascii_otel_metric(ASCII_OTEL_METRIC_OPUS_DECODE_SAMPLES, samples);
  return samples * codec->channels;
}
 
/* ============================================================================
 * Configuration
 * ============================================================================ */
 
asciichat_error_t opus_codec_set_bitrate(opus_codec_t *codec, int bitrate) {
  ASCII_OTEL_SCOPE(OPUS_CODEC_SET_BITRATE);
  if (!codec || !codec->encoder || bitrate <= 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid bitrate parameters: codec=%p, encoder=%p, bitrate=%d", (void *)codec,
                     (void *)(codec ? codec->encoder : NULL), bitrate);
  }
 
  int error = opus_encoder_ctl(codec->encoder, OPUS_SET_BITRATE(bitrate));
  if (error != OPUS_OK) {
    return SET_ERRNO(ERROR_AUDIO, "Failed to set Opus bitrate: %s", opus_strerror(error));
  }
 
  codec->bitrate = bitrate;
  log_debug("Opus bitrate changed to %d bps", bitrate);
 
  return ASCIICHAT_OK;
}
 
int opus_codec_get_bitrate(opus_codec_t *codec) {
  if (!codec || !codec->encoder) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid codec for bitrate query");
    return -1;
  }
 
  opus_int32 bitrate = 0;
  int error = opus_encoder_ctl(codec->encoder, OPUS_GET_BITRATE(&bitrate));
  if (error != OPUS_OK) {
    SET_ERRNO(ERROR_AUDIO, "Failed to get Opus bitrate: %s", opus_strerror(error));
    return -1;
  }
 
  return (int)bitrate;
}
 
asciichat_error_t opus_codec_set_dtx(opus_codec_t *codec, int enable) {
  ASCII_OTEL_SCOPE(OPUS_DTX);
  ASCII_OTEL_ATTR_INT("audio.dtx.enabled", enable != 0);
  if (!codec || !codec->encoder) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid codec for DTX configuration");
  }
 
  int error = opus_encoder_ctl(codec->encoder, OPUS_SET_DTX(enable ? 1 : 0));
  if (error != OPUS_OK) {
    return SET_ERRNO(ERROR_AUDIO, "Failed to set Opus DTX: %s", opus_strerror(error));
  }
 
  log_debug("Opus DTX %s", enable ? "enabled" : "disabled");
 
  return ASCIICHAT_OK;
}
 
/* ============================================================================
 * Lifecycle
 * ============================================================================ */
 
void opus_codec_destroy(opus_codec_t *codec) {
  if (!codec) {
    return;
  }
 
  NAMED_UNREGISTER(codec);
 
  if (codec->encoder) {
    opus_encoder_destroy(codec->encoder);
    codec->encoder = NULL;
  }
 
  if (codec->decoder) {
    opus_decoder_destroy(codec->decoder);
    codec->decoder = NULL;
  }
 
  if (codec->tmp_buffer) {
    SAFE_FREE(codec->tmp_buffer);
    codec->tmp_buffer = NULL;
  }
 
  SAFE_FREE(codec);
}