ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
sdp.c File Reference

SDP offer/answer generation and parsing. More...

Go to the source code of this file.

Macros

#define NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE   128
#define NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE   256
#define NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE   32
#define SDP_VIDEO_CODEC_CAPACITY   4

Functions

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

Detailed Description

SDP offer/answer generation and parsing.

Implements SDP generation for audio (Opus) and video (terminal capabilities). Terminal capabilities are negotiated as custom "codecs" in the video media section.

Date
January 2026

Definition in file sdp.c.

Macro Definition Documentation

◆ NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE   128

Definition at line 12 of file sdp.c.

Referenced by sdp_generate_offer().

◆ NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE   32

Definition at line 14 of file sdp.c.

Referenced by sdp_parse().

◆ NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE

#define NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE   256

Definition at line 13 of file sdp.c.

Referenced by sdp_parse().

◆ SDP_VIDEO_CODEC_CAPACITY

#define SDP_VIDEO_CODEC_CAPACITY   4

Definition at line 17 of file sdp.c.

Referenced by sdp_parse().

Function Documentation

◆ sdp_codec_name()

const char * sdp_codec_name ( acip_codec_t codec)

Get human-readable codec name.

Parameters
codecCodec type
Returns
Static string (e.g., "ACIP-TC", "ACIP-256")

Definition at line 34 of file sdp.c.

34 {
35 switch (codec) {
37 return "ACIP-TC";
39 return "ACIP-256";
41 return "ACIP-16";
42 case ACIP_CODEC_MONO:
43 return "ACIP-MONO";
44 default:
45 return "UNKNOWN";
46 }
47}
@ ACIP_CODEC_16COLOR
16-color (ANSI standard)
Definition sdp.h:88
@ ACIP_CODEC_MONO
Monochrome (ASCII only).
Definition sdp.h:89
@ ACIP_CODEC_256COLOR
256-color (xterm palette)
Definition sdp.h:87
@ ACIP_CODEC_TRUECOLOR
24-bit RGB (truecolor)
Definition sdp.h:86

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
capabilitiesDetected capabilities (output)
capability_countMaximum capabilities to detect
detected_countActual number detected (output)
Returns
ASCIICHAT_OK on success, error code on failure

Definition at line 683 of file sdp.c.

683 {
684 if (!capabilities || capability_count == 0 || !detected_count) {
685 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid capability detection parameters");
686 }
687
688 *detected_count = 0;
689 memset(capabilities, 0, capability_count * sizeof(terminal_capability_t));
690
691 // Detect terminal color level using platform terminal module
692 const char *colorterm = SAFE_GETENV("COLORTERM");
693 const char *term = SAFE_GETENV("TERM");
694 terminal_color_mode_t color_level = TERM_COLOR_NONE;
695
696 if (colorterm && (strcmp(colorterm, "truecolor") == 0 || strcmp(colorterm, "24bit") == 0)) {
697 color_level = TERM_COLOR_TRUECOLOR;
698 } else if (term) {
699 if (strstr(term, "256color") || strstr(term, "256")) {
700 color_level = TERM_COLOR_256;
701 } else if (strstr(term, "color") || strcmp(term, "xterm") == 0) {
702 color_level = TERM_COLOR_16;
703 }
704 }
705
706 // Detect UTF-8 support from LANG environment variable
707 const char *lang = SAFE_GETENV("LANG");
708 bool has_utf8 = (lang && (strstr(lang, "UTF-8") || strstr(lang, "utf8")));
709
710 // CSI REP support correlates with UTF-8
711 bool has_csi_rep = has_utf8;
712
713 // Get terminal size from platform module
714 uint16_t term_width = 80; // default
715 uint16_t term_height = 24; // default
716
717 terminal_size_t term_size;
718 asciichat_error_t term_err = terminal_get_size(&term_size);
719 if (term_err == ASCIICHAT_OK) {
720 term_width = (uint16_t)term_size.cols;
721 term_height = (uint16_t)term_size.rows;
722 } else {
723 log_debug("SDP: Using default terminal size %ux%u", term_width, term_height);
724 }
725
726 // Fill capabilities array based on detected color level (preference order)
727 size_t idx = 0;
728
729 if (color_level >= TERM_COLOR_TRUECOLOR && idx < capability_count) {
730 capabilities[idx].codec = ACIP_CODEC_TRUECOLOR;
731 capabilities[idx].format.width = term_width;
732 capabilities[idx].format.height = term_height;
733 capabilities[idx].format.renderer = RENDERER_BLOCK;
734 capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
735 capabilities[idx].format.compression = COMPRESSION_RLE;
736 capabilities[idx].format.csi_rep_support = has_csi_rep;
737 idx++;
738 }
739
740 if (color_level >= TERM_COLOR_256 && idx < capability_count) {
741 capabilities[idx].codec = ACIP_CODEC_256COLOR;
742 capabilities[idx].format.width = term_width;
743 capabilities[idx].format.height = term_height;
744 capabilities[idx].format.renderer = RENDERER_BLOCK;
745 capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
746 capabilities[idx].format.compression = COMPRESSION_RLE;
747 capabilities[idx].format.csi_rep_support = has_csi_rep;
748 idx++;
749 }
750
751 if (color_level >= TERM_COLOR_16 && idx < capability_count) {
752 capabilities[idx].codec = ACIP_CODEC_16COLOR;
753 capabilities[idx].format.width = term_width;
754 capabilities[idx].format.height = term_height;
755 capabilities[idx].format.renderer = RENDERER_BLOCK;
756 capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
757 capabilities[idx].format.compression = COMPRESSION_NONE;
758 capabilities[idx].format.csi_rep_support = has_csi_rep;
759 idx++;
760 }
761
762 // Monochrome always supported
763 if (idx < capability_count) {
764 capabilities[idx].codec = ACIP_CODEC_MONO;
765 capabilities[idx].format.width = term_width;
766 capabilities[idx].format.height = term_height;
767 capabilities[idx].format.renderer = RENDERER_BLOCK;
768 capabilities[idx].format.charset = has_utf8 ? CHARSET_UTF8 : CHARSET_ASCII;
769 capabilities[idx].format.compression = COMPRESSION_NONE;
770 capabilities[idx].format.csi_rep_support = has_csi_rep;
771 idx++;
772 }
773
774 *detected_count = idx;
775
776 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,
777 term_height);
778
779 return ASCIICHAT_OK;
780}
#define SET_ERRNO(code,...)
unsigned short uint16_t
#define SAFE_GETENV(name)
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
int terminal_get_size(terminal_size_t *size)
Supported terminal capability (for offer/answer).
Definition sdp.h:108
terminal_format_params_t format
Format parameters.
Definition sdp.h:110
acip_codec_t codec
Rendering capability type.
Definition sdp.h:109
enum terminal_format_params_t::@033245003045027275006271166040003043002061260227 compression
bool csi_rep_support
CSI REP (repeat) support.
Definition sdp.h:101
enum terminal_format_params_t::@266046313330162021345135012376004106262220314124 renderer
enum terminal_format_params_t::@332210022076263272012344026361040017317251215266 charset
uint16_t height
Terminal height in characters.
Definition sdp.h:97
uint16_t width
Terminal width in characters.
Definition sdp.h:96

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, 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,
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
offerReceived SDP offer from client (includes client's codec capabilities)
server_capabilitiesArray of server-supported terminal capabilities
server_capability_countNumber of server capabilities
audio_configOpus codec configuration
server_formatServer's rendering constraints
server_video_codec_capsBitmask of server's supported video codecs (VIDEO_CODEC_CAP_*)
server_audio_codec_capsBitmask of server's supported audio codecs (AUDIO_CODEC_CAP_*)
answer_outGenerated 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 189 of file sdp.c.

190 {
191 if (!offer || !server_capabilities || server_capability_count == 0 || !audio_config || !answer_out) {
192 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP answer parameters");
193 }
194
195 memset(answer_out, 0, sizeof(sdp_session_t));
196
197 // Copy session ID from offer, increment version
198 SAFE_STRNCPY(answer_out->session_id, offer->session_id, sizeof(answer_out->session_id));
199
200 time_t now = time(NULL);
201 safe_snprintf(answer_out->session_version, sizeof(answer_out->session_version), "%ld", now);
202
203 // Answer audio section: accept Opus with codec capability negotiation
204 answer_out->has_audio = offer->has_audio;
205 if (answer_out->has_audio) {
206 memcpy(&answer_out->audio_config, audio_config, sizeof(opus_config_t));
207 // Negotiate audio codec capabilities: intersection of client and server
208 answer_out->codec_capabilities_audio = offer->codec_capabilities_audio & server_audio_codec_caps;
209 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);
210 }
211
212 // Answer video section: find best mutually-supported codec with capability negotiation
213 answer_out->has_video = offer->has_video;
214
215 if (answer_out->has_video && offer->video_codecs && offer->video_codec_count > 0) {
216 // Negotiate video codec capabilities: intersection of client and server
217 answer_out->codec_capabilities_video = offer->codec_capabilities_video & server_video_codec_caps;
218 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);
219
220 // Find best terminal capability codec: iterate through server preferences and find first match in offer
221 int selected_index = -1;
222
223 for (size_t s = 0; s < server_capability_count; s++) {
224 for (size_t o = 0; o < offer->video_codec_count; o++) {
225 if (server_capabilities[s].codec == offer->video_codecs[o].codec) {
226 selected_index = (int)s;
227 break; // Found match, use server's preference order
228 }
229 }
230 if (selected_index >= 0) {
231 break;
232 }
233 }
234
235 // Allocate and fill selected codec
237 answer_out->video_codec_count = 1;
238
239 // Use server's capability with any server_format overrides
240 if (selected_index >= 0) {
241 memcpy(answer_out->video_codecs, &server_capabilities[selected_index], sizeof(terminal_capability_t));
242 } else {
243 // Fallback to monochrome
244 memcpy(answer_out->video_codecs, &server_capabilities[0], sizeof(terminal_capability_t));
245 }
246
247 // Apply server format constraints if provided
248 if (server_format) {
249 if (server_format->width > 0) {
250 answer_out->video_codecs[0].format.width = server_format->width;
251 }
252 if (server_format->height > 0) {
253 answer_out->video_codecs[0].format.height = server_format->height;
254 }
255 if (server_format->renderer != RENDERER_BLOCK) {
256 answer_out->video_codecs[0].format.renderer = server_format->renderer;
257 }
258 if (server_format->compression != COMPRESSION_NONE) {
259 answer_out->video_codecs[0].format.compression = server_format->compression;
260 }
261 }
262
263 memcpy(&answer_out->video_format, &answer_out->video_codecs[0].format, sizeof(terminal_format_params_t));
264 }
265
266 // Build complete SDP answer
267 char *sdp = answer_out->sdp_string;
268 size_t remaining = sizeof(answer_out->sdp_string);
269 int written = 0;
270
271 // Session-level attributes
272 written = safe_snprintf(sdp, remaining, "v=0\r\n");
273 sdp += written;
274 remaining -= written;
275
276 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);
277 sdp += written;
278 remaining -= written;
279
280 written = safe_snprintf(sdp, remaining, "s=-\r\n");
281 sdp += written;
282 remaining -= written;
283
284 written = safe_snprintf(sdp, remaining, "t=0 0\r\n");
285 sdp += written;
286 remaining -= written;
287
288 // Audio media section (if present in offer)
289 if (answer_out->has_audio) {
290 written = safe_snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
291 sdp += written;
292 remaining -= written;
293
294 written = safe_snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
295 sdp += written;
296 remaining -= written;
297
298 written = safe_snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
299 sdp += written;
300 remaining -= written;
301
302 // Negotiated audio codec capabilities (custom attribute)
303 written = safe_snprintf(sdp, remaining, "a=codec-capabilities-audio:0x%x\r\n", answer_out->codec_capabilities_audio);
304 sdp += written;
305 remaining -= written;
306 }
307
308 // Video media section (if present in offer)
309 if (answer_out->has_video && answer_out->video_codecs && answer_out->video_codec_count > 0) {
310 written = safe_snprintf(sdp, remaining, "m=video 9 UDP/TLS/RTP/SAVPF 96\r\n");
311 sdp += written;
312 remaining -= written;
313
314 const char *codec_name = sdp_codec_name(answer_out->video_codecs[0].codec);
315 written = safe_snprintf(sdp, remaining, "a=rtpmap:96 %s/90000\r\n", codec_name);
316 sdp += written;
317 remaining -= written;
318
319 // Format parameters
320 const terminal_format_params_t *cap_format = &answer_out->video_codecs[0].format;
321 const char *renderer_name = sdp_renderer_name(cap_format->renderer);
322 const char *charset_name = (cap_format->charset == CHARSET_UTF8) ? "utf8" : "ascii";
323 const char *compression_name = "none";
324 if (cap_format->compression == COMPRESSION_RLE) {
325 compression_name = "rle";
326 } else if (cap_format->compression == COMPRESSION_ZSTD) {
327 compression_name = "zstd";
328 }
329
330 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,
331 compression_name, cap_format->csi_rep_support ? 1 : 0);
332 sdp += written;
333 remaining -= written;
334
335 // Negotiated video codec capabilities (custom attribute)
336 written = safe_snprintf(sdp, remaining, "a=codec-capabilities-video:0x%x\r\n", answer_out->codec_capabilities_video);
337 sdp += written;
338 remaining -= written;
339 }
340
341 answer_out->sdp_length = strlen(answer_out->sdp_string);
342
343 log_debug("SDP: Generated answer with codec %s", sdp_codec_name(answer_out->video_codecs[0].codec));
344
345 return ASCIICHAT_OK;
346}
#define SAFE_STRNCPY(dst, src, size)
#define SAFE_MALLOC(size, cast)
const char * sdp_codec_name(acip_codec_t codec)
Get human-readable codec name.
Definition sdp.c:34
const char * sdp_renderer_name(int renderer_type)
Get human-readable renderer name.
Definition sdp.c:49
Opus codec parameters for ascii-chat.
Definition sdp.h:66
SDP media session (simplified for WebRTC).
Definition sdp.h:123
terminal_format_params_t video_format
Default format parameters.
Definition sdp.h:137
uint32_t codec_capabilities_audio
AUDIO_CODEC_CAP_* bitmask (which audio codecs peer supports).
Definition sdp.h:131
size_t video_codec_count
Number of supported capabilities.
Definition sdp.h:136
char session_version[16]
Session version (timestamp).
Definition sdp.h:126
size_t sdp_length
Length of SDP string (excluding null).
Definition sdp.h:142
bool has_audio
Audio media included.
Definition sdp.h:129
char session_id[32]
Session identifier.
Definition sdp.h:125
terminal_capability_t * video_codecs
Array of supported capabilities.
Definition sdp.h:135
uint32_t codec_capabilities_video
VIDEO_CODEC_CAP_* bitmask (which video codecs peer supports).
Definition sdp.h:138
opus_config_t audio_config
Opus codec configuration.
Definition sdp.h:130
bool has_video
Video media included.
Definition sdp.h:134
char sdp_string[4096]
Complete SDP as null-terminated string.
Definition sdp.h:141
Terminal rendering format parameters.
Definition sdp.h:95

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_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
capabilitiesArray of supported terminal capabilities
capability_countNumber of capabilities
audio_configOpus codec configuration
formatFormat parameters for video section
video_codec_capsBitmask of supported video codecs (VIDEO_CODEC_CAP_*)
audio_codec_capsBitmask of supported audio codecs (AUDIO_CODEC_CAP_*)
offer_outGenerated 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 66 of file sdp.c.

67 {
68 if (!capabilities || capability_count == 0 || !audio_config || !offer_out) {
69 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP offer parameters");
70 }
71
72 memset(offer_out, 0, sizeof(sdp_session_t));
73
74 // Generate session ID and version from current time
75 time_t now = time(NULL);
76 safe_snprintf(offer_out->session_id, sizeof(offer_out->session_id), "%ld", now);
77 safe_snprintf(offer_out->session_version, sizeof(offer_out->session_version), "%ld", now);
78
79 // Allocate and copy video codecs (terminal capabilities)
80 offer_out->video_codecs = SAFE_MALLOC(capability_count * sizeof(terminal_capability_t), terminal_capability_t *);
81 memcpy(offer_out->video_codecs, capabilities, capability_count * sizeof(terminal_capability_t));
82 offer_out->video_codec_count = capability_count;
83
84 // Store codec capabilities (for SDP negotiation)
85 offer_out->codec_capabilities_video = video_codec_caps;
86 offer_out->codec_capabilities_audio = audio_codec_caps;
87
88 offer_out->has_audio = true;
89 memcpy(&offer_out->audio_config, audio_config, sizeof(opus_config_t));
90
91 offer_out->has_video = true;
92 if (format) {
93 memcpy(&offer_out->video_format, format, sizeof(terminal_format_params_t));
94 }
95
96 // Build complete SDP offer
97 char *sdp = offer_out->sdp_string;
98 size_t remaining = sizeof(offer_out->sdp_string);
99 int written = 0;
100
101 // Session-level attributes
102 written = safe_snprintf(sdp, remaining, "v=0\r\n");
103 sdp += written;
104 remaining -= written;
105
106 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);
107 sdp += written;
108 remaining -= written;
109
110 written = safe_snprintf(sdp, remaining, "s=-\r\n");
111 sdp += written;
112 remaining -= written;
113
114 written = safe_snprintf(sdp, remaining, "t=0 0\r\n");
115 sdp += written;
116 remaining -= written;
117
118 // Audio media section
119 written = safe_snprintf(sdp, remaining, "m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n");
120 sdp += written;
121 remaining -= written;
122
123 written = safe_snprintf(sdp, remaining, "a=rtpmap:111 opus/48000/2\r\n");
124 sdp += written;
125 remaining -= written;
126
127 written = safe_snprintf(sdp, remaining, "a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1\r\n");
128 sdp += written;
129 remaining -= written;
130
131 // Audio codec capabilities (custom attribute)
132 written = safe_snprintf(sdp, remaining, "a=codec-capabilities-audio:0x%x\r\n", audio_codec_caps);
133 sdp += written;
134 remaining -= written;
135
136 // Video media section with terminal capabilities
137 char codec_list[NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE] = "96";
138 size_t codec_pos = strlen(codec_list);
139 for (size_t i = 1; i < capability_count && codec_pos < sizeof(codec_list) - 1; i++) {
140 codec_pos += safe_snprintf(codec_list + codec_pos, sizeof(codec_list) - codec_pos, " %d", 96 + (int)i);
141 }
142
143 written = safe_snprintf(sdp, remaining, "m=video 9 UDP/TLS/RTP/SAVPF %s\r\n", codec_list);
144 sdp += written;
145 remaining -= written;
146
147 // Add rtpmap and fmtp for each capability
148 for (size_t i = 0; i < capability_count; i++) {
149 int pt = 96 + (int)i;
150 const char *codec_name = sdp_codec_name(capabilities[i].codec);
151
152 written = safe_snprintf(sdp, remaining, "a=rtpmap:%d %s/90000\r\n", pt, codec_name);
153 sdp += written;
154 remaining -= written;
155
156 // Format parameters
157 const terminal_format_params_t *cap_format = &capabilities[i].format;
158 const char *renderer_name = sdp_renderer_name(cap_format->renderer);
159 const char *charset_name = (cap_format->charset == CHARSET_UTF8) ? "utf8" : "ascii";
160 const char *compression_name = "none";
161 if (cap_format->compression == COMPRESSION_RLE) {
162 compression_name = "rle";
163 } else if (cap_format->compression == COMPRESSION_ZSTD) {
164 compression_name = "zstd";
165 }
166
167 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,
168 compression_name, cap_format->csi_rep_support ? 1 : 0);
169 sdp += written;
170 remaining -= written;
171 }
172
173 // Video codec capabilities (custom attribute)
174 written = safe_snprintf(sdp, remaining, "a=codec-capabilities-video:0x%x\r\n", video_codec_caps);
175 sdp += written;
176 remaining -= written;
177
178 offer_out->sdp_length = strlen(offer_out->sdp_string);
179
180 log_debug("SDP: Generated offer with %zu video codecs and Opus audio", capability_count);
181
182 return ASCIICHAT_OK;
183}
#define NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE
Definition sdp.c:12

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, 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
answerSDP answer from peer
selected_codecSelected codec (output)
selected_formatFormat parameters (output)
Returns
ASCIICHAT_OK if valid selection found, error otherwise

Definition at line 658 of file sdp.c.

658 {
659 if (!answer || !selected_codec || !selected_format) {
660 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters for codec selection");
661 }
662
663 if (!answer->has_video || !answer->video_codecs || answer->video_codec_count == 0) {
664 return SET_ERRNO(ERROR_NOT_FOUND, "No video codec in answer");
665 }
666
667 // In SDP answer, server selects only ONE codec (server's preference)
668 // The first codec in the answer is the selected one
669 terminal_capability_t *selected_cap = &answer->video_codecs[0];
670
671 *selected_codec = selected_cap->codec;
672 memcpy(selected_format, &selected_cap->format, sizeof(terminal_format_params_t));
673
674 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);
675
676 return ASCIICHAT_OK;
677}
@ ERROR_NOT_FOUND

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_stringSDP string (null-terminated)
sessionParsed session (output)
Returns
ASCIICHAT_OK on success, error code on failure

Definition at line 473 of file sdp.c.

473 {
474 if (!sdp_string || !session) {
475 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SDP parse parameters");
476 }
477
478 memset(session, 0, sizeof(sdp_session_t));
479
480 // Copy original SDP string for reference
481 SAFE_STRNCPY(session->sdp_string, sdp_string, sizeof(session->sdp_string));
482 session->sdp_length = strlen(sdp_string);
483
484 // Parse line by line
485 char line_buffer[sizeof(session->sdp_string)];
486 SAFE_STRNCPY(line_buffer, sdp_string, sizeof(line_buffer));
487
488 char *saveptr = NULL;
489 char *line = platform_strtok_r(line_buffer, "\r\n", &saveptr);
490
491 int in_audio_section = 0;
492 int in_video_section = 0;
493 size_t video_codec_index = 0;
494
495 while (line) {
496 // Parse line format: "key=value"
497 char *equals = strchr(line, '=');
498 if (!equals) {
499 line = platform_strtok_r(NULL, "\r\n", &saveptr);
500 continue;
501 }
502
503 char key = line[0];
504 const char *value = equals + 1;
505
506 switch (key) {
507 case 'v':
508 // v=0 (version)
509 break;
510
511 case 'o':
512 // o=username session_id session_version ... session_id ...
513 // Parse session ID (second field)
514 {
516 SAFE_STRNCPY(o_copy, value, sizeof(o_copy));
517 char *o_saveptr = NULL;
518 platform_strtok_r(o_copy, " ", &o_saveptr); // username
519 char *session_id_str = platform_strtok_r(NULL, " ", &o_saveptr);
520 if (session_id_str) {
521 SAFE_STRNCPY(session->session_id, session_id_str, sizeof(session->session_id));
522 }
523 }
524 break;
525
526 case 's':
527 // s=session_name (typically "-" or empty)
528 break;
529
530 case 'm':
531 // m=audio 9 UDP/TLS/RTP/SAVPF ...
532 // m=video 9 UDP/TLS/RTP/SAVPF ...
533 in_audio_section = 0;
534 in_video_section = 0;
535
536 if (strstr(value, "audio")) {
537 in_audio_section = 1;
538 session->has_audio = true;
539 } else if (strstr(value, "video")) {
540 in_video_section = 1;
541 session->has_video = true;
542 video_codec_index = 0;
543 }
544 break;
545
546 case 'a':
547 // a=rtpmap:111 opus/48000/2
548 // a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1
549 // a=rtpmap:96 ACIP-TC/90000
550 // a=fmtp:96 ...
551 // a=codec-capabilities-video:0x...
552 // a=codec-capabilities-audio:0x...
553
554 if (strstr(value, "codec-capabilities-video:")) {
555 // Parse video codec capabilities: "codec-capabilities-video:0xHH"
556 const char *cap_str = value + strlen("codec-capabilities-video:");
557 session->codec_capabilities_video = (uint32_t)strtol(cap_str, NULL, 16);
558 log_debug("SDP: Parsed video codec capabilities: 0x%x", session->codec_capabilities_video);
559 } else if (strstr(value, "codec-capabilities-audio:")) {
560 // Parse audio codec capabilities: "codec-capabilities-audio:0xHH"
561 const char *cap_str = value + strlen("codec-capabilities-audio:");
562 session->codec_capabilities_audio = (uint32_t)strtol(cap_str, NULL, 16);
563 log_debug("SDP: Parsed audio codec capabilities: 0x%x", session->codec_capabilities_audio);
564 } else if (strstr(value, "rtpmap:")) {
565 const char *rtpmap = value + 7; // Skip "rtpmap:"
566
567 // Parse: PT codec/rate[/channels]
568 char *endptr = NULL;
569 int pt = (int)strtol(rtpmap, &endptr, 10);
570 char codec_name[NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE] = {0};
571 if (endptr && *endptr == ' ') {
572 SAFE_STRNCPY(codec_name, endptr + 1, sizeof(codec_name));
573 }
574
575 if (in_audio_section && pt == 111 && strstr(codec_name, "opus")) {
576 // Opus audio
577 session->audio_config.sample_rate = 48000;
578 session->audio_config.channels = 2;
579 } else if (in_video_section && video_codec_index < SDP_VIDEO_CODEC_CAPACITY) {
580 // Terminal capability codec
581 if (!session->video_codecs) {
583 }
584
585 terminal_capability_t *cap = &session->video_codecs[video_codec_index];
586 memset(cap, 0, sizeof(terminal_capability_t));
587
588 if (pt == 96 && strstr(codec_name, "ACIP-TC")) {
590 video_codec_index++;
591 session->video_codec_count++;
592 } else if (pt == 97 && strstr(codec_name, "ACIP-256")) {
594 video_codec_index++;
595 session->video_codec_count++;
596 } else if (pt == 98 && strstr(codec_name, "ACIP-16")) {
598 video_codec_index++;
599 session->video_codec_count++;
600 } else if (pt == 99 && strstr(codec_name, "ACIP-MONO")) {
601 cap->codec = ACIP_CODEC_MONO;
602 video_codec_index++;
603 session->video_codec_count++;
604 }
605 }
606 } else if (strstr(value, "fmtp:")) {
607 // Parse format parameters
608 // a=fmtp:111 minptime=10;useinbandfec=1;usedtx=1
609 // a=fmtp:96 width=80;height=24;renderer=block;charset=utf8;compression=rle;csi_rep=1
610
611 const char *fmtp = value + 5; // Skip "fmtp:"
612
613 if (in_audio_section) {
614 // Parse Opus parameters
615 if (strstr(fmtp, "useinbandfec=1")) {
616 session->audio_config.fec_enabled = true;
617 }
618 if (strstr(fmtp, "usedtx=1")) {
619 session->audio_config.dtx_enabled = true;
620 }
621 // Default values for Opus
622 session->audio_config.bitrate = 24000;
623 session->audio_config.frame_duration = 20;
624 } else if (in_video_section && video_codec_index > 0) {
625 // Parse terminal format parameters
626 terminal_capability_t *cap = &session->video_codecs[video_codec_index - 1];
627
628 // Skip PT number in fmtp string (format: "96 width=...")
629 const char *params = fmtp;
630 while (*params && *params != ' ') {
631 params++;
632 }
633 if (*params == ' ') {
634 params++; // Skip space after PT
635 }
636
637 // Parse with PCRE2 regex (atomic extraction)
638 sdp_parse_fmtp_video_pcre2(params, cap);
639 }
640 }
641 break;
642
643 default:
644 // Ignore unknown SDP attributes
645 break;
646 }
647
648 line = platform_strtok_r(NULL, "\r\n", &saveptr);
649 }
650
651 return ASCIICHAT_OK;
652}
char ** line_buffer
Circular buffer for context_before.
Definition grep.c:67
unsigned int uint32_t
#define SDP_VIDEO_CODEC_CAPACITY
Definition sdp.c:17
#define NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE
Definition sdp.c:13
#define NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE
Definition sdp.c:14
bool dtx_enabled
Discontinuous Transmission (silence suppression).
Definition sdp.h:71
bool fec_enabled
Forward Error Correction for lossy networks.
Definition sdp.h:72
uint32_t sample_rate
48000 Hz (Opus native rate)
Definition sdp.h:67
uint32_t bitrate
24000 bps (good quality for speech)
Definition sdp.h:69
uint16_t frame_duration
20 ms (balance latency/efficiency)
Definition sdp.h:70
uint8_t channels
1 (mono for voice chat)
Definition sdp.h:68

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 49 of file sdp.c.

49 {
50 switch (renderer_type) {
51 case RENDERER_BLOCK:
52 return "block";
53 case RENDERER_HALFBLOCK:
54 return "halfblock";
55 case RENDERER_BRAILLE:
56 return "braille";
57 default:
58 return "unknown";
59 }
60}

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
sessionSession to free

Definition at line 786 of file sdp.c.

786 {
787 if (!session) {
788 return;
789 }
790
791 // Free allocated video codec array
792 if (session->video_codecs) {
793 SAFE_FREE(session->video_codecs);
794 session->video_codec_count = 0;
795 }
796
797 // Zero out the session structure
798 memset(session, 0, sizeof(sdp_session_t));
799}
#define SAFE_FREE(ptr)

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