sdp.h File Reference

SDP (Session Description Protocol) for WebRTC audio/video negotiation. More...

Go to the source code of this file.

Data Structures
struct	opus_config_t
	Opus codec parameters for ascii-chat. More...
struct	terminal_format_params_t
	Terminal rendering format parameters. More...
struct	terminal_capability_t
	Supported terminal capability (for offer/answer) More...
struct	sdp_session_t
	SDP media session (simplified for WebRTC) More...

Enumerations
enum	acip_codec_t { ACIP_CODEC_TRUECOLOR = 96 , ACIP_CODEC_256COLOR = 97 , ACIP_CODEC_16COLOR = 98 , ACIP_CODEC_MONO = 99 }
	Terminal rendering capability payload types. More...

Functions
asciichat_error_t	sdp_generate_offer (const terminal_capability_t *capabilities, size_t capability_count, const opus_config_t *audio_config, const terminal_format_params_t *format, sdp_session_t *offer_out)
	Generate SDP offer (client side)
asciichat_error_t	sdp_generate_answer (const sdp_session_t *offer, const terminal_capability_t *server_capabilities, size_t server_capability_count, const opus_config_t *audio_config, const terminal_format_params_t *server_format, sdp_session_t *answer_out)
	Generate SDP answer (server side)
asciichat_error_t	sdp_parse (const char *sdp_string, sdp_session_t *session)
	Parse SDP offer or answer.
asciichat_error_t	sdp_get_selected_video_codec (const sdp_session_t *answer, acip_codec_t *selected_codec, terminal_format_params_t *selected_format)
	Extract selected video codec from SDP answer.
asciichat_error_t	sdp_detect_terminal_capabilities (terminal_capability_t *capabilities, size_t capability_count, size_t *detected_count)
	Detect client terminal capabilities at startup.
void	sdp_session_free (sdp_session_t *session)
	Free SDP session resources.
const char *	sdp_codec_name (acip_codec_t codec)
	Get human-readable codec name.
const char *	sdp_renderer_name (int renderer_type)
	Get human-readable renderer name.

Detailed Description

SDP (Session Description Protocol) for WebRTC audio/video negotiation.

Handles SDP offer/answer generation and parsing for WebRTC connections. Includes:

• Opus audio codec negotiation (48kHz, mono, 24kbps)
• Terminal capability negotiation via custom ACIP video "codecs"
• Format parameters for resolution, renderer, charset, compression

SDP Offer/Answer Flow

Client (Joiner) generates OFFER:

• Lists supported audio codecs (Opus)
• Lists supported terminal rendering modes in preference order
• Server selects best mutually-supported mode

Server (Creator) generates ANSWER:

• Selects single audio codec (Opus)
• Selects best terminal rendering mode
• Server enforces its rendering constraints

Terminal Capability "Codecs"

These are RTP payload types that represent terminal rendering modes:

• PT 96: ACIP-TC (Truecolor, 24-bit RGB)
• PT 97: ACIP-256 (256-color xterm)
• PT 98: ACIP-16 (16-color ANSI)
• PT 99: ACIP-MONO (Monochrome, ASCII only)

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

January 2026

Definition in file sdp.h.

Enumeration Type Documentation

acip_codec_t

enum acip_codec_t

Terminal rendering capability payload types.

These are custom "codecs" that represent terminal rendering modes. Used in SDP to negotiate which color mode both peers can support.

Enumerator
ACIP_CODEC_TRUECOLOR	24-bit RGB (truecolor)
ACIP_CODEC_256COLOR	256-color (xterm palette)
ACIP_CODEC_16COLOR	16-color (ANSI standard)
ACIP_CODEC_MONO	Monochrome (ASCII only)

Definition at line 76 of file sdp.h.

             {
  ACIP_CODEC_TRUECOLOR = 96, 
  ACIP_CODEC_256COLOR = 97,  
  ACIP_CODEC_16COLOR = 98,   
  ACIP_CODEC_MONO = 99,      
} acip_codec_t;

Function Documentation

sdp_codec_name()

const char * sdp_codec_name

(

acip_codec_t

codec

)

Get human-readable codec name.

Parameters

codec

Codec type

Returns

Static string (e.g., "ACIP-TC", "ACIP-256")

Definition at line 21 of file sdp.c.

                                               {
  switch (codec) {
  case ACIP_CODEC_TRUECOLOR:
    return "ACIP-TC";
  case ACIP_CODEC_256COLOR:
    return "ACIP-256";
  case ACIP_CODEC_16COLOR:
    return "ACIP-16";
  case ACIP_CODEC_MONO:
    return "ACIP-MONO";
  default:
    return "UNKNOWN";
  }
}

References ACIP_CODEC_16COLOR, ACIP_CODEC_256COLOR, ACIP_CODEC_MONO, and ACIP_CODEC_TRUECOLOR.

Referenced by sdp_generate_answer(), sdp_generate_offer(), and sdp_get_selected_video_codec().

sdp_detect_terminal_capabilities()

asciichat_error_t sdp_detect_terminal_capabilities	(	terminal_capability_t *	capabilities,
		size_t	capability_count,
		size_t *	detected_count
	)

Detect client terminal capabilities at startup.

Auto-detects from environment and terminal:

1. COLORTERM env var (truecolor/24bit)
2. Terminal color query (terminfo/XTGETTCAP)
3. UTF-8 support (LANG, test character)
4. CSI REP support (escape sequence test)
5. Terminal size (TIOCGWINSZ)

Parameters

capabilities	Detected capabilities (output)
capability_count	Maximum capabilities to detect
detected_count	Actual number detected (output)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 561 of file sdp.c.

                                                                           {
  if (!capabilities || capability_count == 0 || !detected_count) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid capability detection parameters");
  }
 
  *detected_count = 0;
  memset(capabilities, 0, capability_count * sizeof(terminal_capability_t));
 
  // Detect terminal color level using platform terminal module
  const char *colorterm = SAFE_GETENV("COLORTERM");
  const char *term = SAFE_GETENV("TERM");
  terminal_color_mode_t color_level = TERM_COLOR_NONE;
 
  if (colorterm && (strcmp(colorterm, "truecolor") == 0 || strcmp(colorterm, "24bit") == 0)) {
    color_level = TERM_COLOR_TRUECOLOR;
  } else if (term) {
    if (strstr(term, "256color") || strstr(term, "256")) {
      color_level = TERM_COLOR_256;
    } else if (strstr(term, "color") || strcmp(term, "xterm") == 0) {
      color_level = TERM_COLOR_16;
    }
  }
 
  // Detect UTF-8 support from LANG environment variable
  const char *lang = SAFE_GETENV("LANG");
  bool has_utf8 = (lang && (strstr(lang, "UTF-8") || strstr(lang, "utf8")));
 
  // CSI REP support correlates with UTF-8
  bool has_csi_rep = has_utf8;
 
  // Get terminal size from platform module
  uint16_t term_width = 80;  // default
  uint16_t term_height = 24; // default
 
  terminal_size_t term_size;
  asciichat_error_t term_err = terminal_get_size(&term_size);
  if (term_err == ASCIICHAT_OK) {
    term_width = (uint16_t)term_size.cols;
    term_height = (uint16_t)term_size.rows;
  } else {
    log_debug("SDP: Using default terminal size %ux%u", term_width, term_height);
  }
 
  // Fill capabilities array based on detected color level (preference order)
  size_t idx = 0;
 
  if (color_level >= TERM_COLOR_TRUECOLOR && idx < capability_count) {
    capabilities[idx].codec = ACIP_CODEC_TRUECOLOR;
    capabilities[idx].format.width = term_width;
    capabilities[idx].format.height = term_height;
    capabilities[idx].format.renderer = RENDERER_BLOCK;
    capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
    capabilities[idx].format.compression = COMPRESSION_RLE;
    capabilities[idx].format.csi_rep_support = has_csi_rep;
    idx++;
  }
 
  if (color_level >= TERM_COLOR_256 && idx < capability_count) {
    capabilities[idx].codec = ACIP_CODEC_256COLOR;
    capabilities[idx].format.width = term_width;
    capabilities[idx].format.height = term_height;
    capabilities[idx].format.renderer = RENDERER_BLOCK;
    capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
    capabilities[idx].format.compression = COMPRESSION_RLE;
    capabilities[idx].format.csi_rep_support = has_csi_rep;
    idx++;
  }
 
  if (color_level >= TERM_COLOR_16 && idx < capability_count) {
    capabilities[idx].codec = ACIP_CODEC_16COLOR;
    capabilities[idx].format.width = term_width;
    capabilities[idx].format.height = term_height;
    capabilities[idx].format.renderer = RENDERER_BLOCK;
    capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
    capabilities[idx].format.compression = COMPRESSION_NONE;
    capabilities[idx].format.csi_rep_support = has_csi_rep;
    idx++;
  }
 
  // Monochrome always supported
  if (idx < capability_count) {
    capabilities[idx].codec = ACIP_CODEC_MONO;
    capabilities[idx].format.width = term_width;
    capabilities[idx].format.height = term_height;
    capabilities[idx].format.renderer = RENDERER_BLOCK;
    capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
    capabilities[idx].format.compression = COMPRESSION_NONE;
    capabilities[idx].format.csi_rep_support = has_csi_rep;
    idx++;
  }
 
  *detected_count = idx;
 
  log_debug("SDP: Detected %zu terminal capabilities (colors=%d, utf8=%s, csi_rep=%s, size=%ux%u)", *detected_count,
            color_level, has_utf8 ? "yes" : "no", has_csi_rep ? "yes" : "no", term_width, term_height);
 
  return ASCIICHAT_OK;
}

References ACIP_CODEC_16COLOR, ACIP_CODEC_256COLOR, ACIP_CODEC_MONO, ACIP_CODEC_TRUECOLOR, ASCIICHAT_OK, terminal_format_params_t::charset, terminal_capability_t::codec, terminal_size_t::cols, terminal_format_params_t::compression, terminal_format_params_t::csi_rep_support, ERROR_INVALID_PARAM, terminal_capability_t::format, terminal_format_params_t::height, log_debug, terminal_format_params_t::renderer, terminal_size_t::rows, SAFE_GETENV, SET_ERRNO, TERM_COLOR_16, TERM_COLOR_256, TERM_COLOR_NONE, TERM_COLOR_TRUECOLOR, terminal_get_size(), and terminal_format_params_t::width.

sdp_generate_answer()

asciichat_error_t sdp_generate_answer	(	const sdp_session_t *	offer,
		const terminal_capability_t *	server_capabilities,
		size_t	server_capability_count,
		const opus_config_t *	audio_config,
		const terminal_format_params_t *	server_format,
		sdp_session_t *	answer_out
	)

Generate SDP answer (server side)

Creates an SDP answer by selecting best mutually-supported mode from offer. Server enforces its rendering constraints.

Parameters

offer	Received SDP offer from client
server_capabilities	Array of server-supported capabilities
server_capability_count	Number of server capabilities
audio_config	Opus codec configuration
server_format	Server's rendering constraints
answer_out	Generated SDP answer (output)

Returns

ASCIICHAT_OK on success, error code on failure

Note

Caller must free answer_out using sdp_session_free()

Definition at line 168 of file sdp.c.

                                                                                                                {
  if (!offer || !server_capabilities || server_capability_count == 0 || !audio_config || !answer_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP answer parameters");
  }
 
  memset(answer_out, 0, sizeof(sdp_session_t));
 
  // Copy session ID from offer, increment version
  SAFE_STRNCPY(answer_out->session_id, offer->session_id, sizeof(answer_out->session_id));
 
  time_t now = time(NULL);
  snprintf(answer_out->session_version, sizeof(answer_out->session_version), "%ld", now);
 
  // Answer audio section: accept Opus
  answer_out->has_audio = offer->has_audio;
  if (answer_out->has_audio) {
    memcpy(&answer_out->audio_config, audio_config, sizeof(opus_config_t));
  }
 
  // Answer video section: find best mutually-supported codec
  answer_out->has_video = offer->has_video;
 
  if (answer_out->has_video && offer->video_codecs && offer->video_codec_count > 0) {
    // Find best codec: iterate through server preferences and find first match in offer
    int selected_index = -1;
 
    for (size_t s = 0; s < server_capability_count; s++) {
      for (size_t o = 0; o < offer->video_codec_count; o++) {
        if (server_capabilities[s].codec == offer->video_codecs[o].codec) {
          selected_index = (int)s;
          break; // Found match, use server's preference order
        }
      }
      if (selected_index >= 0) {
        break;
      }
    }
 
    // Allocate and fill selected codec
    answer_out->video_codecs = SAFE_MALLOC(sizeof(terminal_capability_t), terminal_capability_t *);
    answer_out->video_codec_count = 1;
 
    // Use server's capability with any server_format overrides
    if (selected_index >= 0) {
      memcpy(answer_out->video_codecs, &server_capabilities[selected_index], sizeof(terminal_capability_t));
    } else {
      // Fallback to monochrome
      memcpy(answer_out->video_codecs, &server_capabilities[0], sizeof(terminal_capability_t));
    }
 
    // Apply server format constraints if provided
    if (server_format) {
      if (server_format->width > 0) {
        answer_out->video_codecs[0].format.width = server_format->width;
      }
      if (server_format->height > 0) {
        answer_out->video_codecs[0].format.height = server_format->height;
      }
      if (server_format->renderer != RENDERER_BLOCK) {
        answer_out->video_codecs[0].format.renderer = server_format->renderer;
      }
      if (server_format->compression != COMPRESSION_NONE) {
        answer_out->video_codecs[0].format.compression = server_format->compression;
      }
    }
 
    memcpy(&answer_out->video_format, &answer_out->video_codecs[0].format, sizeof(terminal_format_params_t));
  }
 
  // Build complete SDP answer
  char *sdp = answer_out->sdp_string;
  size_t remaining = sizeof(answer_out->sdp_string);
  int written = 0;
 
  // Session-level attributes
  written = snprintf(sdp, remaining, "v=0\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "o=ascii-chat %s %s IN IP4 0.0.0.0\r\n", answer_out->session_id,
                     answer_out->session_version);
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "s=-\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "t=0 0\r\n");
  sdp += written;
  remaining -= written;
 
  // Audio media section (if present in offer)
  if (answer_out->has_audio) {
    written = snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
    sdp += written;
    remaining -= written;
 
    written = snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
    sdp += written;
    remaining -= written;
 
    written = snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
    sdp += written;
    remaining -= written;
  }
 
  // Video media section (if present in offer)
  if (answer_out->has_video && answer_out->video_codecs && answer_out->video_codec_count > 0) {
    written = snprintf(sdp, remaining, "m=video 9 UDP/TLS/RTP/SAVPF 96\r\n");
    sdp += written;
    remaining -= written;
 
    const char *codec_name = sdp_codec_name(answer_out->video_codecs[0].codec);
    written = snprintf(sdp, remaining, "a=rtpmap:96 %s/90000\r\n", codec_name);
    sdp += written;
    remaining -= written;
 
    // Format parameters
    const terminal_format_params_t *cap_format = &answer_out->video_codecs[0].format;
    const char *renderer_name = sdp_renderer_name(cap_format->renderer);
    const char *charset_name = (cap_format->charset == CHARSET_UTF8) ? "utf8" : "ascii";
    const char *compression_name = "none";
    if (cap_format->compression == COMPRESSION_RLE) {
      compression_name = "rle";
    } else if (cap_format->compression == COMPRESSION_ZSTD) {
      compression_name = "zstd";
    }
 
    written =
        snprintf(sdp, remaining, "a=fmtp:96 width=%u;height=%u;renderer=%s;charset=%s;compression=%s;csi_rep=%d\r\n",
                 cap_format->width, cap_format->height, renderer_name, charset_name, compression_name,
                 cap_format->csi_rep_support ? 1 : 0);
    sdp += written;
    remaining -= written;
  }
 
  answer_out->sdp_length = strlen(answer_out->sdp_string);
 
  log_debug("SDP: Generated answer with codec %s", sdp_codec_name(answer_out->video_codecs[0].codec));
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, sdp_session_t::audio_config, terminal_format_params_t::charset, terminal_capability_t::codec, terminal_format_params_t::compression, terminal_format_params_t::csi_rep_support, ERROR_INVALID_PARAM, terminal_capability_t::format, sdp_session_t::has_audio, sdp_session_t::has_video, terminal_format_params_t::height, log_debug, terminal_format_params_t::renderer, SAFE_MALLOC, SAFE_STRNCPY, sdp_codec_name(), sdp_session_t::sdp_length, sdp_renderer_name(), sdp_session_t::sdp_string, sdp_session_t::session_id, sdp_session_t::session_version, SET_ERRNO, sdp_session_t::video_codec_count, sdp_session_t::video_codecs, sdp_session_t::video_format, and terminal_format_params_t::width.

sdp_generate_offer()

asciichat_error_t sdp_generate_offer	(	const terminal_capability_t *	capabilities,
		size_t	capability_count,
		const opus_config_t *	audio_config,
		const terminal_format_params_t *	format,
		sdp_session_t *	offer_out
	)

Generate SDP offer (client side)

Creates an SDP offer with:

• Opus audio codec
• Terminal capabilities in client preference order

Parameters

capabilities	Array of supported terminal capabilities
capability_count	Number of capabilities
audio_config	Opus codec configuration
format	Format parameters for video section
offer_out	Generated SDP offer (output)

Returns

ASCIICHAT_OK on success, error code on failure

Note

Caller must free offer_out using sdp_session_free()

Definition at line 53 of file sdp.c.

                                                               {
  if (!capabilities || capability_count == 0 || !audio_config || !offer_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP offer parameters");
  }
 
  memset(offer_out, 0, sizeof(sdp_session_t));
 
  // Generate session ID and version from current time
  time_t now = time(NULL);
  snprintf(offer_out->session_id, sizeof(offer_out->session_id), "%ld", now);
  snprintf(offer_out->session_version, sizeof(offer_out->session_version), "%ld", now);
 
  // Allocate and copy video codecs
  offer_out->video_codecs = SAFE_MALLOC(capability_count * sizeof(terminal_capability_t), terminal_capability_t *);
  memcpy(offer_out->video_codecs, capabilities, capability_count * sizeof(terminal_capability_t));
  offer_out->video_codec_count = capability_count;
 
  offer_out->has_audio = true;
  memcpy(&offer_out->audio_config, audio_config, sizeof(opus_config_t));
 
  offer_out->has_video = true;
  if (format) {
    memcpy(&offer_out->video_format, format, sizeof(terminal_format_params_t));
  }
 
  // Build complete SDP offer
  char *sdp = offer_out->sdp_string;
  size_t remaining = sizeof(offer_out->sdp_string);
  int written = 0;
 
  // Session-level attributes
  written = snprintf(sdp, remaining, "v=0\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "o=ascii-chat %s %s IN IP4 0.0.0.0\r\n", offer_out->session_id,
                     offer_out->session_version);
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "s=-\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "t=0 0\r\n");
  sdp += written;
  remaining -= written;
 
  // Audio media section
  written = snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
  sdp += written;
  remaining -= written;
 
  written = snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
  sdp += written;
  remaining -= written;
 
  // Video media section with terminal capabilities
  char codec_list[128] = "96";
  for (size_t i = 1; i < capability_count; i++) {
    char codec_num[4];
    snprintf(codec_num, sizeof(codec_num), " %d", 96 + (int)i);
    size_t len = strlen(codec_list);
    strncat(codec_list, codec_num, sizeof(codec_list) - len - 1);
  }
 
  written = snprintf(sdp, remaining, "m=video 9 UDP/TLS/RTP/SAVPF %s\r\n", codec_list);
  sdp += written;
  remaining -= written;
 
  // Add rtpmap and fmtp for each capability
  for (size_t i = 0; i < capability_count; i++) {
    int pt = 96 + (int)i;
    const char *codec_name = sdp_codec_name(capabilities[i].codec);
 
    written = snprintf(sdp, remaining, "a=rtpmap:%d %s/90000\r\n", pt, codec_name);
    sdp += written;
    remaining -= written;
 
    // Format parameters
    const terminal_format_params_t *cap_format = &capabilities[i].format;
    const char *renderer_name = sdp_renderer_name(cap_format->renderer);
    const char *charset_name = (cap_format->charset == CHARSET_UTF8) ? "utf8" : "ascii";
    const char *compression_name = "none";
    if (cap_format->compression == COMPRESSION_RLE) {
      compression_name = "rle";
    } else if (cap_format->compression == COMPRESSION_ZSTD) {
      compression_name = "zstd";
    }
 
    written =
        snprintf(sdp, remaining, "a=fmtp:%d width=%u;height=%u;renderer=%s;charset=%s;compression=%s;csi_rep=%d\r\n",
                 pt, cap_format->width, cap_format->height, renderer_name, charset_name, compression_name,
                 cap_format->csi_rep_support ? 1 : 0);
    sdp += written;
    remaining -= written;
  }
 
  offer_out->sdp_length = strlen(offer_out->sdp_string);
 
  log_debug("SDP: Generated offer with %zu video codecs and Opus audio", capability_count);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, sdp_session_t::audio_config, terminal_format_params_t::charset, terminal_format_params_t::compression, terminal_format_params_t::csi_rep_support, ERROR_INVALID_PARAM, terminal_capability_t::format, sdp_session_t::has_audio, sdp_session_t::has_video, terminal_format_params_t::height, log_debug, terminal_format_params_t::renderer, SAFE_MALLOC, sdp_codec_name(), sdp_session_t::sdp_length, sdp_renderer_name(), sdp_session_t::sdp_string, sdp_session_t::session_id, sdp_session_t::session_version, SET_ERRNO, sdp_session_t::video_codec_count, sdp_session_t::video_codecs, sdp_session_t::video_format, and terminal_format_params_t::width.

sdp_get_selected_video_codec()

asciichat_error_t sdp_get_selected_video_codec	(	const sdp_session_t *	answer,
		acip_codec_t *	selected_codec,
		terminal_format_params_t *	selected_format
	)

Extract selected video codec from SDP answer.

Determines which terminal rendering capability the peer selected.

Parameters

answer	SDP answer from peer
selected_codec	Selected codec (output)
selected_format	Format parameters (output)

Returns

ASCIICHAT_OK if valid selection found, error otherwise

Definition at line 534 of file sdp.c.

                                                                                          {
  if (!answer || !selected_codec || !selected_format) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for codec selection");
  }
 
  if (!answer->has_video || !answer->video_codecs || answer->video_codec_count == 0) {
    return SET_ERRNO(ERROR_NOT_FOUND, "No video codec in answer");
  }
 
  // In SDP answer, server selects only ONE codec (server's preference)
  // The first codec in the answer is the selected one
  terminal_capability_t *selected_cap = &answer->video_codecs[0];
 
  *selected_codec = selected_cap->codec;
  memcpy(selected_format, &selected_cap->format, sizeof(terminal_format_params_t));
 
  log_debug("SDP: Selected video codec %s with resolution %ux%u", sdp_codec_name(selected_cap->codec),
            selected_cap->format.width, selected_cap->format.height);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, terminal_capability_t::codec, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, terminal_capability_t::format, sdp_session_t::has_video, terminal_format_params_t::height, log_debug, sdp_codec_name(), SET_ERRNO, sdp_session_t::video_codec_count, sdp_session_t::video_codecs, and terminal_format_params_t::width.

sdp_parse()

asciichat_error_t sdp_parse	(	const char *	sdp_string,
		sdp_session_t *	session
	)

Parse SDP offer or answer.

Parses an SDP string and extracts audio/video configurations.

Parameters

sdp_string	SDP string (null-terminated)
session	Parsed session (output)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 318 of file sdp.c.

                                                                            {
  if (!sdp_string || !session) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP parse parameters");
  }
 
  memset(session, 0, sizeof(sdp_session_t));
 
  // Copy original SDP string for reference
  SAFE_STRNCPY(session->sdp_string, sdp_string, sizeof(session->sdp_string));
  session->sdp_length = strlen(sdp_string);
 
  // Parse line by line
  char line_buffer[512];
  SAFE_STRNCPY(line_buffer, sdp_string, sizeof(line_buffer));
 
  char *saveptr = NULL;
  char *line = strtok_r(line_buffer, "\r\n", &saveptr);
 
  int in_audio_section = 0;
  int in_video_section = 0;
  size_t video_codec_index = 0;
 
  while (line) {
    // Parse line format: "key=value"
    char *equals = strchr(line, '=');
    if (!equals) {
      line = strtok_r(NULL, "\r\n", &saveptr);
      continue;
    }
 
    char key = line[0];
    const char *value = equals + 1;
 
    switch (key) {
    case 'v':
      // v=0 (version)
      break;
 
    case 'o':
      // o=username session_id session_version ... session_id ...
      // Parse session ID (second field)
      {
        char o_copy[256];
        SAFE_STRNCPY(o_copy, value, sizeof(o_copy));
        char *o_saveptr = NULL;
        strtok_r(o_copy, " ", &o_saveptr); // username
        char *session_id_str = strtok_r(NULL, " ", &o_saveptr);
        if (session_id_str) {
          SAFE_STRNCPY(session->session_id, session_id_str, sizeof(session->session_id));
        }
      }
      break;
 
    case 's':
      // s=session_name (typically "-" or empty)
      break;
 
    case 'm':
      // m=audio 9 UDP/TLS/RTP/SAVPF ...
      // m=video 9 UDP/TLS/RTP/SAVPF ...
      in_audio_section = 0;
      in_video_section = 0;
 
      if (strstr(value, "audio")) {
        in_audio_section = 1;
        session->has_audio = true;
      } else if (strstr(value, "video")) {
        in_video_section = 1;
        session->has_video = true;
        video_codec_index = 0;
      }
      break;
 
    case 'a':
      // a=rtpmap:111 opus/48000/2
      // a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1
      // a=rtpmap:96 ACIP-TC/90000
      // a=fmtp:96 ...
 
      if (strstr(value, "rtpmap:")) {
        const char *rtpmap = value + 7; // Skip "rtpmap:"
 
        // Parse: PT codec/rate[/channels]
        int pt = 0;
        char codec_name[32] = {0};
        sscanf(rtpmap, "%d %s", &pt, codec_name);
 
        if (in_audio_section && pt == 111 && strstr(codec_name, "opus")) {
          // Opus audio
          session->audio_config.sample_rate = 48000;
          session->audio_config.channels = 2;
        } else if (in_video_section && video_codec_index < 4) {
          // Terminal capability codec
          if (!session->video_codecs) {
            session->video_codecs = SAFE_MALLOC(4 * sizeof(terminal_capability_t), terminal_capability_t *);
          }
 
          terminal_capability_t *cap = &session->video_codecs[video_codec_index];
          memset(cap, 0, sizeof(terminal_capability_t));
 
          if (pt == 96 && strstr(codec_name, "ACIP-TC")) {
            cap->codec = ACIP_CODEC_TRUECOLOR;
            video_codec_index++;
            session->video_codec_count++;
          } else if (pt == 97 && strstr(codec_name, "ACIP-256")) {
            cap->codec = ACIP_CODEC_256COLOR;
            video_codec_index++;
            session->video_codec_count++;
          } else if (pt == 98 && strstr(codec_name, "ACIP-16")) {
            cap->codec = ACIP_CODEC_16COLOR;
            video_codec_index++;
            session->video_codec_count++;
          } else if (pt == 99 && strstr(codec_name, "ACIP-MONO")) {
            cap->codec = ACIP_CODEC_MONO;
            video_codec_index++;
            session->video_codec_count++;
          }
        }
      } else if (strstr(value, "fmtp:")) {
        // Parse format parameters
        // a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1
        // a=fmtp:96 width=80;height=24;renderer=block;charset=utf8;compression=rle;csi_rep=1
 
        const char *fmtp = value + 5; // Skip "fmtp:"
 
        if (in_audio_section) {
          // Parse Opus parameters
          if (strstr(fmtp, "useinbandfec=1")) {
            session->audio_config.fec_enabled = true;
          }
          if (strstr(fmtp, "usedtx=1")) {
            session->audio_config.dtx_enabled = true;
          }
          // Default values for Opus
          session->audio_config.bitrate = 24000;
          session->audio_config.frame_duration = 20;
        } else if (in_video_section && video_codec_index > 0) {
          // Parse terminal format parameters
          terminal_capability_t *cap = &session->video_codecs[video_codec_index - 1];
 
          char fmtp_copy[256];
          SAFE_STRNCPY(fmtp_copy, fmtp, sizeof(fmtp_copy));
 
          // Skip PT number
          char *saveptr = NULL;
          strtok_r(fmtp_copy, " ", &saveptr);
          const char *params = fmtp_copy + strcspn(fmtp_copy, " ") + 1;
 
          // Parse width=N
          const char *width_str = strstr(params, "width=");
          if (width_str) {
            sscanf(width_str + 6, "%hu", &cap->format.width);
          }
 
          // Parse height=N
          const char *height_str = strstr(params, "height=");
          if (height_str) {
            sscanf(height_str + 7, "%hu", &cap->format.height);
          }
 
          // Parse renderer type
          const char *renderer_str = strstr(params, "renderer=");
          if (renderer_str) {
            if (strstr(renderer_str, "block")) {
              cap->format.renderer = RENDERER_BLOCK;
            } else if (strstr(renderer_str, "halfblock")) {
              cap->format.renderer = RENDERER_HALFBLOCK;
            } else if (strstr(renderer_str, "braille")) {
              cap->format.renderer = RENDERER_BRAILLE;
            }
          }
 
          // Parse charset
          const char *charset_str = strstr(params, "charset=");
          if (charset_str) {
            if (strstr(charset_str, "utf8")) {
              cap->format.charset = CHARSET_UTF8;
            } else if (strstr(charset_str, "utf8_wide")) {
              cap->format.charset = CHARSET_UTF8_WIDE;
            } else {
              cap->format.charset = CHARSET_ASCII;
            }
          }
 
          // Parse compression
          const char *compression_str = strstr(params, "compression=");
          if (compression_str) {
            if (strstr(compression_str, "rle")) {
              cap->format.compression = COMPRESSION_RLE;
            } else if (strstr(compression_str, "zstd")) {
              cap->format.compression = COMPRESSION_ZSTD;
            } else {
              cap->format.compression = COMPRESSION_NONE;
            }
          }
 
          // Parse CSI REP support
          const char *csi_rep_str = strstr(params, "csi_rep=");
          if (csi_rep_str) {
            cap->format.csi_rep_support = (csi_rep_str[8] == '1');
          }
        }
      }
      break;
    }
 
    line = strtok_r(NULL, "\r\n", &saveptr);
  }
 
  return ASCIICHAT_OK;
}

References ACIP_CODEC_16COLOR, ACIP_CODEC_256COLOR, ACIP_CODEC_MONO, ACIP_CODEC_TRUECOLOR, ASCIICHAT_OK, sdp_session_t::audio_config, opus_config_t::bitrate, opus_config_t::channels, terminal_format_params_t::charset, terminal_capability_t::codec, terminal_format_params_t::compression, terminal_format_params_t::csi_rep_support, opus_config_t::dtx_enabled, ERROR_INVALID_PARAM, opus_config_t::fec_enabled, terminal_capability_t::format, opus_config_t::frame_duration, sdp_session_t::has_audio, sdp_session_t::has_video, terminal_format_params_t::height, terminal_format_params_t::renderer, SAFE_MALLOC, SAFE_STRNCPY, opus_config_t::sample_rate, sdp_session_t::sdp_length, sdp_session_t::sdp_string, sdp_session_t::session_id, SET_ERRNO, sdp_session_t::video_codec_count, sdp_session_t::video_codecs, and terminal_format_params_t::width.

sdp_renderer_name()

const char * sdp_renderer_name

(

int

renderer_type

)

Get human-readable renderer name.

Returns

Static string (e.g., "block", "halfblock")

Definition at line 36 of file sdp.c.

                                                 {
  switch (renderer_type) {
  case RENDERER_BLOCK:
    return "block";
  case RENDERER_HALFBLOCK:
    return "halfblock";
  case RENDERER_BRAILLE:
    return "braille";
  default:
    return "unknown";
  }
}

Referenced by sdp_generate_answer(), and sdp_generate_offer().

sdp_session_free()

void sdp_session_free

(

sdp_session_t *

session

)

Free SDP session resources.

Parameters

session

Session to free

Definition at line 665 of file sdp.c.

                                              {
  if (!session) {
    return;
  }
 
  // Free allocated video codec array
  if (session->video_codecs) {
    SAFE_FREE(session->video_codecs);
    session->video_codec_count = 0;
  }
 
  // Zero out the session structure
  memset(session, 0, sizeof(sdp_session_t));
}

References SAFE_FREE, sdp_session_t::video_codec_count, and sdp_session_t::video_codecs.