flexablelib-speedups 3.3.1__tar.gz → 3.5.0__tar.gz

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0}/MANIFEST.in

@@ -2,3 +2,4 @@ include README.md
 include LICENSE
 include flexablelib_speedups/_frames.c
 include flexablelib_speedups/_width_tables.h
+include flexablelib_speedups/_ascii_table.h

{flexablelib_speedups-3.3.1/flexablelib_speedups.egg-info → flexablelib_speedups-3.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: flexablelib-speedups
-Version: 3.3.1
-Summary: Optional C acceleration of terminal frame drawing for flexablelib (cut, pad, borders, frame diffs).
+Version: 3.5.0
+Summary: Optional C acceleration of terminal frame drawing for flexablelib (cut, pad, borders, frame diffs, images).
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Author: Benjamin Ramirez
 Author-email: chilerito12@gmail.com

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0}/flexablelib_speedups/__init__.py

@@ -6,7 +6,7 @@ directly: :mod:`flexablelib._frames` picks it up when it is installed and
 falls back to identical pure-Python code when it is not.
 """
 
-__version__ = '3.3.1'
+__version__ = '3.5.0'
 
 from . import _frames  # noqa: F401,E402
 

flexablelib_speedups-3.5.0/flexablelib_speedups/_ascii_table.h

@@ -0,0 +1,342 @@
+/* Generated by tools/gen_ascii_table.py from
+ * flexablelib._frames.ASCII_FOLD. Do not edit. */
+
+struct ascii_fold_entry { Py_UCS4 cp; char ch; };
+
+static const struct ascii_fold_entry ascii_fold_table[] = {
+    {0x00A0, ' '},
+    {0x00A6, '|'},
+    {0x00AB, '<'},
+    {0x00AC, '-'},
+    {0x00B0, 'o'},
+    {0x00B1, '+'},
+    {0x00B7, '.'},
+    {0x00BB, '>'},
+    {0x00D7, 'x'},
+    {0x00F7, '/'},
+    {0x2010, '-'},
+    {0x2011, '-'},
+    {0x2012, '-'},
+    {0x2013, '-'},
+    {0x2014, '-'},
+    {0x2015, '-'},
+    {0x2018, '\''},
+    {0x2019, '\''},
+    {0x201A, '\''},
+    {0x201C, '"'},
+    {0x201D, '"'},
+    {0x201E, '"'},
+    {0x2022, '.'},
+    {0x2023, '>'},
+    {0x2026, '.'},
+    {0x2032, '\''},
+    {0x2033, '"'},
+    {0x2039, '<'},
+    {0x203A, '>'},
+    {0x2043, '-'},
+    {0x20AC, 'E'},
+    {0x2139, 'i'},
+    {0x2190, '<'},
+    {0x2191, '^'},
+    {0x2192, '>'},
+    {0x2193, 'v'},
+    {0x2194, '-'},
+    {0x2195, '|'},
+    {0x219E, '<'},
+    {0x21A0, '>'},
+    {0x21A4, '<'},
+    {0x21A6, '>'},
+    {0x21A9, '<'},
+    {0x21B5, '<'},
+    {0x21D0, '<'},
+    {0x21D1, '^'},
+    {0x21D2, '>'},
+    {0x21D3, 'v'},
+    {0x21D4, '-'},
+    {0x21D5, '|'},
+    {0x2205, '0'},
+    {0x2212, '-'},
+    {0x2219, '.'},
+    {0x221A, '+'},
+    {0x221E, '8'},
+    {0x223C, '~'},
+    {0x2248, '~'},
+    {0x2260, '#'},
+    {0x2264, '<'},
+    {0x2265, '>'},
+    {0x22EF, '.'},
+    {0x23CE, '<'},
+    {0x2423, '_'},
+    {0x2500, '-'},
+    {0x2501, '-'},
+    {0x2502, '|'},
+    {0x2503, '|'},
+    {0x2504, '-'},
+    {0x2505, '-'},
+    {0x2506, '|'},
+    {0x2507, '|'},
+    {0x2508, '-'},
+    {0x2509, '-'},
+    {0x250A, '|'},
+    {0x250B, '|'},
+    {0x250C, '+'},
+    {0x250D, '+'},
+    {0x250E, '+'},
+    {0x250F, '+'},
+    {0x2510, '+'},
+    {0x2511, '+'},
+    {0x2512, '+'},
+    {0x2513, '+'},
+    {0x2514, '+'},
+    {0x2515, '+'},
+    {0x2516, '+'},
+    {0x2517, '+'},
+    {0x2518, '+'},
+    {0x2519, '+'},
+    {0x251A, '+'},
+    {0x251B, '+'},
+    {0x251C, '+'},
+    {0x251D, '+'},
+    {0x251E, '+'},
+    {0x251F, '+'},
+    {0x2520, '+'},
+    {0x2521, '+'},
+    {0x2522, '+'},
+    {0x2523, '+'},
+    {0x2524, '+'},
+    {0x2525, '+'},
+    {0x2526, '+'},
+    {0x2527, '+'},
+    {0x2528, '+'},
+    {0x2529, '+'},
+    {0x252A, '+'},
+    {0x252B, '+'},
+    {0x252C, '+'},
+    {0x252D, '+'},
+    {0x252E, '+'},
+    {0x252F, '+'},
+    {0x2530, '+'},
+    {0x2531, '+'},
+    {0x2532, '+'},
+    {0x2533, '+'},
+    {0x2534, '+'},
+    {0x2535, '+'},
+    {0x2536, '+'},
+    {0x2537, '+'},
+    {0x2538, '+'},
+    {0x2539, '+'},
+    {0x253A, '+'},
+    {0x253B, '+'},
+    {0x253C, '+'},
+    {0x253D, '+'},
+    {0x253E, '+'},
+    {0x253F, '+'},
+    {0x2540, '+'},
+    {0x2541, '+'},
+    {0x2542, '+'},
+    {0x2543, '+'},
+    {0x2544, '+'},
+    {0x2545, '+'},
+    {0x2546, '+'},
+    {0x2547, '+'},
+    {0x2548, '+'},
+    {0x2549, '+'},
+    {0x254A, '+'},
+    {0x254B, '+'},
+    {0x254C, '-'},
+    {0x254D, '-'},
+    {0x254E, '|'},
+    {0x254F, '|'},
+    {0x2550, '='},
+    {0x2551, '|'},
+    {0x2552, '+'},
+    {0x2553, '+'},
+    {0x2554, '+'},
+    {0x2555, '+'},
+    {0x2556, '+'},
+    {0x2557, '+'},
+    {0x2558, '+'},
+    {0x2559, '+'},
+    {0x255A, '+'},
+    {0x255B, '+'},
+    {0x255C, '+'},
+    {0x255D, '+'},
+    {0x255E, '+'},
+    {0x255F, '+'},
+    {0x2560, '+'},
+    {0x2561, '+'},
+    {0x2562, '+'},
+    {0x2563, '+'},
+    {0x2564, '+'},
+    {0x2565, '+'},
+    {0x2566, '+'},
+    {0x2567, '+'},
+    {0x2568, '+'},
+    {0x2569, '+'},
+    {0x256A, '+'},
+    {0x256B, '+'},
+    {0x256C, '+'},
+    {0x256D, '+'},
+    {0x256E, '+'},
+    {0x256F, '+'},
+    {0x2570, '+'},
+    {0x2571, '/'},
+    {0x2572, '\\'},
+    {0x2573, 'X'},
+    {0x2574, '-'},
+    {0x2575, '|'},
+    {0x2576, '-'},
+    {0x2577, '|'},
+    {0x2578, '-'},
+    {0x2579, '|'},
+    {0x257A, '-'},
+    {0x257B, '|'},
+    {0x257C, '-'},
+    {0x257D, '|'},
+    {0x257E, '-'},
+    {0x257F, '|'},
+    {0x2580, '-'},
+    {0x2581, '_'},
+    {0x2582, '_'},
+    {0x2583, '.'},
+    {0x2584, '-'},
+    {0x2585, '='},
+    {0x2586, '='},
+    {0x2587, '#'},
+    {0x2588, '#'},
+    {0x2589, '#'},
+    {0x258A, '#'},
+    {0x258B, '='},
+    {0x258C, '='},
+    {0x258D, '-'},
+    {0x258E, '-'},
+    {0x258F, '|'},
+    {0x2590, '='},
+    {0x2591, '.'},
+    {0x2592, ':'},
+    {0x2593, '#'},
+    {0x2594, '-'},
+    {0x2595, '|'},
+    {0x2596, '#'},
+    {0x2597, '#'},
+    {0x2598, '#'},
+    {0x2599, '#'},
+    {0x259A, '#'},
+    {0x259B, '#'},
+    {0x259C, '#'},
+    {0x259D, '#'},
+    {0x259E, '#'},
+    {0x259F, '#'},
+    {0x25A0, '#'},
+    {0x25A1, 'o'},
+    {0x25A2, '*'},
+    {0x25A3, '*'},
+    {0x25A4, '*'},
+    {0x25A5, '*'},
+    {0x25A6, '*'},
+    {0x25A7, '*'},
+    {0x25A8, '*'},
+    {0x25A9, '*'},
+    {0x25AA, '#'},
+    {0x25AB, 'o'},
+    {0x25AC, '#'},
+    {0x25AD, 'o'},
+    {0x25AE, '#'},
+    {0x25AF, 'o'},
+    {0x25B0, '*'},
+    {0x25B1, '*'},
+    {0x25B2, '^'},
+    {0x25B3, '^'},
+    {0x25B4, '^'},
+    {0x25B5, '^'},
+    {0x25B6, '>'},
+    {0x25B7, '>'},
+    {0x25B8, '>'},
+    {0x25B9, '>'},
+    {0x25BA, '>'},
+    {0x25BB, '>'},
+    {0x25BC, 'v'},
+    {0x25BD, 'v'},
+    {0x25BE, 'v'},
+    {0x25BF, 'v'},
+    {0x25C0, '<'},
+    {0x25C1, '<'},
+    {0x25C2, '<'},
+    {0x25C3, '<'},
+    {0x25C4, '<'},
+    {0x25C5, '<'},
+    {0x25C6, '*'},
+    {0x25C7, '*'},
+    {0x25C8, '*'},
+    {0x25C9, '*'},
+    {0x25CA, '*'},
+    {0x25CB, 'o'},
+    {0x25CC, 'o'},
+    {0x25CD, '*'},
+    {0x25CE, '*'},
+    {0x25CF, '*'},
+    {0x25D0, 'o'},
+    {0x25D1, 'o'},
+    {0x25D2, 'o'},
+    {0x25D3, 'o'},
+    {0x25D4, '*'},
+    {0x25D5, '*'},
+    {0x25D6, '*'},
+    {0x25D7, '*'},
+    {0x25D8, '*'},
+    {0x25D9, '*'},
+    {0x25DA, '*'},
+    {0x25DB, '*'},
+    {0x25DC, '*'},
+    {0x25DD, '*'},
+    {0x25DE, '*'},
+    {0x25DF, '*'},
+    {0x25E0, '*'},
+    {0x25E1, '*'},
+    {0x25E2, '*'},
+    {0x25E3, '*'},
+    {0x25E4, '*'},
+    {0x25E5, '*'},
+    {0x25E6, 'o'},
+    {0x25E7, '*'},
+    {0x25E8, '*'},
+    {0x25E9, '*'},
+    {0x25EA, '*'},
+    {0x25EB, '*'},
+    {0x25EC, '*'},
+    {0x25ED, '*'},
+    {0x25EE, '*'},
+    {0x25EF, 'o'},
+    {0x25F0, '*'},
+    {0x25F1, '*'},
+    {0x25F2, '*'},
+    {0x25F3, '*'},
+    {0x25F4, '*'},
+    {0x25F5, '*'},
+    {0x25F6, '*'},
+    {0x25F7, '*'},
+    {0x25F8, '*'},
+    {0x25F9, '*'},
+    {0x25FA, '*'},
+    {0x25FB, '*'},
+    {0x25FC, '*'},
+    {0x25FF, '*'},
+    {0x2605, '*'},
+    {0x2606, '*'},
+    {0x2610, '.'},
+    {0x2611, 'x'},
+    {0x2612, 'x'},
+    {0x26A0, '!'},
+    {0x2713, '+'},
+    {0x2714, '+'},
+    {0x2716, 'x'},
+    {0x2717, 'x'},
+    {0x2718, 'x'},
+    {0x2726, '*'},
+    {0x2727, '*'},
+    {0x27F5, '<'},
+    {0x27F6, '>'},
+    {0x2B51, '*'},
+};
+
+#define ASCII_FOLD_COUNT 333

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0}/flexablelib_speedups/_frames.c

@@ -19,6 +19,7 @@
 #include <string.h>
 
 #include "_width_tables.h"
+#include "_ascii_table.h"
 
 #define ESC 0x1B
 #define BEL 0x07
@@ -682,6 +683,226 @@ fail:
     return NULL;
 }
 
+/* ------------------------------------------------------------------------
+ * ascii_fold(text) -> str
+ *
+ * Every symbol of flexablelib._frames.ASCII_FOLD replaced by its one-column
+ * ASCII stand-in; braille cells become ' ', '.', ':' or '#' by dot count.
+ */
+static int
+fold_cp(Py_UCS4 cp)
+{
+    size_t low = 0, high = ASCII_FOLD_COUNT;
+    if (cp < 0x80) return 0;
+    if (cp >= 0x2800 && cp <= 0x28FF) {
+        unsigned bits = (unsigned)(cp - 0x2800);
+        int dots = 0;
+        while (bits) { dots += (int)(bits & 1u); bits >>= 1; }
+        return dots == 0 ? ' ' : dots <= 2 ? '.' : dots <= 5 ? ':' : '#';
+    }
+    while (low < high) {
+        size_t mid = low + (high - low) / 2;
+        if (cp < ascii_fold_table[mid].cp) high = mid;
+        else if (cp > ascii_fold_table[mid].cp) low = mid + 1;
+        else return (unsigned char)ascii_fold_table[mid].ch;
+    }
+    return 0;
+}
+
+static PyObject *
+py_ascii_fold(PyObject *m, PyObject *text)
+{
+    int kind, okind;
+    const void *data;
+    void *odata;
+    Py_ssize_t length, i;
+    Py_UCS4 maxchar = 0;
+    int changed = 0;
+    PyObject *out;
+    (void)m;
+    if (unpack(text, &kind, &data, &length) < 0) return NULL;
+    if (PyUnicode_IS_ASCII(text)) return Py_NewRef(text);
+    for (i = 0; i < length; i++) {
+        Py_UCS4 cp = PyUnicode_READ(kind, data, i);
+        int c = fold_cp(cp);
+        if (c) { changed = 1; cp = (Py_UCS4)c; }
+        if (cp > maxchar) maxchar = cp;
+    }
+    if (!changed) return Py_NewRef(text);
+    out = PyUnicode_New(length, maxchar);
+    if (!out) return NULL;
+    okind = PyUnicode_KIND(out);
+    odata = PyUnicode_DATA(out);
+    for (i = 0; i < length; i++) {
+        Py_UCS4 cp = PyUnicode_READ(kind, data, i);
+        int c = fold_cp(cp);
+        PyUnicode_WRITE(okind, odata, i, c ? (Py_UCS4)c : cp);
+    }
+    return out;
+}
+
+/* ------------------------------------------------------------------------
+ * extract_marks(lines) -> (clean_lines, regions)
+ *
+ * Removes the zero-width hit-region marks (ESC ] 8970 ; id BEL opens,
+ * ESC ] 8970 ; BEL closes) and reports (id, row, x0, x1, depth) per span.
+ */
+static Py_ssize_t
+measure_range(int kind, const void *data, Py_ssize_t start, Py_ssize_t end)
+{
+    Py_ssize_t total = 0, pos = start;
+    int prev = 0;
+    while (pos < end) {
+        Py_UCS4 cp = PyUnicode_READ(kind, data, pos);
+        int w;
+        if (cp == ESC) {
+            Py_ssize_t skip = seq_len(kind, data, end, pos);
+            if (skip > 0) { pos += skip; continue; }
+        }
+        if (cp == VS16) {
+            if (prev == 1) { total += 1; prev = 2; }
+            pos++;
+            continue;
+        }
+        w = cp_width(cp);
+        total += w;
+        prev = w;
+        pos++;
+    }
+    return total;
+}
+
+static int
+is_mark(int kind, const void *data, Py_ssize_t length, Py_ssize_t pos)
+{
+    static const char tag[] = "\x1b]8970;";
+    Py_ssize_t k;
+    if (pos + 7 > length) return 0;
+    for (k = 0; k < 7; k++)
+        if (PyUnicode_READ(kind, data, pos + k) != (Py_UCS4)(unsigned char)tag[k])
+            return 0;
+    return 1;
+}
+
+#define MARK_DEPTH 64
+
+static int
+add_region(PyObject *regions, long ident, Py_ssize_t row, Py_ssize_t x0,
+           Py_ssize_t x1, Py_ssize_t depth)
+{
+    PyObject *t = Py_BuildValue("(lnnnn)", ident, row, x0, x1, depth);
+    int rc;
+    if (!t) return -1;
+    rc = PyList_Append(regions, t);
+    Py_DECREF(t);
+    return rc;
+}
+
+static PyObject *
+py_extract_marks(PyObject *m, PyObject *arg)
+{
+    PyObject *seq, *out = NULL, *regions = NULL, *result = NULL;
+    Py_ssize_t n, row;
+    long ids[MARK_DEPTH];
+    Py_ssize_t starts[MARK_DEPTH];
+    (void)m;
+    seq = PySequence_Fast(arg, "lines must be a sequence of str");
+    if (!seq) return NULL;
+    n = PySequence_Fast_GET_SIZE(seq);
+    out = PyList_New(n);
+    regions = PyList_New(0);
+    if (!out || !regions) goto done;
+    for (row = 0; row < n; row++) {
+        PyObject *line = PySequence_Fast_GET_ITEM(seq, row);
+        PyObject *parts = NULL, *joined, *empty;
+        int kind;
+        const void *data;
+        Py_ssize_t length, pos = 0, k, col = 0, depth = 0, overflow = 0;
+        int found = 0;
+        if (unpack(line, &kind, &data, &length) < 0) goto done;
+        for (k = 0; k < length; k++) {
+            if (PyUnicode_READ(kind, data, k) == ESC &&
+                is_mark(kind, data, length, k)) { found = 1; break; }
+        }
+        if (!found) {
+            PyList_SET_ITEM(out, row, Py_NewRef(line));
+            continue;
+        }
+        parts = PyList_New(0);
+        if (!parts) goto done;
+        for (;;) {
+            Py_ssize_t mk = -1, end = -1, q;
+            PyObject *seg;
+            for (k = pos; k < length; k++) {
+                if (PyUnicode_READ(kind, data, k) == ESC &&
+                    is_mark(kind, data, length, k)) { mk = k; break; }
+            }
+            q = mk < 0 ? length : mk;
+            seg = PyUnicode_Substring(line, pos, q);
+            if (!seg || PyList_Append(parts, seg) < 0) {
+                Py_XDECREF(seg); Py_DECREF(parts); goto done;
+            }
+            Py_DECREF(seg);
+            col += measure_range(kind, data, pos, q);
+            if (mk < 0) break;
+            for (k = mk; k < length; k++) {
+                if (PyUnicode_READ(kind, data, k) == BEL) { end = k; break; }
+            }
+            if (end < 0) break;
+            {
+                Py_ssize_t a = mk + 7, len = end - a;
+                int digits = len > 0 && len <= 9;
+                long ident = 0;
+                for (k = a; digits && k < end; k++) {
+                    Py_UCS4 c = PyUnicode_READ(kind, data, k);
+                    if (c < '0' || c > '9') digits = 0;
+                    else ident = ident * 10 + (long)(c - '0');
+                }
+                if (digits) {
+                    if (depth < MARK_DEPTH) {
+                        ids[depth] = ident;
+                        starts[depth] = col;
+                        depth++;
+                    } else {
+                        overflow++;
+                    }
+                } else if (len == 0) {
+                    if (overflow) {
+                        overflow--;
+                    } else if (depth > 0) {
+                        depth--;
+                        if (add_region(regions, ids[depth], row, starts[depth],
+                                       col, depth) < 0) {
+                            Py_DECREF(parts); goto done;
+                        }
+                    }
+                }
+            }
+            pos = end + 1;
+        }
+        while (depth > 0) {
+            depth--;
+            if (add_region(regions, ids[depth], row, starts[depth], col,
+                           depth) < 0) {
+                Py_DECREF(parts); goto done;
+            }
+        }
+        empty = PyUnicode_New(0, 0);
+        if (!empty) { Py_DECREF(parts); goto done; }
+        joined = PyUnicode_Join(empty, parts);
+        Py_DECREF(empty);
+        Py_DECREF(parts);
+        if (!joined) goto done;
+        PyList_SET_ITEM(out, row, joined);
+    }
+    result = PyTuple_Pack(2, out, regions);
+done:
+    Py_XDECREF(out);
+    Py_XDECREF(regions);
+    Py_DECREF(seq);
+    return result;
+}
+
 static PyMethodDef methods[] = {
     {"visible_width", py_visible_width, METH_O, "Visible terminal columns of a string."},
     {"strip_ansi", py_strip_ansi, METH_O, "The string without ANSI escapes."},
@@ -695,6 +916,9 @@ static PyMethodDef methods[] = {
      "border_grid(width, height, horiz, vert, glyphs) -> list of str"},
     {"changed_lines", py_changed_lines, METH_VARARGS, "changed_lines(old, new)"},
     {"render_diff", py_render_diff, METH_VARARGS, "render_diff(old, new) -> str"},
+    {"ascii_fold", py_ascii_fold, METH_O, "ascii_fold(text) -> str"},
+    {"extract_marks", py_extract_marks, METH_O,
+     "extract_marks(lines) -> (clean_lines, regions)"},
     {NULL, NULL, 0, NULL}
 };
 

flexablelib_speedups-3.5.0/flexablelib_speedups/_images.c

@@ -0,0 +1,668 @@
+/*
+ * flexablelib_speedups._images -- C versions of the image primitives in
+ * flexablelib/_images.py: PNG unfiltering, area-average resizing, median-cut
+ * quantization, the sixel encoder and the Unicode/ASCII cell renderer.
+ *
+ * Every function gives exactly the result of its Python reference (integer
+ * arithmetic only, same tie-breaking); tests/test_v350_images.py compares
+ * both on random images.
+ */
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef long long i64;
+
+/* ------------------------------------------------------------------ */
+/* growable byte buffer                                                */
+
+typedef struct { char *p; Py_ssize_t n, cap; } Buf;
+
+static int buf_grow(Buf *b, Py_ssize_t extra)
+{
+    if (b->n + extra <= b->cap) return 0;
+    Py_ssize_t cap = b->cap ? b->cap : 256;
+    while (cap < b->n + extra) cap *= 2;
+    char *p = (char *)realloc(b->p, (size_t)cap);
+    if (!p) { PyErr_NoMemory(); return -1; }
+    b->p = p; b->cap = cap;
+    return 0;
+}
+
+static int buf_put(Buf *b, const char *s, Py_ssize_t len)
+{
+    if (buf_grow(b, len) < 0) return -1;
+    memcpy(b->p + b->n, s, (size_t)len);
+    b->n += len;
+    return 0;
+}
+
+static int buf_str(Buf *b, const char *s) { return buf_put(b, s, (Py_ssize_t)strlen(s)); }
+
+static int buf_cp(Buf *b, unsigned int cp)
+{
+    char t[4]; int n;
+    if (cp < 0x80) { t[0] = (char)cp; n = 1; }
+    else if (cp < 0x800) { t[0] = (char)(0xC0 | (cp >> 6)); t[1] = (char)(0x80 | (cp & 63)); n = 2; }
+    else if (cp < 0x10000) { t[0] = (char)(0xE0 | (cp >> 12)); t[1] = (char)(0x80 | ((cp >> 6) & 63));
+        t[2] = (char)(0x80 | (cp & 63)); n = 3; }
+    else { t[0] = (char)(0xF0 | (cp >> 18)); t[1] = (char)(0x80 | ((cp >> 12) & 63));
+        t[2] = (char)(0x80 | ((cp >> 6) & 63)); t[3] = (char)(0x80 | (cp & 63)); n = 4; }
+    return buf_put(b, t, n);
+}
+
+static int buf_int(Buf *b, long v)
+{
+    char t[32];
+    int n = snprintf(t, sizeof t, "%ld", v);
+    return buf_put(b, t, n);
+}
+
+/* ------------------------------------------------------------------ */
+/* unfilter                                                            */
+
+static PyObject *
+img_unfilter(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    Py_ssize_t rows, stride, bpp;
+    if (!PyArg_ParseTuple(args, "y*nnn", &in, &rows, &stride, &bpp)) return NULL;
+    if (rows < 0 || stride < 0 || bpp < 1) {
+        PyBuffer_Release(&in);
+        PyErr_SetString(PyExc_ValueError, "bad sizes");
+        return NULL;
+    }
+    const unsigned char *src = (const unsigned char *)in.buf;
+    PyObject *res = PyBytes_FromStringAndSize(NULL, rows * stride);
+    if (!res) { PyBuffer_Release(&in); return NULL; }
+    unsigned char *out = (unsigned char *)PyBytes_AS_STRING(res);
+    Py_ssize_t pos = 0;
+    for (Py_ssize_t r = 0; r < rows; r++) {
+        if (pos + 1 + stride > in.len) goto truncated;
+        int ft = src[pos];
+        const unsigned char *line = src + pos + 1;
+        unsigned char *o = out + r * stride;
+        const unsigned char *prev = r ? out + (r - 1) * stride : NULL;
+        pos += 1 + stride;
+        for (Py_ssize_t i = 0; i < stride; i++) {
+            int a = i >= bpp ? o[i - bpp] : 0;
+            int b = prev ? prev[i] : 0;
+            int c = (prev && i >= bpp) ? prev[i - bpp] : 0;
+            int pred;
+            switch (ft) {
+            case 0: pred = 0; break;
+            case 1: pred = a; break;
+            case 2: pred = b; break;
+            case 3: pred = (a + b) >> 1; break;
+            case 4: {
+                int p = a + b - c;
+                int pa = abs(p - a), pb = abs(p - b), pc = abs(p - c);
+                pred = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c);
+                break; }
+            default:
+                Py_DECREF(res); PyBuffer_Release(&in);
+                PyErr_Format(PyExc_ValueError, "PNG con filtro desconocido %d", ft);
+                return NULL;
+            }
+            o[i] = (unsigned char)((line[i] + pred) & 255);
+        }
+    }
+    PyBuffer_Release(&in);
+    return res;
+truncated:
+    Py_DECREF(res);
+    PyBuffer_Release(&in);
+    {
+        PyObject *mod = PyImport_ImportModule("flexablelib._images");
+        PyObject *cls = mod ? PyObject_GetAttrString(mod, "ImageError") : NULL;
+        Py_XDECREF(mod);
+        if (cls) { PyErr_SetString(cls, "PNG truncado"); Py_DECREF(cls); }
+    }
+    return NULL;
+}
+
+/* ------------------------------------------------------------------ */
+/* resize                                                              */
+
+static void spans(Py_ssize_t size, Py_ssize_t n, Py_ssize_t *lo, Py_ssize_t *hi)
+{
+    for (Py_ssize_t o = 0; o < n; o++) {
+        Py_ssize_t a = o * size / n;
+        Py_ssize_t b = ((o + 1) * size + n - 1) / n;
+        lo[o] = a;
+        hi[o] = b > a + 1 ? b : a + 1;
+    }
+}
+
+static PyObject *
+img_resize(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    Py_ssize_t w, h, nw, nh;
+    if (!PyArg_ParseTuple(args, "y*nnnn", &in, &w, &h, &nw, &nh)) return NULL;
+    if (nw <= 0 || nh <= 0 || w <= 0 || h <= 0) {
+        PyBuffer_Release(&in);
+        PyErr_SetString(PyExc_ValueError, "sizes must be positive");
+        return NULL;
+    }
+    if (in.len < w * h * 4) {
+        PyBuffer_Release(&in);
+        PyErr_SetString(PyExc_ValueError, "data shorter than width * height * 4");
+        return NULL;
+    }
+    const unsigned char *src = (const unsigned char *)in.buf;
+    Py_ssize_t *xl = PyMem_Malloc(sizeof(Py_ssize_t) * (size_t)(2 * nw + 2 * nh));
+    i64 *acc = PyMem_Malloc(sizeof(i64) * 4 * (size_t)nw);
+    if (!xl || !acc) { PyMem_Free(xl); PyMem_Free(acc); PyBuffer_Release(&in); return PyErr_NoMemory(); }
+    Py_ssize_t *xh = xl + nw, *yl = xh + nw, *yh = yl + nh;
+    spans(w, nw, xl, xh);
+    spans(h, nh, yl, yh);
+    PyObject *res = PyBytes_FromStringAndSize(NULL, nw * nh * 4);
+    if (!res) { PyMem_Free(xl); PyMem_Free(acc); PyBuffer_Release(&in); return NULL; }
+    unsigned char *out = (unsigned char *)PyBytes_AS_STRING(res);
+    Py_BEGIN_ALLOW_THREADS
+    for (Py_ssize_t oy = 0; oy < nh; oy++) {
+        memset(acc, 0, sizeof(i64) * 4 * (size_t)nw);
+        for (Py_ssize_t y = yl[oy]; y < yh[oy]; y++) {
+            const unsigned char *row = src + y * w * 4;
+            for (Py_ssize_t ox = 0; ox < nw; ox++) {
+                i64 *s = acc + ox * 4;
+                for (Py_ssize_t x = xl[ox]; x < xh[ox]; x++) {
+                    const unsigned char *p = row + x * 4;
+                    i64 a = p[3];
+                    s[0] += p[0] * a; s[1] += p[1] * a; s[2] += p[2] * a; s[3] += a;
+                }
+            }
+        }
+        unsigned char *o = out + oy * nw * 4;
+        for (Py_ssize_t ox = 0; ox < nw; ox++) {
+            i64 *s = acc + ox * 4;
+            i64 n = (i64)(yh[oy] - yl[oy]) * (xh[ox] - xl[ox]);
+            i64 sa = s[3];
+            if (sa) {
+                o[ox * 4] = (unsigned char)((s[0] + sa / 2) / sa);
+                o[ox * 4 + 1] = (unsigned char)((s[1] + sa / 2) / sa);
+                o[ox * 4 + 2] = (unsigned char)((s[2] + sa / 2) / sa);
+            } else {
+                o[ox * 4] = o[ox * 4 + 1] = o[ox * 4 + 2] = 0;
+            }
+            o[ox * 4 + 3] = (unsigned char)((sa + n / 2) / n);
+        }
+    }
+    Py_END_ALLOW_THREADS
+    PyMem_Free(xl);
+    PyMem_Free(acc);
+    PyBuffer_Release(&in);
+    return res;
+}
+
+/* ------------------------------------------------------------------ */
+/* quantize                                                            */
+
+static int sort_shift;
+static int cmp_keys(const void *a, const void *b)
+{
+    int ka = *(const int *)a, kb = *(const int *)b;
+    long va = ((long)((ka >> sort_shift) & 31) << 15) | ka;
+    long vb = ((long)((kb >> sort_shift) & 31) << 15) | kb;
+    return va < vb ? -1 : va > vb;
+}
+
+static int box_range(const int *keys, Py_ssize_t n, int shift)
+{
+    int lo = (keys[0] >> shift) & 31, hi = lo;
+    for (Py_ssize_t i = 1; i < n; i++) {
+        int v = (keys[i] >> shift) & 31;
+        if (v < lo) lo = v; else if (v > hi) hi = v;
+    }
+    return hi - lo;
+}
+
+static PyObject *
+img_quantize(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    Py_ssize_t w, h;
+    int colors, thr;
+    if (!PyArg_ParseTuple(args, "y*nnii", &in, &w, &h, &colors, &thr)) return NULL;
+    if (colors < 1) colors = 1;
+    if (colors > 255) colors = 255;
+    Py_ssize_t n = w * h;
+    if (w <= 0 || h <= 0 || in.len < n * 4) {
+        PyBuffer_Release(&in);
+        PyErr_SetString(PyExc_ValueError, "bad image size");
+        return NULL;
+    }
+    const unsigned char *src = (const unsigned char *)in.buf;
+    i64 *count = PyMem_Calloc(32768, sizeof(i64));
+    i64 *sums = PyMem_Calloc(32768 * 3, sizeof(i64));
+    int *pk = PyMem_Malloc(sizeof(int) * (size_t)n);
+    int *keys = PyMem_Malloc(sizeof(int) * 32768);
+    Py_ssize_t *bstart = PyMem_Malloc(sizeof(Py_ssize_t) * 256);
+    Py_ssize_t *blen = PyMem_Malloc(sizeof(Py_ssize_t) * 256);
+    i64 *btot = PyMem_Malloc(sizeof(i64) * 256);
+    unsigned char *lut = PyMem_Malloc(32768);
+    PyObject *pal = NULL, *idx = NULL, *res = NULL;
+    if (!count || !sums || !pk || !keys || !bstart || !blen || !btot || !lut) {
+        PyErr_NoMemory();
+        goto done;
+    }
+    for (Py_ssize_t p = 0; p < n; p++) {
+        const unsigned char *px = src + p * 4;
+        if (thr && px[3] < thr) { pk[p] = -1; continue; }
+        int key = ((px[0] >> 3) << 10) | ((px[1] >> 3) << 5) | (px[2] >> 3);
+        pk[p] = key;
+        count[key]++;
+        sums[key * 3] += px[0]; sums[key * 3 + 1] += px[1]; sums[key * 3 + 2] += px[2];
+    }
+    Py_ssize_t used = 0;
+    i64 total = 0;
+    for (int k = 0; k < 32768; k++) if (count[k]) { keys[used++] = k; total += count[k]; }
+    if (!used) {
+        pal = PyBytes_FromStringAndSize("\0\0\0", 3);
+        idx = PyBytes_FromStringAndSize(NULL, n);
+        if (pal && idx) memset(PyBytes_AS_STRING(idx), 255, (size_t)n);
+        goto pack;
+    }
+    int nb = 1;
+    bstart[0] = 0; blen[0] = used; btot[0] = total;
+    while (nb < colors) {
+        int best = -1, best_range = -1;
+        i64 best_count = -1;
+        for (int bi = 0; bi < nb; bi++) {
+            if (blen[bi] < 2) continue;
+            const int *bk = keys + bstart[bi];
+            int r = box_range(bk, blen[bi], 10), g = box_range(bk, blen[bi], 5), b = box_range(bk, blen[bi], 0);
+            int rng = r > g ? r : g; if (b > rng) rng = b;
+            if (rng > best_range || (rng == best_range && btot[bi] > best_count)) {
+                best = bi; best_range = rng; best_count = btot[bi];
+            }
+        }
+        if (best < 0) break;
+        int *bk = keys + bstart[best];
+        Py_ssize_t bn = blen[best];
+        int r = box_range(bk, bn, 10), g = box_range(bk, bn, 5), b = box_range(bk, bn, 0);
+        int mx = r; sort_shift = 10;
+        if (g > mx) { mx = g; sort_shift = 5; }
+        if (b > mx) { mx = b; sort_shift = 0; }
+        qsort(bk, (size_t)bn, sizeof(int), cmp_keys);
+        i64 tot = btot[best], acc = 0;
+        Py_ssize_t cut = 1;
+        for (Py_ssize_t j = 0; j < bn; j++) {
+            acc += count[bk[j]];
+            if (acc * 2 >= tot) { cut = j + 1; break; }
+        }
+        if (cut > bn - 1) cut = bn - 1;
+        if (cut < 1) cut = 1;
+        i64 lt = 0;
+        for (Py_ssize_t j = 0; j < cut; j++) lt += count[bk[j]];
+        for (int m = nb; m > best + 1; m--) {
+            bstart[m] = bstart[m - 1]; blen[m] = blen[m - 1]; btot[m] = btot[m - 1];
+        }
+        bstart[best + 1] = bstart[best] + cut; blen[best + 1] = bn - cut; btot[best + 1] = tot - lt;
+        blen[best] = cut; btot[best] = lt;
+        nb++;
+    }
+    pal = PyBytes_FromStringAndSize(NULL, nb * 3);
+    if (!pal) goto done;
+    unsigned char *pp = (unsigned char *)PyBytes_AS_STRING(pal);
+    for (int bi = 0; bi < nb; bi++) {
+        i64 s[3] = {0, 0, 0};
+        for (Py_ssize_t j = 0; j < blen[bi]; j++) {
+            int k = keys[bstart[bi] + j];
+            s[0] += sums[k * 3]; s[1] += sums[k * 3 + 1]; s[2] += sums[k * 3 + 2];
+        }
+        i64 c = btot[bi];
+        for (int ch = 0; ch < 3; ch++) pp[bi * 3 + ch] = (unsigned char)((s[ch] + c / 2) / c);
+    }
+    for (Py_ssize_t u = 0; u < used; u++) {
+        int k = keys[u];
+        i64 c = count[k];
+        int rr = (int)((sums[k * 3] + c / 2) / c), gg = (int)((sums[k * 3 + 1] + c / 2) / c),
+            bb = (int)((sums[k * 3 + 2] + c / 2) / c);
+        int best = 0; long dist = 1L << 30;
+        for (int pi = 0; pi < nb; pi++) {
+            long dr = pp[pi * 3] - rr, dg = pp[pi * 3 + 1] - gg, db = pp[pi * 3 + 2] - bb;
+            long d = dr * dr + dg * dg + db * db;
+            if (d < dist) { best = pi; dist = d; }
+        }
+        lut[k] = (unsigned char)best;
+    }
+    idx = PyBytes_FromStringAndSize(NULL, n);
+    if (!idx) goto done;
+    {
+        unsigned char *ip = (unsigned char *)PyBytes_AS_STRING(idx);
+        for (Py_ssize_t p = 0; p < n; p++) ip[p] = pk[p] < 0 ? 255 : lut[pk[p]];
+    }
+pack:
+    if (pal && idx) res = PyTuple_Pack(2, pal, idx);
+done:
+    Py_XDECREF(pal); Py_XDECREF(idx);
+    PyMem_Free(count); PyMem_Free(sums); PyMem_Free(pk); PyMem_Free(keys);
+    PyMem_Free(bstart); PyMem_Free(blen); PyMem_Free(btot); PyMem_Free(lut);
+    PyBuffer_Release(&in);
+    return res;
+}
+
+/* ------------------------------------------------------------------ */
+/* sixel                                                               */
+
+static PyObject *
+img_sixel_encode(PyObject *self, PyObject *args)
+{
+    Py_buffer ib, pb;
+    Py_ssize_t w, h;
+    if (!PyArg_ParseTuple(args, "y*nny*", &ib, &w, &h, &pb)) return NULL;
+    PyObject *res = NULL;
+    Buf b = {0};
+    unsigned char *bits = NULL;
+    if (w <= 0 || h <= 0 || ib.len < w * h) {
+        PyErr_SetString(PyExc_ValueError, "bad image size");
+        goto done;
+    }
+    const unsigned char *idx = (const unsigned char *)ib.buf;
+    const unsigned char *pal = (const unsigned char *)pb.buf;
+    Py_ssize_t ncolors = pb.len / 3;
+    bits = (unsigned char *)malloc((size_t)w);
+    if (!bits) { PyErr_NoMemory(); goto done; }
+    if (buf_str(&b, "\x1bP0;1;0q\"1;1;") < 0 || buf_int(&b, (long)w) < 0 ||
+        buf_str(&b, ";") < 0 || buf_int(&b, (long)h) < 0) goto done;
+    for (Py_ssize_t i = 0; i < ncolors; i++) {
+        if (buf_str(&b, "#") < 0 || buf_int(&b, (long)i) < 0 || buf_str(&b, ";2;") < 0) goto done;
+        for (int c = 0; c < 3; c++) {
+            if (c && buf_str(&b, ";") < 0) goto done;
+            if (buf_int(&b, (pal[i * 3 + c] * 100 + 127) / 255) < 0) goto done;
+        }
+    }
+    for (Py_ssize_t top = 0; top < h; top += 6) {
+        Py_ssize_t band = h - top < 6 ? h - top : 6;
+        unsigned char present[256];
+        memset(present, 0, sizeof present);
+        for (Py_ssize_t y = top; y < top + band; y++)
+            for (Py_ssize_t x = 0; x < w; x++) present[idx[y * w + x]] = 1;
+        int first = 1;
+        for (int color = 0; color < 255; color++) {
+            if (!present[color] || color >= ncolors) continue;
+            memset(bits, 0, (size_t)w);
+            for (Py_ssize_t dy = 0; dy < band; dy++) {
+                const unsigned char *row = idx + (top + dy) * w;
+                for (Py_ssize_t x = 0; x < w; x++)
+                    if (row[x] == color) bits[x] |= (unsigned char)(1 << dy);
+            }
+            Py_ssize_t last = w;
+            while (last > 0 && !bits[last - 1]) last--;
+            if (!first && buf_str(&b, "$") < 0) goto done;
+            first = 0;
+            if (buf_str(&b, "#") < 0 || buf_int(&b, color) < 0) goto done;
+            Py_ssize_t x = 0;
+            while (x < last) {
+                unsigned char v = bits[x];
+                Py_ssize_t run = 1;
+                while (x + run < last && bits[x + run] == v) run++;
+                char ch = (char)(63 + v);
+                if (run > 3) {
+                    if (buf_str(&b, "!") < 0 || buf_int(&b, (long)run) < 0 || buf_put(&b, &ch, 1) < 0) goto done;
+                } else {
+                    for (Py_ssize_t k = 0; k < run; k++) if (buf_put(&b, &ch, 1) < 0) goto done;
+                }
+                x += run;
+            }
+        }
+        if (top + 6 < h && buf_str(&b, "-") < 0) goto done;
+    }
+    if (buf_str(&b, "\x1b\\") < 0) goto done;
+    res = PyUnicode_DecodeASCII(b.p, b.n, NULL);
+done:
+    free(b.p);
+    free(bits);
+    PyBuffer_Release(&ib);
+    PyBuffer_Release(&pb);
+    return res;
+}
+
+/* ------------------------------------------------------------------ */
+/* cells                                                               */
+
+static const unsigned int QUAD[16] = {0x20, 0x2598, 0x259D, 0x2580, 0x2596, 0x258C, 0x259E, 0x259B,
+                                      0x2597, 0x259A, 0x2590, 0x259C, 0x2584, 0x2599, 0x259F, 0x2588};
+static const char RAMP[] = " .:-=+*#%@";
+static const int BAYER[16] = {0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5};
+static const int BRAILLE_BITS[8] = {0x01, 0x08, 0x02, 0x10, 0x04, 0x20, 0x40, 0x80};
+static const int CUBE[6] = {0, 95, 135, 175, 215, 255};
+static const int ANSI16[16][3] = {{0, 0, 0}, {205, 0, 0}, {0, 205, 0}, {205, 205, 0}, {0, 0, 238},
+    {205, 0, 205}, {0, 205, 205}, {229, 229, 229}, {127, 127, 127}, {255, 0, 0}, {0, 255, 0},
+    {255, 255, 0}, {92, 92, 255}, {255, 0, 255}, {0, 255, 255}, {255, 255, 255}};
+
+enum { M_HALF, M_QUAD, M_SEXT, M_BRAILLE, M_ASCII };
+enum { C_TRUE, C_256, C_16, C_NONE };
+
+typedef struct { int set; int r, g, b; } Col;
+
+static int lum3(int r, int g, int b) { return (77 * r + 150 * g + 29 * b) >> 8; }
+
+static int cube_index(int v) { return v < 48 ? 0 : v < 115 ? 1 : (v - 35) / 40; }
+
+static int to256(int r, int g, int b)
+{
+    int ri = cube_index(r), gi = cube_index(g), bi = cube_index(b);
+    int cr = CUBE[ri], cg = CUBE[gi], cb = CUBE[bi];
+    int avg = (r + g + b) / 3;
+    int gray = avg > 238 ? 23 : (avg - 3) / 10;
+    if (avg < 3) gray = 0;
+    if (gray < 0) gray = 0;
+    int gv = 8 + 10 * gray;
+    long dc = (long)(cr - r) * (cr - r) + (long)(cg - g) * (cg - g) + (long)(cb - b) * (cb - b);
+    long dg = (long)(gv - r) * (gv - r) + (long)(gv - g) * (gv - g) + (long)(gv - b) * (gv - b);
+    return dg < dc ? 232 + gray : 16 + 36 * ri + 6 * gi + bi;
+}
+
+static int to16(int r, int g, int b)
+{
+    int best = 0; long dist = 1L << 30;
+    for (int i = 0; i < 16; i++) {
+        long dr = ANSI16[i][0] - r, dg = ANSI16[i][1] - g, db = ANSI16[i][2] - b;
+        long d = dr * dr + dg * dg + db * db;
+        if (d < dist) { best = i; dist = d; }
+    }
+    return best;
+}
+
+static int col_eq(Col a, Col b)
+{
+    if (a.set != b.set) return 0;
+    if (!a.set) return 1;
+    return a.r == b.r && a.g == b.g && a.b == b.b;
+}
+
+static int put_sgr(Buf *b, Col fg, Col bg, int color)
+{
+    if (buf_str(b, "\x1b[") < 0) return -1;
+    for (int which = 0; which < 2; which++) {
+        Col c = which ? bg : fg;
+        int base = which ? 48 : 38;
+        if (which && buf_str(b, ";") < 0) return -1;
+        if (!c.set) { if (buf_int(b, base + 1) < 0) return -1; continue; }
+        if (color == C_TRUE) {
+            if (buf_int(b, base) < 0 || buf_str(b, ";2;") < 0 || buf_int(b, c.r) < 0 || buf_str(b, ";") < 0 ||
+                buf_int(b, c.g) < 0 || buf_str(b, ";") < 0 || buf_int(b, c.b) < 0) return -1;
+        } else if (color == C_256) {
+            if (buf_int(b, base) < 0 || buf_str(b, ";5;") < 0 || buf_int(b, to256(c.r, c.g, c.b)) < 0) return -1;
+        } else {
+            int idx = to16(c.r, c.g, c.b);
+            if (buf_int(b, (idx < 8 ? base - 8 : base + 52) + (idx & 7)) < 0) return -1;
+        }
+    }
+    return buf_str(b, "m");
+}
+
+static unsigned int sextant_cp(int mask)
+{
+    if (mask == 0) return 0x20;
+    if (mask == 63) return 0x2588;
+    if (mask == 21) return 0x258C;
+    if (mask == 42) return 0x2590;
+    unsigned int cp = 0x1FB00 + mask - 1;
+    if (mask > 21) cp--;
+    if (mask > 42) cp--;
+    return cp;
+}
+
+static Col mean_of(const int (*px)[3], const int *sel, int n)
+{
+    Col c = {0, 0, 0, 0};
+    int cnt = 0; long s0 = 0, s1 = 0, s2 = 0;
+    for (int k = 0; k < n; k++) if (sel[k]) { s0 += px[k][0]; s1 += px[k][1]; s2 += px[k][2]; cnt++; }
+    if (!cnt) return c;
+    c.set = 1;
+    c.r = (int)((s0 + cnt / 2) / cnt); c.g = (int)((s1 + cnt / 2) / cnt); c.b = (int)((s2 + cnt / 2) / cnt);
+    return c;
+}
+
+static PyObject *
+img_cells(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    Py_ssize_t w, h;
+    const char *mode_s, *color_s;
+    int thr;
+    if (!PyArg_ParseTuple(args, "y*nnssi", &in, &w, &h, &mode_s, &color_s, &thr)) return NULL;
+    int mode, pw, ph, color;
+    if (!strcmp(mode_s, "half")) { mode = M_HALF; pw = 1; ph = 2; }
+    else if (!strcmp(mode_s, "quadrant")) { mode = M_QUAD; pw = 2; ph = 2; }
+    else if (!strcmp(mode_s, "sextant")) { mode = M_SEXT; pw = 2; ph = 3; }
+    else if (!strcmp(mode_s, "braille")) { mode = M_BRAILLE; pw = 2; ph = 4; }
+    else if (!strcmp(mode_s, "ascii")) { mode = M_ASCII; pw = 1; ph = 2; }
+    else { PyBuffer_Release(&in); return PyErr_Format(PyExc_ValueError, "unknown mode '%s'", mode_s); }
+    if (!strcmp(color_s, "truecolor")) color = C_TRUE;
+    else if (!strcmp(color_s, "256")) color = C_256;
+    else if (!strcmp(color_s, "16")) color = C_16;
+    else if (!strcmp(color_s, "none")) color = C_NONE;
+    else { PyBuffer_Release(&in); return PyErr_Format(PyExc_ValueError, "unknown colour level '%s'", color_s); }
+    if (w < 0 || h < 0 || in.len < w * h * 4) {
+        PyBuffer_Release(&in);
+        PyErr_SetString(PyExc_ValueError, "data shorter than width * height * 4");
+        return NULL;
+    }
+    const unsigned char *src = (const unsigned char *)in.buf;
+    int mono = color == C_NONE;
+    Py_ssize_t cols = w / pw, rows = h / ph;
+    PyObject *list = PyList_New(rows);
+    if (!list) { PyBuffer_Release(&in); return NULL; }
+    Buf b = {0};
+    int npx = pw * ph;
+    for (Py_ssize_t row = 0; row < rows; row++) {
+        b.n = 0;
+        Col cur_fg = {0}, cur_bg = {0};
+        for (Py_ssize_t col = 0; col < cols; col++) {
+            int px[8][3], solid[8], lums[8];
+            int nsolid = 0;
+            for (int dy = 0; dy < ph; dy++) {
+                const unsigned char *p = src + ((row * ph + dy) * w + col * pw) * 4;
+                for (int dx = 0; dx < pw; dx++, p += 4) {
+                    int k = dy * pw + dx;
+                    solid[k] = p[3] >= thr;
+                    px[k][0] = p[0]; px[k][1] = p[1]; px[k][2] = p[2];
+                    lums[k] = lum3(p[0], p[1], p[2]);
+                    nsolid += solid[k];
+                }
+            }
+            unsigned int ch = 0x20;
+            Col fg = {0}, bg = {0};
+            if (mode == M_HALF) {
+                if (!solid[0] && !solid[1]) ch = 0x20;
+                else if (!solid[1]) { ch = 0x2580; fg.set = 1; fg.r = px[0][0]; fg.g = px[0][1]; fg.b = px[0][2]; }
+                else if (!solid[0]) { ch = 0x2584; fg.set = 1; fg.r = px[1][0]; fg.g = px[1][1]; fg.b = px[1][2]; }
+                else if (mono) {
+                    static const unsigned int T[4] = {0x20, 0x2584, 0x2580, 0x2588};
+                    ch = T[(lums[0] >= 128) * 2 + (lums[1] >= 128)];
+                } else if (px[0][0] == px[1][0] && px[0][1] == px[1][1] && px[0][2] == px[1][2]) {
+                    ch = 0x2588; fg.set = 1; fg.r = px[0][0]; fg.g = px[0][1]; fg.b = px[0][2];
+                } else {
+                    ch = 0x2580;
+                    fg.set = 1; fg.r = px[0][0]; fg.g = px[0][1]; fg.b = px[0][2];
+                    bg.set = 1; bg.r = px[1][0]; bg.g = px[1][1]; bg.b = px[1][2];
+                }
+            } else if (mode == M_ASCII) {
+                if (nsolid) {
+                    fg = mean_of((const int (*)[3])px, solid, npx);
+                    ch = (unsigned char)RAMP[lum3(fg.r, fg.g, fg.b) * 10 / 256];
+                    if (ch == 0x20 || mono) fg.set = 0;
+                }
+            } else {
+                int on[8] = {0};
+                if (nsolid) {
+                    if (mono) {
+                        Py_ssize_t gx = col * pw, gy = row * ph;
+                        for (int k = 0; k < npx; k++)
+                            if (solid[k] && lums[k] * 16 >
+                                BAYER[((gy + k / pw) & 3) * 4 + ((gx + k % pw) & 3)] * 256 + 128)
+                                on[k] = 1;
+                    } else {
+                        if (nsolid < npx) {
+                            for (int k = 0; k < npx; k++) on[k] = solid[k];
+                        } else if (mode == M_BRAILLE) {
+                            int s = 0;
+                            for (int k = 0; k < npx; k++) s += lums[k];
+                            int mean = s / npx;
+                            for (int k = 0; k < npx; k++) on[k] = lums[k] >= mean;
+                        } else {
+                            int s = 0, any = 0;
+                            for (int k = 0; k < npx; k++) s += lums[k];
+                            int mean = (s + npx / 2) / npx;
+                            for (int k = 0; k < npx; k++) { on[k] = lums[k] > mean; any |= on[k]; }
+                            if (!any) for (int k = 0; k < npx; k++) on[k] = 1;
+                        }
+                        int offs[8];
+                        for (int k = 0; k < npx; k++) offs[k] = !on[k] && solid[k];
+                        fg = mean_of((const int (*)[3])px, on, npx);
+                        if (mode != M_BRAILLE) bg = mean_of((const int (*)[3])px, offs, npx);
+                    }
+                }
+                int mask = 0;
+                for (int k = 0; k < npx; k++) if (on[k]) mask |= 1 << k;
+                if (mode == M_BRAILLE) {
+                    int bits = 0;
+                    for (int k = 0; k < 8; k++) if (mask & (1 << k)) bits |= BRAILLE_BITS[k];
+                    ch = bits ? 0x2800 + (unsigned int)bits : 0x20;
+                } else if (mode == M_QUAD) ch = QUAD[mask];
+                else ch = sextant_cp(mask);
+                if (ch == 0x20) fg.set = 0;
+                else if (ch == 0x2588) bg.set = 0;
+            }
+            if (!mono && !(col_eq(fg, cur_fg) && col_eq(bg, cur_bg))) {
+                int r = (!fg.set && !bg.set) ? buf_str(&b, "\x1b[0m") : put_sgr(&b, fg, bg, color);
+                if (r < 0) goto fail;
+                cur_fg = fg; cur_bg = bg;
+            }
+            if (buf_cp(&b, ch) < 0) goto fail;
+        }
+        if ((cur_fg.set || cur_bg.set) && buf_str(&b, "\x1b[0m") < 0) goto fail;
+        PyObject *s = PyUnicode_DecodeUTF8(b.p ? b.p : "", b.n, NULL);
+        if (!s) goto fail;
+        PyList_SET_ITEM(list, row, s);
+    }
+    free(b.p);
+    PyBuffer_Release(&in);
+    return list;
+fail:
+    free(b.p);
+    Py_DECREF(list);
+    PyBuffer_Release(&in);
+    return NULL;
+}
+
+static PyMethodDef methods[] = {
+    {"unfilter", img_unfilter, METH_VARARGS, "Undo PNG scanline filters."},
+    {"resize", img_resize, METH_VARARGS, "Area-average RGBA resampling."},
+    {"quantize", img_quantize, METH_VARARGS, "Median-cut palette and indices."},
+    {"sixel_encode", img_sixel_encode, METH_VARARGS, "DCS sixel sequence."},
+    {"cells", img_cells, METH_VARARGS, "Unicode block, braille or ASCII cells."},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT, "_images", "C image primitives for flexablelib.", -1, methods
+};
+
+PyMODINIT_FUNC PyInit__images(void) { return PyModule_Create(&module); }

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0/flexablelib_speedups.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: flexablelib-speedups
-Version: 3.3.1
-Summary: Optional C acceleration of terminal frame drawing for flexablelib (cut, pad, borders, frame diffs).
+Version: 3.5.0
+Summary: Optional C acceleration of terminal frame drawing for flexablelib (cut, pad, borders, frame diffs, images).
 Home-page: https://github.com/Opus-Perpetuus/flexablelib
 Author: Benjamin Ramirez
 Author-email: chilerito12@gmail.com

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0}/flexablelib_speedups.egg-info/SOURCES.txt

@@ -3,7 +3,9 @@ MANIFEST.in
 README.md
 setup.py
 flexablelib_speedups/__init__.py
+flexablelib_speedups/_ascii_table.h
 flexablelib_speedups/_frames.c
+flexablelib_speedups/_images.c
 flexablelib_speedups/_width_tables.h
 flexablelib_speedups.egg-info/PKG-INFO
 flexablelib_speedups.egg-info/SOURCES.txt

{flexablelib_speedups-3.3.1 → flexablelib_speedups-3.5.0}/setup.py

@@ -20,7 +20,7 @@ setup(
     name='flexablelib-speedups',
     version=version(),
     description='Optional C acceleration of terminal frame drawing for '
-                'flexablelib (cut, pad, borders, frame diffs).',
+                'flexablelib (cut, pad, borders, frame diffs, images).',
     long_description=readme(),
     long_description_content_type='text/markdown',
     author='Benjamin Ramirez',
@@ -30,9 +30,13 @@ setup(
     packages=['flexablelib_speedups'],
     ext_modules=[Extension('flexablelib_speedups._frames',
                            sources=['flexablelib_speedups/_frames.c'],
-                           depends=['flexablelib_speedups/_width_tables.h'],
+                           depends=['flexablelib_speedups/_width_tables.h',
+                                    'flexablelib_speedups/_ascii_table.h'],
                            # No compiler: the install still succeeds and
                            # flexablelib keeps its pure-Python frame code.
+                           optional=True),
+                 Extension('flexablelib_speedups._images',
+                           sources=['flexablelib_speedups/_images.c'],
                            optional=True)],
     python_requires='>=3.8',
     classifiers=[