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...

Macros
#define	NETWORK_WEBRTC_SDP_SESSION_ID_BUFFER_SIZE   32
#define	NETWORK_WEBRTC_SDP_SESSION_VERSION_BUFFER_SIZE   16
#define	NETWORK_WEBRTC_SDP_SDP_STRING_BUFFER_SIZE   4096

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, uint32_t video_codec_caps, uint32_t audio_codec_caps, sdp_session_t *offer_out)
	SDP media session (simplified for WebRTC).
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, uint32_t server_video_codec_caps, uint32_t server_audio_codec_caps, 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_destroy (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.

Macro Definition Documentation

NETWORK_WEBRTC_SDP_SDP_STRING_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_SDP_STRING_BUFFER_SIZE   4096

Definition at line 41 of file sdp.h.

NETWORK_WEBRTC_SDP_SESSION_ID_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_SESSION_ID_BUFFER_SIZE   32

Definition at line 39 of file sdp.h.

NETWORK_WEBRTC_SDP_SESSION_VERSION_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_SESSION_VERSION_BUFFER_SIZE   16

Definition at line 40 of 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 85 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 33 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 698 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_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, SAFE_GETENV, SET_ERRNO, 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,
		uint32_t	server_video_codec_caps,
		uint32_t	server_audio_codec_caps,
		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 and codec capabilities. Performs codec capability negotiation (intersection of client and server capabilities).

Parameters

offer	Received SDP offer from client (includes client's codec capabilities)
server_capabilities	Array of server-supported terminal capabilities
server_capability_count	Number of server capabilities
audio_config	Opus codec configuration
server_format	Server's rendering constraints
server_video_codec_caps	Bitmask of server's supported video codecs (VIDEO_CODEC_CAP_*)
server_audio_codec_caps	Bitmask of server's supported audio codecs (AUDIO_CODEC_CAP_*)
answer_out	Generated SDP answer (output)

Returns

ASCIICHAT_OK on success, error code on failure

Note

Caller must free answer_out using sdp_session_destroy()

Definition at line 192 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);
  safe_snprintf(answer_out->session_version, sizeof(answer_out->session_version), "%ld", now);
 
  // Answer audio section: accept Opus with codec capability negotiation
  answer_out->has_audio = offer->has_audio;
  if (answer_out->has_audio) {
    memcpy(&answer_out->audio_config, audio_config, sizeof(opus_config_t));
    // Negotiate audio codec capabilities: intersection of client and server
    answer_out->codec_capabilities_audio = offer->codec_capabilities_audio & server_audio_codec_caps;
    log_debug("SDP: Audio codec negotiation - client=0x%x server=0x%x negotiated=0x%x", offer->codec_capabilities_audio,
              server_audio_codec_caps, answer_out->codec_capabilities_audio);
  }
 
  // Answer video section: find best mutually-supported codec with capability negotiation
  answer_out->has_video = offer->has_video;
 
  if (answer_out->has_video && offer->video_codecs && offer->video_codec_count > 0) {
    // Negotiate video codec capabilities: intersection of client and server
    answer_out->codec_capabilities_video = offer->codec_capabilities_video & server_video_codec_caps;
    log_debug("SDP: Video codec negotiation - client=0x%x server=0x%x negotiated=0x%x", offer->codec_capabilities_video,
              server_video_codec_caps, answer_out->codec_capabilities_video);
 
    // Find best terminal capability 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 = safe_snprintf(sdp, remaining, "v=0\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_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 = safe_snprintf(sdp, remaining, "s=-\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_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 = safe_snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
    sdp += written;
    remaining -= written;
 
    written = safe_snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
    sdp += written;
    remaining -= written;
 
    written = safe_snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
    sdp += written;
    remaining -= written;
 
    // Negotiated audio codec capabilities (custom attribute)
    written =
        safe_snprintf(sdp, remaining, "a=codec-capabilities-audio:0x%x\r\n", answer_out->codec_capabilities_audio);
    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 = safe_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 = safe_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 = safe_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;
 
    // Negotiated video codec capabilities (custom attribute)
    written =
        safe_snprintf(sdp, remaining, "a=codec-capabilities-video:0x%x\r\n", answer_out->codec_capabilities_video);
    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, sdp_session_t::codec_capabilities_audio, sdp_session_t::codec_capabilities_video, 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_snprintf(), 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,
		uint32_t	video_codec_caps,
		uint32_t	audio_codec_caps,
		sdp_session_t *	offer_out )

SDP media session (simplified for WebRTC).

Generate SDP offer (client side)

Creates an SDP offer with:

• Opus audio codec with audio codec capabilities (AUDIO_CODEC_CAP_*)
• Terminal capabilities in client preference order with video codec capabilities (VIDEO_CODEC_CAP_*)

Parameters

capabilities	Array of supported terminal capabilities
capability_count	Number of capabilities
audio_config	Opus codec configuration
format	Format parameters for video section
video_codec_caps	Bitmask of supported video codecs (VIDEO_CODEC_CAP_*)
audio_codec_caps	Bitmask of supported audio codecs (AUDIO_CODEC_CAP_*)
offer_out	Generated SDP offer (output)

Returns

ASCIICHAT_OK on success, error code on failure

Note

Caller must free offer_out using sdp_session_destroy()

Definition at line 65 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);
  safe_snprintf(offer_out->session_id, sizeof(offer_out->session_id), "%ld", now);
  safe_snprintf(offer_out->session_version, sizeof(offer_out->session_version), "%ld", now);
 
  // Allocate and copy video codecs (terminal capabilities)
  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;
 
  // Store codec capabilities (for SDP negotiation)
  offer_out->codec_capabilities_video = video_codec_caps;
  offer_out->codec_capabilities_audio = audio_codec_caps;
 
  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 = safe_snprintf(sdp, remaining, "v=0\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_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 = safe_snprintf(sdp, remaining, "s=-\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_snprintf(sdp, remaining, "t=0 0\r\n");
  sdp += written;
  remaining -= written;
 
  // Audio media section
  written = safe_snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
  sdp += written;
  remaining -= written;
 
  written = safe_snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
  sdp += written;
  remaining -= written;
 
  // Audio codec capabilities (custom attribute)
  written = safe_snprintf(sdp, remaining, "a=codec-capabilities-audio:0x%x\r\n", audio_codec_caps);
  sdp += written;
  remaining -= written;
 
  // Video media section with terminal capabilities
  char codec_list[NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE] = "96";
  size_t codec_pos = strlen(codec_list);
  for (size_t i = 1; i < capability_count && codec_pos < sizeof(codec_list) - 1; i++) {
    codec_pos += safe_snprintf(codec_list + codec_pos, sizeof(codec_list) - codec_pos, " %d", 96 + (int)i);
  }
 
  written = safe_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 = safe_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 = safe_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;
  }
 
  // Video codec capabilities (custom attribute)
  written = safe_snprintf(sdp, remaining, "a=codec-capabilities-video:0x%x\r\n", video_codec_caps);
  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, sdp_session_t::codec_capabilities_audio, sdp_session_t::codec_capabilities_video, 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, NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE, terminal_format_params_t::renderer, SAFE_MALLOC, safe_snprintf(), 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 671 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 485 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[sizeof(session->sdp_string)];
  SAFE_STRNCPY(line_buffer, sdp_string, sizeof(line_buffer));
 
  char *saveptr = NULL;
  char *line = platform_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 = platform_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[NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE];
        SAFE_STRNCPY(o_copy, value, sizeof(o_copy));
        char *o_saveptr = NULL;
        platform_strtok_r(o_copy, " ", &o_saveptr); // username
        char *session_id_str = platform_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 ...
      // a=codec-capabilities-video:0x...
      // a=codec-capabilities-audio:0x...
 
      if (strstr(value, "codec-capabilities-video:")) {
        // Parse video codec capabilities: "codec-capabilities-video:0xHH"
        const char *cap_str = value + strlen("codec-capabilities-video:");
        session->codec_capabilities_video = (uint32_t)strtol(cap_str, NULL, 16);
        log_debug("SDP: Parsed video codec capabilities: 0x%x", session->codec_capabilities_video);
      } else if (strstr(value, "codec-capabilities-audio:")) {
        // Parse audio codec capabilities: "codec-capabilities-audio:0xHH"
        const char *cap_str = value + strlen("codec-capabilities-audio:");
        session->codec_capabilities_audio = (uint32_t)strtol(cap_str, NULL, 16);
        log_debug("SDP: Parsed audio codec capabilities: 0x%x", session->codec_capabilities_audio);
      } else if (strstr(value, "rtpmap:")) {
        const char *rtpmap = value + 7; // Skip "rtpmap:"
 
        // Parse: PT codec/rate[/channels]
        char *endptr = NULL;
        int pt = (int)strtol(rtpmap, &endptr, 10);
        char codec_name[NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE] = {0};
        if (endptr && *endptr == ' ') {
          SAFE_STRNCPY(codec_name, endptr + 1, sizeof(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 < SDP_VIDEO_CODEC_CAPACITY) {
          // Terminal capability codec
          if (!session->video_codecs) {
            session->video_codecs =
                SAFE_MALLOC(SDP_VIDEO_CODEC_CAPACITY * 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];
 
          // Skip PT number in fmtp string (format: "96 width=...")
          const char *params = fmtp;
          while (*params && *params != ' ') {
            params++;
          }
          if (*params == ' ') {
            params++; // Skip space after PT
          }
 
          // Parse with PCRE2 regex (atomic extraction)
          sdp_parse_fmtp_video_pcre2(params, cap);
        }
      }
      break;
 
    default:
      // Ignore unknown SDP attributes
      break;
    }
 
    line = platform_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_capability_t::codec, sdp_session_t::codec_capabilities_audio, sdp_session_t::codec_capabilities_video, opus_config_t::dtx_enabled, ERROR_INVALID_PARAM, opus_config_t::fec_enabled, opus_config_t::frame_duration, sdp_session_t::has_audio, sdp_session_t::has_video, line_buffer, log_debug, NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE, NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE, SAFE_MALLOC, SAFE_STRNCPY, opus_config_t::sample_rate, sdp_session_t::sdp_length, sdp_session_t::sdp_string, SDP_VIDEO_CODEC_CAPACITY, sdp_session_t::session_id, SET_ERRNO, sdp_session_t::video_codec_count, and sdp_session_t::video_codecs.

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 48 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_destroy()

void sdp_session_destroy

(

sdp_session_t *

session

)

Free SDP session resources.

Parameters

session

Session to free

Definition at line 802 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.