Welcome to the Lounge

static void process_byte(uint8_t val) {
    if (can_configure) return;
    if (dc.value()) {
        switch (st) {
            case STATE_WRITE:
                switch (offset) {
                    case 0:
                        write_col = val << 8;
                        ++offset;
                        ++bytes_written;
                        break;
                    case 1:
                        write_col |= val;
                        uint8_t r = ((float)((write_col >> 11) & 31) / 31.0f) * 255;
                        uint8_t g = ((float)((write_col >> 5) & 63) / 63.0f) * 255;
                        uint8_t b = ((float)((write_col >> 0) & 31) / 31.0f) * 255;
                        if (WAIT_OBJECT_0 == WaitForSingleObject(
                                                 render_mutex,  // handle to mutex
                                                 INFINITE)) {   // no time-out interval)
                            uint8_t* p = &frame_buffer[column + screen_size.width * row * 4];
                            *p++ = b;
                            *p++ = g;
                            *p++ = r;
                            *p = 0xFF;
                        }
                        ++column;
                        if (column > col_end) {
                            ++row;
                            if (row > row_end) {
                                st = STATE_IGNORING;
                                break;
                            }
                        }
                        ++bytes_written;
                        offset = 0;
                        break;
                }

                break;

            default:
                if (cmd_args_cap == 0) {
                    cmd_args_cap = 16;
                    cmd_args_size = 0;
                    cmd_args = (uint8_t*)malloc(cmd_args_cap);
                    if (cmd_args == nullptr) {
                        return;
                    }
                } else if (cmd_args == nullptr) {
                    return;
                }
                if (cmd_args_size >= cmd_args_cap) {
                    cmd_args_cap += (cmd_args_cap * .8);
                    cmd_args = (uint8_t*)realloc(cmd_args, cmd_args_cap);
                    if (cmd_args == nullptr) {
                        return;
                    }
                }
                cmd_args[cmd_args_size++] = val;
                switch (st) {
                    case STATE_COLSET:
                        if (cmd_args_size == 4) {
                            uint16_t r = cmd_args[0] << 8;
                            r |= cmd_args[1];
                            col_start = r;
                            r = cmd_args[2] << 8;
                            r |= cmd_args[3];
                            col_end = r;
                            cmd_args_size = 0;
                            column = col_start;
                            st = STATE_IGNORING;
                        }
                        break;
                    case STATE_ROWSET:
                        if (cmd_args_size == 4) {
                            uint16_t r = cmd_args[0] << 8;
                            r |= cmd_args[1];
                            row_start = r;
                            row = row_start;
                            r = cmd_args[2] << 8;
                            r |= cmd_args[3];
                            row_end = r;
                            cmd_args_size = 0;
                            st = STATE_IGNORING;
                        }
                    case STATE_WRITE:
                        if (bytes_written == sizeof(uint16_t) * (row_end - row_start + 1) * (col_start - col_end + 1)) {
                            st = STATE_IGNORING;
                        }
                        break;
                }
                break;
        }
    } else {
        bytes_written = 0;
        bytes_read = 0;
        cmd = val;
        if (cmd == colset) {
            st = STATE_COLSET;
        } else if (cmd == rowset) {
            st = STATE_ROWSET;
        } else if (cmd == write) {
            st = STATE_WRITE;
        } else if (cmd == read) {
            st = STATE_READ;
        } else {
            st = STATE_IGNORING;
            cmd_args_size = 0;
        }
    }
}
static void on_clk_changed(void* state) {
    if (cs.value()) return;
    if (clk.value()) {
        if (bit_count == 8) {
            process_byte(in_byte);
            bit_count = 0;
            in_byte = 0;
        }
        in_byte |= mosi.value();
        ++bit_count;
    } else {
        in_byte << 1;
    }
}