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
Go to the documentation of this file.
1
10
11/* Storage capacities in elements; text buffers include the terminating NUL. */
12#define NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE 128
13#define NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE 256
14#define NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE 32
15
16/* Existing buffer budgets in bytes, including NUL for text storage. */
17#define SDP_VIDEO_CODEC_CAPACITY 4
18
21#include <ascii-chat/log/log.h>
23#include <libplatform/terminal.h>
24#include <string.h>
25#include <stdio.h>
26#include <time.h>
27#include <pcre2.h>
28#include <util/string.h>
29
30/* ============================================================================
31 * Utility Functions
32 * ============================================================================ */
33
34const char *sdp_codec_name(acip_codec_t codec) {
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}
48
49const char *sdp_renderer_name(int renderer_type) {
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}
61
62/* ============================================================================
63 * SDP Offer Generation
64 * ============================================================================ */
65
66asciichat_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,
67 uint32_t video_codec_caps, uint32_t audio_codec_caps, sdp_session_t *offer_out) {
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}
184
185/* ============================================================================
186 * SDP Answer Generation
187 * ============================================================================ */
188
189asciichat_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,
190 const terminal_format_params_t *server_format, uint32_t server_video_codec_caps, uint32_t server_audio_codec_caps, sdp_session_t *answer_out) {
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}
347
348/* ============================================================================
349 * SDP Parsing with PCRE2
350 * ============================================================================ */
351
358
359static const char *SDP_FMTP_VIDEO_PATTERN = "width=([0-9]+)" // 1: width
360 ".*?height=([0-9]+)" // 2: height
361 ".*?renderer=([a-z]+)" // 3: renderer (block/halfblock/braille)
362 "(?:.*?charset=([a-z0-9_]+))?" // 4: charset (optional)
363 "(?:.*?compression=([a-z0-9]+))?" // 5: compression (optional)
364 "(?:.*?csi_rep=([01]))?"; // 6: csi_rep (optional)
365
370static pcre2_code *sdp_fmtp_video_regex_get(void) {
371 return asciichat_pcre2_compile(SDP_FMTP_VIDEO_PATTERN, PCRE2_DOTALL);
372}
373
384static bool sdp_parse_fmtp_video_pcre2(const char *fmtp_params, terminal_capability_t *cap) {
385 if (!fmtp_params || !cap) {
386 return false;
387 }
388
389 // Get compiled regex (owned by the caller)
390 pcre2_code *regex = sdp_fmtp_video_regex_get();
391
392 // If PCRE2 not available, fall through to manual parsing
393 if (!regex) {
394 return false; // Fall back to manual parser in caller
395 }
396
397 pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(regex, NULL);
398 if (!match_data) {
399 pcre2_code_free(regex);
400 return false;
401 }
402
403 int rc = asciichat_pcre2_match(regex, (PCRE2_SPTR8)fmtp_params, strlen(fmtp_params), 0, 0, match_data, NULL);
404
405 bool success = false;
406 if (rc >= 4) { // At least 4 groups (width, height, renderer must be present)
407 // Extract width (group 1)
408 unsigned long width;
409 if (asciichat_pcre2_extract_group_ulong(match_data, 1, fmtp_params, &width)) {
410 cap->format.width = (uint16_t)width;
411 }
412
413 // Extract height (group 2)
414 unsigned long height;
415 if (asciichat_pcre2_extract_group_ulong(match_data, 2, fmtp_params, &height)) {
417 }
418
419 // Extract renderer (group 3)
420 char *renderer_str = asciichat_pcre2_extract_group(match_data, 3, fmtp_params);
421 if (renderer_str) {
422 if (strcmp(renderer_str, "block") == 0) {
423 cap->format.renderer = RENDERER_BLOCK;
424 } else if (strcmp(renderer_str, "halfblock") == 0) {
425 cap->format.renderer = RENDERER_HALFBLOCK;
426 } else if (strcmp(renderer_str, "braille") == 0) {
427 cap->format.renderer = RENDERER_BRAILLE;
428 }
429 SAFE_FREE(renderer_str);
430 }
431
432 // Extract charset (group 4, optional)
433 char *charset_str = asciichat_pcre2_extract_group(match_data, 4, fmtp_params);
434 if (charset_str) {
435 if (strcmp(charset_str, "utf8_wide") == 0) {
436 cap->format.charset = CHARSET_UTF8_WIDE;
437 } else if (strcmp(charset_str, "utf8") == 0) {
438 cap->format.charset = CHARSET_UTF8;
439 } else {
440 cap->format.charset = CHARSET_ASCII;
441 }
442 SAFE_FREE(charset_str);
443 }
444
445 // Extract compression (group 5, optional)
446 char *compression_str = asciichat_pcre2_extract_group(match_data, 5, fmtp_params);
447 if (compression_str) {
448 if (strcmp(compression_str, "zstd") == 0) {
449 cap->format.compression = COMPRESSION_ZSTD;
450 } else if (strcmp(compression_str, "rle") == 0) {
451 cap->format.compression = COMPRESSION_RLE;
452 } else {
453 cap->format.compression = COMPRESSION_NONE;
454 }
455 SAFE_FREE(compression_str);
456 }
457
458 // Extract csi_rep (group 6, optional)
459 char *csi_rep_str = asciichat_pcre2_extract_group(match_data, 6, fmtp_params);
460 if (csi_rep_str) {
461 cap->format.csi_rep_support = (csi_rep_str[0] == '1');
462 SAFE_FREE(csi_rep_str);
463 }
464
465 success = true;
466 }
467
468 pcre2_match_data_free(match_data);
469 pcre2_code_free(regex);
470 return success;
471}
472
473asciichat_error_t sdp_parse(const char *sdp_string, sdp_session_t *session) {
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}
653
654/* ============================================================================
655 * Video Codec Selection
656 * ============================================================================ */
657
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}
678
679/* ============================================================================
680 * Terminal Capability Detection
681 * ============================================================================ */
682
683asciichat_error_t sdp_detect_terminal_capabilities(terminal_capability_t *capabilities, size_t capability_count, size_t *detected_count) {
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}
781
782/* ============================================================================
783 * Resource Cleanup
784 * ============================================================================ */
785
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 SET_ERRNO(code,...)
Video and audio codec definitions and capability bitmasks.
unsigned int height
Definition fft.c:24
unsigned int width
Definition fft.c:24
char ** line_buffer
Circular buffer for context_before.
Definition grep.c:67
unsigned short uint16_t
unsigned int uint32_t
#define SAFE_STRNCPY(dst, src, size)
#define SAFE_FREE(ptr)
#define SAFE_MALLOC(size, cast)
#define SAFE_GETENV(name)
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_NOT_FOUND
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
📝 Logging API with multiple log levels and terminal output control
pcre2_code * asciichat_pcre2_compile(const char *pattern, uint32_t flags)
Definition pcre2.c:16
int asciichat_pcre2_match(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, PCRE2_SIZE startoffset, uint32_t options, pcre2_match_data *match_data, pcre2_match_context *context)
Definition pcre2.c:161
char * asciichat_pcre2_extract_group(pcre2_match_data *match_data, int group_num, const char *subject)
Extract numbered capture group as allocated string.
Definition pcre2.c:72
bool asciichat_pcre2_extract_group_ulong(pcre2_match_data *match_data, int group_num, const char *subject, unsigned long *out_value)
Extract numbered capture group and convert to unsigned long.
Definition pcre2.c:124
PCRE2 compilation and match helpers.
#define SDP_VIDEO_CODEC_CAPACITY
Definition sdp.c:17
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.
Definition sdp.c:683
asciichat_error_t sdp_parse(const char *sdp_string, sdp_session_t *session)
Parse SDP offer or answer.
Definition sdp.c:473
const char * sdp_codec_name(acip_codec_t codec)
Get human-readable codec name.
Definition sdp.c:34
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).
Definition sdp.c:189
#define NETWORK_WEBRTC_SDP_CODEC_LIST_BUFFER_SIZE
Definition sdp.c:12
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.
Definition sdp.c:658
#define NETWORK_WEBRTC_SDP_O_COPY_BUFFER_SIZE
Definition sdp.c:13
const char * sdp_renderer_name(int renderer_type)
Get human-readable renderer name.
Definition sdp.c:49
void sdp_session_destroy(sdp_session_t *session)
Free SDP session resources.
Definition sdp.c:786
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).
Definition sdp.c:66
#define NETWORK_WEBRTC_SDP_CODEC_NAME_BUFFER_SIZE
Definition sdp.c:14
SDP (Session Description Protocol) for WebRTC audio/video negotiation.
acip_codec_t
Terminal rendering capability payload types.
Definition sdp.h:85
@ 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
int terminal_get_size(terminal_size_t *size)
🔤 String Manipulation and Shell Escaping Utilities
Opus codec parameters for ascii-chat.
Definition sdp.h:66
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
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
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
Terminal rendering format parameters.
Definition sdp.h:95
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
⏱️ High-precision timing utilities using sokol_time.h and uthash