ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
rle.c
Go to the documentation of this file.
1
6
10#include <ascii-chat/common.h>
11
12#include <string.h>
13
14char *ansi_expand_rle(const char *input, size_t input_len) {
15 if (!input || input_len == 0) {
16 return NULL;
17 }
18
19 // RLE expansion can make output larger than input, start with 2x capacity
20 outbuf_t ob = {0};
21 ob_reserve(&ob, input_len * 2);
22
23 // Track the last character/grapheme for RLE expansion
24 // UTF-8 characters can be up to 4 bytes
25 char last_char[ASCII_CHAT_UTF8_BUFFER_SIZE] = " ";
26 size_t last_char_len = 1;
27
28 size_t i = 0;
29 while (i < input_len) {
30 // Check for ESC character (start of ANSI sequence)
31 if (input[i] == '\x1b' && i + 1 < input_len && input[i + 1] == '[') {
32 size_t seq_start = i;
33 i += 2; // Skip ESC[
34
35 // Parse parameter bytes (digits and semicolons)
36 uint32_t param = 0;
37 while (i < input_len && ((input[i] >= '0' && input[i] <= '9') || input[i] == ';')) {
38 if (input[i] >= '0' && input[i] <= '9') {
39 param = param * 10 + (uint32_t)(input[i] - '0');
40 } else if (input[i] == ';') {
41 param = 0; // Reset for next parameter
42 }
43 i++;
44 }
45
46 // Check for final byte
47 if (i < input_len) {
48 char final_byte = input[i];
49 i++;
50
51 // Handle RLE: ESC[Nb repeats previous character N times
52 if (final_byte == 'b' && param > 0) {
53 for (uint32_t r = 0; r < param; r++) {
54 ob_write(&ob, last_char, last_char_len);
55 }
56 } else {
57 // Not RLE - copy the entire escape sequence as-is
58 ob_write(&ob, input + seq_start, i - seq_start);
59 }
60 }
61 } else {
62 // Regular character - copy to output and track for RLE
63 unsigned char c = (unsigned char)input[i];
64 size_t char_len = 1;
65
66 // Determine UTF-8 character length from first byte
67 if ((c & 0x80) == 0) {
68 char_len = 1; // ASCII
69 } else if ((c & 0xE0) == 0xC0) {
70 char_len = 2; // 2-byte UTF-8
71 } else if ((c & 0xF0) == 0xE0) {
72 char_len = 3; // 3-byte UTF-8
73 } else if ((c & 0xF8) == 0xF0) {
74 char_len = 4; // 4-byte UTF-8
75 }
76
77 // Make sure we don't read past end of input
78 if (i + char_len > input_len) {
79 char_len = input_len - i;
80 }
81
82 // Copy full UTF-8 character to output
83 ob_write(&ob, input + i, char_len);
84
85 // Track last printable character for RLE (skip control chars)
86 if (c >= 0x20 && c != 0x7F) {
87 SAFE_MEMCPY(last_char, sizeof(last_char), input + i, char_len);
88 last_char[char_len] = '\0';
89 last_char_len = char_len;
90 }
91 i += char_len;
92 }
93 }
94
95 ob_term(&ob);
96 return ob.buf;
97}
98
99char *ansi_compress_rle(const char *input, size_t input_len) {
100 if (!input || input_len == 0) {
101 return NULL;
102 }
103
104 outbuf_t ob = {0};
105 ob_reserve(&ob, input_len);
106
107 size_t i = 0;
108 while (i < input_len) {
109 // Check for ESC character (start of ANSI sequence)
110 if (input[i] == '\x1b' && i + 1 < input_len && input[i + 1] == '[') {
111 size_t seq_start = i;
112 i += 2; // Skip ESC[
113
114 // Skip parameter bytes
115 while (i < input_len && ((input[i] >= '0' && input[i] <= '9') || input[i] == ';')) {
116 i++;
117 }
118
119 // Skip final byte
120 if (i < input_len) {
121 i++;
122 }
123
124 // Copy entire escape sequence as-is
125 ob_write(&ob, input + seq_start, i - seq_start);
126 } else {
127 // Regular character - check for runs
128 char c = input[i];
129
130 // Only compress printable characters (not newlines, not control chars)
131 if (c >= 0x20 && c != 0x7F) {
132 // Count run length
133 size_t run_len = 1;
134 i++;
135
136 while (i < input_len && input[i] == c) {
137 run_len++;
138 i++;
139 }
140
141 // Emit first character
142 ob_putc(&ob, c);
143
144 // Use RLE if profitable (run > overhead of ESC[Nb)
145 if (run_len > 1 && rep_is_profitable((uint32_t)run_len)) {
146 emit_rep(&ob, (uint32_t)(run_len - 1));
147 } else {
148 // Emit remaining characters directly
149 for (size_t k = 1; k < run_len; k++) {
150 ob_putc(&ob, c);
151 }
152 }
153 } else {
154 // Non-compressible character (newline, etc.)
155 ob_putc(&ob, c);
156 i++;
157 }
158 }
159 }
160
161 ob_term(&ob);
162 return ob.buf;
163}
Common buffer size definitions.
#define ASCII_CHAT_UTF8_BUFFER_SIZE
unsigned int uint32_t
#define SAFE_MEMCPY(dest, dest_size, src, count)
void ob_term(outbuf_t *ob)
Append null terminator to buffer.
void ob_putc(outbuf_t *ob, char c)
Append a character to buffer.
bool rep_is_profitable(uint32_t runlen)
Check if run-length encoding is profitable.
void ob_reserve(outbuf_t *ob, size_t need)
Dynamic output buffer (auto-expanding).
void emit_rep(outbuf_t *ob, uint32_t extra)
Emit run-length encoded sequence.
char * ansi_compress_rle(const char *input, size_t input_len)
Compress repeated characters using RLE escape sequences.
Definition rle.c:99
void ob_write(outbuf_t *ob, const void *s, size_t n)
Append a string to buffer.
char * ansi_expand_rle(const char *input, size_t input_len)
Expand RLE escape sequences in a string.
Definition rle.c:14
⚙️ Common definitions, error codes, macros, and types shared throughout the application
🔤 String Manipulation and Shell Escaping Utilities
Dynamic output buffer (auto-expanding).
char * buf
Buffer pointer (allocated, owned by caller, must be freed).