Improve braille drawing with dynamic buffer allocation

[da-luce]

Title. When terminal gets super large, fixed buffer breaks.

[rumly111]

The most obvious solution would be to increase MAX_COLS and MAX_ROWS, but that just adds memory usage. The current 1024x1024 bytes = 1M additional memory is a tolerable amount.

The second way to prevent the program to crash when terminal exceeds 1024x1024 is add simple check if (x >= MAX_COLS) || (y >= MAX_ROWS) return; to the function draw_braille_cell, which won't draw anything that is beyond those coordinates.

The third way is to implement a data structure that behaves like a "sparse 2d array", and it can operate with whatever coordinates the user wishes (even negatives!). Reduces memory usage, increases computation complexity. It can be an interesting exercise, but honestly no.2 is probably the best fix for it.

[rumly111]

since this is C, we may make MAX_COLS|MAX_ROWS a compile-time defined macros, and the maintainer can decide for himself at compilation time what values he wants. Current monitors can have 1024x1024, and in future just recompile with bigger values.

#if !defined(MAX_COLS)
#define MAX_COLS 1024
#endif

#if !defined(MAX_ROWS)
#define MAX_ROWS 1024
#endif

[rumly111]

@da-luce now that I think of it, you probably thought of allocating/reallocating memory (malloc/realloc etc) on terminal size change or something

[rumly111]

here is an implementation with an array with dynamic size allocation. it's not perfect, probably usable (didn't test myself):

#include <stdlib.h>
#include <string.h>
#include <curses.h>

// TODO: wrap it in struct ?
static unsigned char *braille_layer = NULL;
static int curr_max_x = 0;
static int curr_max_y = 0;

void ensure_size(int y, int x)
{
    if (y < curr_max_y && x < curr_max_x)
    {
        return;
    }
    for (curr_max_y = 1024; curr_max_y <= x; curr_max_y += 1024);
    for (curr_max_x = 1024; curr_max_x <= x; curr_max_x += 1024);
    braille_layer = reallocarray(&braille_layer, curr_max_x * curr_max_y, sizeof(unsigned char));
}

unsigned char get_cell(int y, int x)
{
    ensure_size(y, x);
    return braille_layer[curr_max_y * y + x];
}

void set_cell(int y, int x, unsigned char value)
{
    ensure_size(y, x);
    braille_layer[curr_max_y * y + x] = value;
}

void clear_braille_lines(void)
{
    memset(braille_layer, 0, curr_max_x * curr_max_y * sizeof(unsigned char));
}

void draw_braille_cell(WINDOW *win, int y, int x, unsigned char mask)
{
    if (mask == 0) return;

    // mask |= braille_layer[y][x];
    // braille_layer[y][x] = mask;
    mask |= get_cell(y, x);
    set_cell(y, x, mask);

    unsigned char utf8[4];
    utf8[0] = 0xE2;
    utf8[1] = 0xA0 | (mask >> 6);   // Top 2 bits of mask
    utf8[2] = 0x80 | (mask & 0x3F); // Bottom 6 bits of mask
    utf8[3] = '\0';

    mvwaddstr(win, y, x, (char *)utf8);
}