hackaton2019

// st7789v.c
#include "st7789v.h"

#include <guiconfig.h>
#include <string.h>
#include <stdlib.h>
#include "stm32f4xx_hal.h"
#include "gpio.h"

#ifdef ST7789V_USE_RTOS
#include "cmsis_os.h"
#endif //ST7789V_USE_RTOS

#define ST7789V_COLS 240 //
#define ST7789V_ROWS 320 //

//st7789 commands
#define CMD_SLPIN 0x10
#define CMD_SLPOUT 0x11
#define CMD_INVOFF 0x20 //Display Inversion Off
#define CMD_INVON 0x21 //Display Inversion On
#define CMD_GAMMA_SET 0x26 //gamma set
#define CMD_DISPOFF 0x28
#define CMD_DISPON 0x29
#define CMD_CASET 0x2A
#define CMD_RASET 0x2B
#define CMD_RAMWR 0x2C
#define CMD_RAMRD 0x2E
#define CMD_MADCTL 0x36
//#define CMD_IDMOFF 		0x38//Idle Mode Off
//#define CMD_IDMON 		0x38//Idle Mode On
#define CMD_COLMOD 0x3A
#define CMD_RAMWRC 0x3C
#define CMD_WRDISBV 0x51 //Write Display Brightness
#define CMD_RDDISBV 0x52 //Read Display Brightness Value
#define CMD_WRCTRLD 0x53 // Write CTRL Display \
    //-Brightness Control Block - bit 5        \
    //-Display Dimming			- bit 3               \
    //-Backlight Control On/Off - bit 2
#define CMD_RDCTRLD 0x54 //Read CTRL Value Display

//st7789 gamma
#define GAMMA_CURVE0 0x01
#define GAMMA_CURVE1 0x02
#define GAMMA_CURVE2 0x04
#define GAMMA_CURVE3 0x08

//st7789 CTRL Display
#define MASK_CTRLD_BCTRL (0x01 << 5) //Brightness Control Block
#define MASK_CTRLD_DD (0x01 << 3) //Display Dimming
#define MASK_CTRLD_BL (0x01 << 2) //Backlight Control

//color constants
#define CLR565_WHITE 0xffff
#define CLR565_BLACK 0x0000
#define CLR565_RED 0xf800
#define CLR565_CYAN 0x0000
#define CLR565_MAGENTA 0x0000
#define CLR565_GREEN 0x07e0
#define CLR565_YELLOW 0xffe0
#define CLR565_ORANGE 0x0000
#define CLR565_GRAY 0x38e7
#define CLR565_BLUE 0x001f

//color conversion
#define _COLOR_565(clr) color_to_565(clr)
//color reverse conversion
#define _565_COLOR(clr) color_from_565(clr)

//private flags (pin states)
#define FLG_CS 0x01 // current CS pin state
#define FLG_RS 0x02 // current RS pin state
#define FLG_RST 0x04 // current RST pin state

uint8_t st7789v_flg = 0; // flags

uint16_t st7789v_x = 0; // current x coordinate (CASET)
uint16_t st7789v_y = 0; // current y coordinate (RASET)
uint16_t st7789v_cx = 0; //
uint16_t st7789v_cy = 0; //

uint8_t st7789v_buff[ST7789V_COLS * 2 * 16]; //16 lines buffer

rect_ui16_t st7789v_clip = { 0, 0, ST7789V_COLS, ST7789V_ROWS };

#ifdef ST7789V_USE_RTOS
osThreadId st7789v_task_handle = 0;
#endif //ST7789V_USE_RTOS

//forward declarations
void st7789v_init(void);
void st7789v_done(void);
void st7789v_clear(color_t clr);
void st7789v_set_pixel(point_ui16_t pt, color_t clr);
void st7789v_clip_rect(rect_ui16_t rc);
void st7789v_draw_line(point_ui16_t pt, point_ui16_t pt1, color_t clr);
void st7789v_draw_rect(rect_ui16_t rc, color_t clr);
void st7789v_fill_rect(rect_ui16_t rc, color_t clr);
void st7789v_draw_char(point_ui16_t pt, char chr, font_t* pf, color_t clr0, color_t clr1);
void st7789v_draw_text(rect_ui16_t rc, const char* str, font_t* pf, color_t clr0, color_t clr1);
void st7789v_draw_png(point_ui16_t pt, FILE* pf);
/*some functions are in header - excluded from display_t struct*/
void st7789v_gamma_set_direct(uint8_t gamma_enu);
uint8_t st7789v_read_ctrl(void);
void st7789v_ctrl_set(uint8_t ctrl);

static inline void st7789v_set_cs(void)
{
    gpio_set(st7789v_config.pinCS, 1);
    st7789v_flg |= FLG_CS;
}

static inline void st7789v_clr_cs(void)
{
    gpio_set(st7789v_config.pinCS, 0);
    st7789v_flg &= ~FLG_CS;
}

static inline void st7789v_set_rs(void)
{
    gpio_set(st7789v_config.pinRS, 1);
    st7789v_flg |= FLG_RS;
}

static inline void st7789v_clr_rs(void)
{
    gpio_set(st7789v_config.pinRS, 0);
    st7789v_flg &= ~FLG_RS;
}

static inline void st7789v_set_rst(void)
{
    gpio_set(st7789v_config.pinRST, 1);
    st7789v_flg |= FLG_RST;
}

static inline void st7789v_clr_rst(void)
{
    gpio_set(st7789v_config.pinRST, 0);
    st7789v_flg &= ~FLG_RST;
}

static inline void st7789v_fill_ui16(uint16_t* p, uint16_t v, uint16_t c)
{
    while (c--)
        *(p++) = v;
}

static inline int is_interrupt(void)
{
    return (SCB->ICSR & SCB_ICSR_VECTACTIVE_Msk) != 0;
}

void st7789v_delay_ms(uint32_t ms)
{
    if (is_interrupt() || (st7789v_flg & ST7789V_FLG_SAFE)) {
        volatile uint32_t temp;
        while (ms--) {
            do {
                temp = SysTick->CTRL;
            } while ((temp & 0x01) && !(temp & (1 << 16)));
        }
    } else {
#ifdef ST7789V_USE_RTOS
        osDelay(ms);
#else
        HAL_Delay(ms);
#endif
    }
}

void st7789v_spi_wr_byte(uint8_t b)
{
    HAL_SPI_Transmit(st7789v_config.phspi, &b, 1, HAL_MAX_DELAY);
}

void st7789v_spi_wr_bytes(uint8_t* pb, uint16_t size)
{
    if ((st7789v_flg & ST7789V_FLG_DMA) && !(st7789v_flg & ST7789V_FLG_SAFE) && (size > 4)) {
#ifdef ST7789V_USE_RTOS
        osSignalSet(st7789v_task_handle, ST7789V_SIG_SPI_TX);
        osSignalWait(ST7789V_SIG_SPI_TX, osWaitForever);
#endif //ST7789V_USE_RTOS
        HAL_SPI_Transmit_DMA(st7789v_config.phspi, pb, size);
#ifdef ST7789V_USE_RTOS
        osSignalWait(ST7789V_SIG_SPI_TX, osWaitForever);
#else //ST7789V_USE_RTOS
//TODO:
#endif //ST7789V_USE_RTOS
    } else
        HAL_SPI_Transmit(st7789v_config.phspi, pb, size, HAL_MAX_DELAY);
}

void st7789v_spi_rd_bytes(uint8_t* pb, uint16_t size)
{
    HAL_StatusTypeDef ret;
#if 0
//#ifdef ST7789V_DMA
	if (size <= 4)
		ret = HAL_SPI_Receive(st7789v_config.phspi, pb, size, HAL_MAX_DELAY);
	else
	{
#ifdef ST7789V_USE_RTOS
		osSignalSet(0, ST7789V_SIG_SPI_TX);
		osSignalWait(ST7789V_SIG_SPI_TX, osWaitForever);
#endif //ST7789V_USE_RTOS
		ret = HAL_SPI_Receive_DMA(st7789v_config.phspi, pb, size);
#ifdef ST7789V_USE_RTOS
		osSignalWait(ST7789V_SIG_SPI_TX, osWaitForever);
#endif //ST7789V_USE_RTOS
	}
#else //ST7789V_DMA
    ret = HAL_SPI_Receive(st7789v_config.phspi, pb, size, HAL_MAX_DELAY);
#endif //ST7789V_DMA
    ret = ret; //prevent warning
}

void st7789v_cmd(uint8_t cmd, uint8_t* pdata, uint16_t size)
{
    uint16_t tmp_flg = st7789v_flg; // save flags
    if (st7789v_flg & FLG_CS)
        st7789v_clr_cs(); // CS = L
    if (st7789v_flg & FLG_RS)
        st7789v_clr_rs(); // RS = L
    st7789v_spi_wr_byte(cmd); // write command byte
    if (pdata && size) {
        st7789v_set_rs(); // RS = H
        st7789v_spi_wr_bytes(pdata, size); // write data bytes
    }
    if (tmp_flg & FLG_CS)
        st7789v_set_cs(); // CS = H
}

void st7789v_wr(uint8_t* pdata, uint16_t size)
{
    if (!(pdata && size))
        return; // null or empty data - return
    uint16_t tmp_flg = st7789v_flg; // save flags
    if (st7789v_flg & FLG_CS)
        st7789v_clr_cs(); // CS = L
    if (!(st7789v_flg & FLG_RS))
        st7789v_set_rs(); // RS = H
    st7789v_spi_wr_bytes(pdata, size); // write data bytes
    if (tmp_flg & FLG_CS)
        st7789v_set_cs(); // CS = H
}

void st7789v_rd(uint8_t* pdata, uint16_t size)
{
    if (!(pdata && size))
        return; // null or empty data - return
    uint16_t tmp_flg = st7789v_flg; // save flags
    if (st7789v_flg & FLG_CS)
        st7789v_clr_cs(); // CS = L
    if (!(st7789v_flg & FLG_RS))
        st7789v_set_rs(); // RS = H
    st7789v_spi_rd_bytes(pdata, size); // read data bytes
    if (tmp_flg & FLG_CS)
        st7789v_set_cs(); // CS = H
}

void st7789v_cmd_slpout(void)
{
    st7789v_cmd(CMD_SLPOUT, 0, 0);
}

void st7789v_cmd_madctl(uint8_t madctl)
{
    st7789v_cmd(CMD_MADCTL, &madctl, 1);
}

void st7789v_cmd_colmod(uint8_t colmod)
{
    st7789v_cmd(CMD_COLMOD, &colmod, 1);
}

void st7789v_cmd_dispon(void)
{
    st7789v_cmd(CMD_DISPON, 0, 0);
}

void st7789v_cmd_caset(uint16_t x, uint16_t cx)
{
    uint8_t data[4] = { x >> 8, x & 0xff, cx >> 8, cx & 0xff };
    st7789v_cmd(CMD_CASET, data, 4);
}

void st7789v_cmd_raset(uint16_t y, uint16_t cy)
{
    uint8_t data[4] = { y >> 8, y & 0xff, cy >> 8, cy & 0xff };
    st7789v_cmd(CMD_RASET, data, 4);
}

void st7789v_cmd_ramwr(uint8_t* pdata, uint16_t size)
{
    st7789v_cmd(CMD_RAMWR, pdata, size);
}

void st7789v_cmd_ramrd(uint8_t* pdata, uint16_t size)
{
    st7789v_cmd(CMD_RAMRD, 0, 0);
    st7789v_rd(pdata, size);
}

/*void st7789v_test_miso(void)
{
//	uint16_t data_out[8] = {CLR565_WHITE, CLR565_WHITE, CLR565_RED, CLR565_RED, CLR565_GREEN, CLR565_GREEN, CLR565_BLUE, CLR565_BLUE};
	uint8_t data_out[16] = {0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	uint8_t data_in[32];
	memset(data_in, 0, sizeof(data_in));
	st7789v_clr_cs();
	st7789v_cmd_caset(0, ST7789V_COLS - 1);
	st7789v_cmd_raset(0, ST7789V_ROWS - 1);
	st7789v_cmd_ramwr((uint8_t*)data_out, 16);
	st7789v_set_cs();
	st7789v_clr_cs();
	st7789v_cmd_caset(0, ST7789V_COLS - 1);
	st7789v_cmd_raset(0, ST7789V_ROWS - 1);
	st7789v_cmd_ramrd(data_in, 32);
	st7789v_set_cs();
}*/

void st7789v_init_ctl_pins(void)
{
    if (!(st7789v_flg & ST7789V_FLG_SAFE)) {
        gpio_init(st7789v_config.pinCS, GPIO_MODE_OUTPUT_PP, GPIO_NOPULL, GPIO_SPEED_FREQ_HIGH);
        gpio_init(st7789v_config.pinRS, GPIO_MODE_OUTPUT_PP, GPIO_NOPULL, GPIO_SPEED_FREQ_HIGH);
        gpio_init(st7789v_config.pinRST, GPIO_MODE_OUTPUT_PP, GPIO_NOPULL, GPIO_SPEED_FREQ_LOW);
    }
    st7789v_flg &= ~(FLG_CS | FLG_RS | FLG_RST);
    st7789v_set_rst();
    st7789v_set_cs();
    st7789v_set_rs();
}

void st7789v_reset(void)
{
    st7789v_clr_rst();
    st7789v_delay_ms(15);
    st7789v_set_rst();
}

void st7789v_init(void)
{
#ifdef ST7789V_USE_RTOS
    st7789v_task_handle = osThreadGetId();
#endif //ST7789V_USE_RTOS
    if (st7789v_flg & ST7789V_FLG_SAFE)
        st7789v_flg &= ~ST7789V_FLG_DMA;
    else
        st7789v_flg = st7789v_config.flg;
    st7789v_init_ctl_pins(); // CS=H, RS=H, RST=H
    st7789v_reset(); // 15ms reset pulse
    st7789v_delay_ms(120); // 120ms wait
    st7789v_cmd_slpout(); // wakeup
    st7789v_delay_ms(120); // 120ms wait
    st7789v_cmd_madctl(st7789v_config.madctl); // interface pixel format
    st7789v_cmd_colmod(st7789v_config.colmod); // memory data access control
    st7789v_cmd_dispon(); // display on
    st7789v_delay_ms(10); // 10ms wait
}

void st7789v_done(void)
{
}

void st7789v_clear(color_t clr)
{
    int i;
    uint16_t clr565 = _COLOR_565(clr);
    for (i = 0; i < ST7789V_COLS * 16; i++)
        ((uint16_t*)st7789v_buff)[i] = clr565;
    st7789v_clr_cs();
    st7789v_cmd_caset(0, ST7789V_COLS - 1);
    st7789v_cmd_raset(0, ST7789V_ROWS - 1);
    st7789v_cmd_ramwr(0, 0);
    for (i = 0; i < ST7789V_ROWS / 16; i++)
        st7789v_wr(st7789v_buff, 2 * ST7789V_COLS * 16);
    st7789v_set_cs();
    //	st7789v_test_miso();
}

void st7789v_set_pixel(point_ui16_t pt, color_t clr)
{
    if (!point_in_rect_ui16(pt, st7789v_clip))
        return;
    uint16_t clr565 = _COLOR_565(clr);
    st7789v_cmd_caset(pt.x, 1);
    st7789v_cmd_raset(pt.y, 1);
    st7789v_cmd_ramwr((uint8_t*)(&clr565), 2);
}

color_t st7789v_get_pixel(point_ui16_t pt)
{
    if (!point_in_rect_ui16(pt, st7789v_clip))
        return 0;
    uint16_t clr565;
    st7789v_cmd_caset(pt.x, 1);
    st7789v_cmd_raset(pt.y, 1);
    st7789v_cmd_ramrd((uint8_t*)(&clr565), 2);
    return _565_COLOR(clr565);
}

void st7789v_set_pixel_directColor(point_ui16_t pt, uint16_t directColor)
{
    if (!point_in_rect_ui16(pt, st7789v_clip))
        return;
    st7789v_cmd_caset(pt.x, 1);
    st7789v_cmd_raset(pt.y, 1);
    st7789v_cmd_ramwr((uint8_t*)(&directColor), 2);
}

//1 == 0000 0001, 5 == 0001 1111
static uint16_t set_num_of_ones(uint8_t num_of_ones)
{
    return ~((uint16_t)(-1) << num_of_ones);
}

//BYTEs 0 and 1 are empty
//bit0 -> bit5 BYTE2
//bit1 -> bit6 BYTE2
//bit2 -> bit7 BYTE2

//bit3 -> bit3 BYTE4
//bit4 -> bit4 BYTE4
//bit5 -> bit5 BYTE4
//bit6 -> bit6 BYTE4
//bit7 -> bit7 BYTE4

//bit8 -> bit3 BYTE3
//bit9 -> bit4 BYTE3
//bit10-> bit5 BYTE3
//bit11-> bit6 BYTE3
//bit12-> bit7 BYTE3

//bit13-> bit2 BYTE3
//bit14-> bit3 BYTE3
//bit15-> bit4 BYTE2

//since BYTE0 and BYTE1 are empty, buff[0] == BYTE2
static uint16_t rd18bit_to_16bit(uint8_t* buff)
{
    return ((uint16_t)(buff[0] >> 5) & set_num_of_ones(3)) | (((uint16_t)(buff[2] >> 3) & set_num_of_ones(5)) << 3) | (((uint16_t)(buff[1] >> 3) & set_num_of_ones(5)) << 8) | (((uint16_t)(buff[0] >> 2) & set_num_of_ones(3)) << 13);
}

uint16_t st7789v_get_pixel_directColor(point_ui16_t pt)
{
    if (!point_in_rect_ui16(pt, st7789v_clip))
        return 0;
    enum { buff_sz = 5 };
    uint8_t buff[buff_sz];
    st7789v_cmd_caset(pt.x, 1);
    st7789v_cmd_raset(pt.y, 1);
    st7789v_cmd_ramrd(buff, buff_sz);
    uint16_t ret = rd18bit_to_16bit(buff + 2);
    return ret; //directColor;
}

void st7789v_clip_rect(rect_ui16_t rc)
{
    st7789v_clip = rc;
}

void st7789v_draw_line(point_ui16_t pt, point_ui16_t pt1, color_t clr)
{
    int n;
    int dx = pt1.x - pt.x;
    int dy = pt1.y - pt.y;
    int sx = (dx >= 0) ? 1 : -1;
    int sy = (dy >= 0) ? 1 : -1;
    int cx = (sx > 0) ? dx : -dx;
    int cy = (sy > 0) ? dy : -dy;
    dx = cx;
    dy = cy;
    if ((dx == 0) || (dy == 0)) { // orthogonal line
        if (dx) // dy == 0
            st7789v_fill_rect(rect_ui16((sx > 0) ? pt.x : pt1.x, pt.y, dx, 1), clr);
        else // dx == 0
            st7789v_fill_rect(rect_ui16(pt.x, (sy > 0) ? pt.y : pt1.y, 1, dy), clr);
    } else if (dx > dy)
        for (n = dx; n > 0; n--) {
            st7789v_set_pixel(pt, clr);
            if ((cx -= cy) <= 0) {
                pt.y += sy;
                cx += dx;
            }
            pt.x += sx;
        }
    else if (dx < dy)
        for (n = dy; n > 0; n--) {
            st7789v_set_pixel(pt, clr);
            if ((cy -= cx) <= 0) {
                pt.x += sx;
                cy += dy;
            }
            pt.y += sy;
        }
    else //dx == dy
        for (n = dx; n > 0; n--) {
            st7789v_set_pixel(pt, clr);
            pt.x += sx;
            pt.y += sy;
        }
}

void st7789v_draw_rect(rect_ui16_t rc, color_t clr)
{
    point_ui16_t pt = { rc.x, rc.y };
    point_ui16_t pt1 = { rc.x + rc.w - 1, rc.y };
    point_ui16_t pt2 = { rc.x + rc.w - 1, rc.y + rc.h - 1 };
    point_ui16_t pt3 = { rc.x, rc.y + rc.h - 1 };
    st7789v_draw_line(pt, pt1, clr);
    st7789v_draw_line(pt1, pt2, clr);
    st7789v_draw_line(pt2, pt3, clr);
    st7789v_draw_line(pt3, pt, clr);
}

void st7789v_fill_rect(rect_ui16_t rc, color_t clr)
{
    rc = rect_intersect_ui16(rc, st7789v_clip);
    if (rect_empty_ui16(rc))
        return;
    int i;
    uint16_t clr565 = _COLOR_565(clr);
    uint32_t size = (uint32_t)rc.w * rc.h * 2;
    int n = size / sizeof(st7789v_buff);
    int s = size % sizeof(st7789v_buff);
    if (n)
        st7789v_fill_ui16((uint16_t*)st7789v_buff, clr565, sizeof(st7789v_buff) / 2);
    else
        st7789v_fill_ui16((uint16_t*)st7789v_buff, clr565, size / 2);
    st7789v_clr_cs();
    st7789v_cmd_caset(rc.x, rc.x + rc.w - 1);
    st7789v_cmd_raset(rc.y, rc.y + rc.h - 1);
    st7789v_cmd_ramwr(0, 0);
    for (i = 0; i < n; i++)
        st7789v_wr(st7789v_buff, sizeof(st7789v_buff));
    if (s)
        st7789v_wr(st7789v_buff, s);
    st7789v_set_cs();
}

void st7789v_draw_char(point_ui16_t pt, char chr, font_t* pf, color_t clr0, color_t clr1)
{
    int i;
    int j;
    uint8_t* pch; //character data pointer
    uint8_t crd = 0; //current row byte data
    uint8_t rb; //row byte
    uint16_t w = pf->w; //cache width
    uint16_t h = pf->h; //..
    uint8_t bpr = pf->bpr; //bytes per row
    uint16_t bpc = bpr * h; //bytes per char
    uint8_t bpp = 8 * bpr / w; //bits per pixel
    uint8_t ppb = 8 / bpp; //pixels per byte
    uint8_t pms = (1 << bpp) - 1; //pixel mask
    uint16_t* p = (uint16_t*)st7789v_buff;
    uint8_t* pc;
    if ((chr >= pf->asc_min) && (chr <= pf->asc_max)) {
        pch = (pf->pcs) + ((chr - pf->asc_min) * bpc);
        uint16_t clr565[16];
        for (i = 0; i <= pms; i++)
            clr565[i] = _COLOR_565(color_alpha(clr0, clr1, 255 * i / pms));
        for (j = 0; j < h; j++) {
            pc = pch + j * bpr;
            for (i = 0; i < w; i++) {
                if ((i % ppb) == 0) {
                    if (pf->flg & FONT_FLG_SWAP) {
                        rb = (i / ppb) ^ 1;
                        crd = pch[rb + j * bpr];
                    } else
                        crd = *(pc++);
                }
                if (pf->flg & FONT_FLG_LSBF) {
                    *(p++) = clr565[crd & pms];
                    crd >>= bpp;
                } else {
                    *(p++) = clr565[crd >> (8 - bpp)];
                    crd <<= bpp;
                }
            }
        }
        st7789v_clr_cs();
        st7789v_cmd_caset(pt.x, pt.x + w - 1);
        st7789v_cmd_raset(pt.y, pt.y + h - 1);
        st7789v_cmd_ramwr(st7789v_buff, 2 * w * h);
        st7789v_set_cs();
    } else
        display->fill_rect(rect_ui16(pt.x, pt.y, w, h), clr0);
}

void st7789v_draw_text(rect_ui16_t rc, const char* str, font_t* pf, color_t clr0, color_t clr1)
{
    int i;
    int len = strlen(str);
    int x = rc.x;
    int y = rc.y;
    for (i = 0; i < len; i++) {
        char c = str[i];
        if (c == '\n') {
            y += pf->h;
            x = rc.x;
            if ((y + pf->h) > (rc.y + rc.h))
                break;
        } else {
            st7789v_draw_char(point_ui16(x, y), c, pf, clr0, clr1);
            x += pf->w;
            if ((x + pf->w) > (rc.x + rc.w))
                break;
        }
    }
}

static inline void rop_rgb888_invert(uint8_t* ppx888)
{
    uint8_t r = ppx888[0];
    uint8_t g = ppx888[1];
    uint8_t b = ppx888[2];
    ppx888[0] = 255 - r;
    ppx888[1] = 255 - g;
    ppx888[2] = 255 - b;
}

#define SWAPBW_TOLERANCE 64
static inline void rop_rgb888_swapbw(uint8_t* ppx888)
{
    uint8_t r = ppx888[0];
    uint8_t g = ppx888[1];
    uint8_t b = ppx888[2];
    uint8_t l = (r + g + b) / 3;
    uint8_t l0 = (l >= SWAPBW_TOLERANCE) ? (l - SWAPBW_TOLERANCE) : 0;
    uint8_t l1 = (l <= (255 - SWAPBW_TOLERANCE)) ? (l + SWAPBW_TOLERANCE) : 255;
    if ((l0 <= r) && (r <= l1) && (l0 <= g) && (g <= l1) && (l0 <= b) && (b <= l1)) {
        ppx888[0] = 255 - r;
        ppx888[1] = 255 - g;
        ppx888[2] = 255 - b;
    }
}

static inline void rop_rgb888_disabled(uint8_t* ppx888)
{
    uint8_t r = ppx888[0];
    uint8_t g = ppx888[1];
    uint8_t b = ppx888[2];
    uint8_t l = (r + g + b) / 3;
    uint8_t l0 = (l >= SWAPBW_TOLERANCE) ? (l - SWAPBW_TOLERANCE) : 0;
    uint8_t l1 = (l <= (255 - SWAPBW_TOLERANCE)) ? (l + SWAPBW_TOLERANCE) : 255;
    if ((l0 <= r) && (r <= l1) && (l0 <= g) && (g <= l1) && (l0 <= b) && (b <= l1)) {
        ppx888[0] = r / 2;
        ppx888[1] = g / 2;
        ppx888[2] = b / 2;
    }
}

static inline void rop_rgb8888_swapbw(uint8_t* ppx)
{
    uint8_t r = ppx[0];
    uint8_t g = ppx[1];
    uint8_t b = ppx[2];
    uint8_t a = ppx[3];
    if ((r == g) && (g == b)) {
        ppx[0] = 255 - r;
        ppx[1] = 255 - g;
        ppx[2] = 255 - b;
        if (/*(r < 32) && */ (a < 128)) {
            ppx[0] = 0;
            ppx[1] = 0;
            ppx[2] = 255;
            ppx[3] = 255;
        }
    } else if ((a < 128)) {
        ppx[0] = 0;
        ppx[1] = 255;
        ppx[2] = 0;
        ppx[3] = 255;
    }
}

void st7789v_draw_png_ex(point_ui16_t pt, FILE* pf, color_t clr0, uint8_t rop);

void st7789v_draw_icon(point_ui16_t pt, uint16_t id_res, color_t clr0, uint8_t rop)
{
    FILE* pf = resource_fopen(id_res, "rb");
    st7789v_draw_png_ex(pt, pf, clr0, rop);
    fclose(pf);
}

#ifdef ST7789V_PNG_SUPPORT

#include <png.h>

void* png_mem_ptr0 = 0;
uint32_t png_mem_total = 0;
void* png_mem_ptrs[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint32_t png_mem_sizes[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint32_t png_mem_cnt = 0;

png_voidp _pngmalloc(png_structp pp, png_alloc_size_t size)
{
    //	return malloc(size);
    //	return pvPortMalloc(size);
    if (png_mem_ptr0 == 0)
        //png_mem_ptr0 = pvPortMalloc(0xc000); //48k
        png_mem_ptr0 = (void*)0x10000000; //ccram
    int i;
    void* p = ((uint8_t*)png_mem_ptr0) + png_mem_total;
    //	if (p == 0)
    //		while (1);
    //	else
    {
        for (i = 0; i < 10; i++)
            if (png_mem_ptrs[i] == 0)
                break;
        png_mem_ptrs[i] = p;
        png_mem_sizes[i] = size;
        png_mem_total += size;
        png_mem_cnt++;
    }
    return p;
}

void _pngfree(png_structp pp, png_voidp mem)
{
    //	free(mem);
    int i;

    for (i = 0; i < 10; i++)
        if (mem == png_mem_ptrs[i]) {
            uint32_t size = png_mem_sizes[i];
            png_mem_ptrs[i] = 0;
            png_mem_sizes[i] = 0;
            png_mem_total -= size;
            png_mem_cnt--;
        }
    //	vPortFree(mem);
}

void st7789v_draw_png_ex(point_ui16_t pt, FILE* pf, color_t clr0, uint8_t rop)
{
    //	rewind(pf);
    //png_structp pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    png_structp pp = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL, NULL, _pngmalloc, _pngfree);
    //png_set_mem_fn(pp, 0, _pngmalloc, _pngfree);
    if (pp == NULL)
        goto _e_0;
    png_infop ppi = png_create_info_struct(pp);
    if (ppi == NULL)
        goto _e_1;
    if (setjmp(png_jmpbuf(pp)))
        goto _e_1;
    png_init_io(pp, pf);
    {
        uint8_t sig[8];
        if (fread(sig, 1, 8, pf) < 8)
            goto _e_1;
        if (!png_check_sig(sig, 8))
            goto _e_1; /* bad signature */
        png_set_sig_bytes(pp, 8);
    }
    png_read_info(pp, ppi);
    uint16_t w = png_get_image_width(pp, ppi);
    uint16_t h = png_get_image_height(pp, ppi);
    int rowsize = png_get_rowbytes(pp, ppi);
    //_dbg("st7789v_draw_png rowsize = %i", rowsize);
    if (rowsize > ST7789V_COLS * 4)
        goto _e_1;
    int pixsize = rowsize / w;
    //_dbg("st7789v_draw_png pixsize = %i", pixsize);
    int i;
    int j;
    st7789v_clr_cs();
    if (setjmp(png_jmpbuf(pp)))
        goto _e_2;
    st7789v_cmd_caset(pt.x, pt.x + w - 1);
    st7789v_cmd_raset(pt.y, pt.y + h - 1);
    st7789v_cmd_ramwr(0, 0);
    switch (rop) {
        //case ROPFN_INVERT: rop_rgb888_invert((uint8_t*)&clr0); break;
        //case ROPFN_SWAPBW: rop_rgb888_swapbw((uint8_t*)&clr0); break;
    }
    for (i = 0; i < h; i++) {
        png_read_row(pp, st7789v_buff, NULL);
        if (pixsize == 3) //RGB
            for (j = 0; j < w; j++) {
                uint16_t* ppx565 = (uint16_t*)(st7789v_buff + j * 2);
                uint8_t* ppx888 = (uint8_t*)(st7789v_buff + j * pixsize);
                switch (rop) {
                case ROPFN_INVERT:
                    rop_rgb888_invert(ppx888);
                    break;
                case ROPFN_SWAPBW:
                    rop_rgb888_swapbw(ppx888);
                    break;
                case ROPFN_DISABLE:
                    rop_rgb888_disabled(ppx888);
                    break;
                }
                *ppx565 = _COLOR_565(color_rgb(ppx888[0], ppx888[1], ppx888[2]));
            }
        else if (pixsize == 4) //RGBA
        {
            for (j = 0; j < w; j++) {
                uint16_t* ppx565 = (uint16_t*)(st7789v_buff + j * 2);
                uint8_t* ppx888 = (uint8_t*)(st7789v_buff + j * pixsize);
                *((color_t*)ppx888) = color_alpha(clr0, color_rgb(ppx888[0], ppx888[1], ppx888[2]), ppx888[3]);
                switch (rop) {
                case ROPFN_INVERT:
                    rop_rgb888_invert(ppx888);
                    break;
                case ROPFN_SWAPBW:
                    rop_rgb888_swapbw(ppx888);
                    break;
                case ROPFN_DISABLE:
                    rop_rgb888_disabled(ppx888);
                    break;
                }
                //*ppx565 = _COLOR_565(color_alpha(clr0, color_rgb(ppx888[0], ppx888[1], ppx888[2]), ppx888[3]));
                *ppx565 = _COLOR_565(color_rgb(ppx888[0], ppx888[1], ppx888[2]));
            }
        }
        st7789v_wr(st7789v_buff, 2 * w);
    }
_e_2:
    st7789v_set_cs();
_e_1:
    png_destroy_read_struct(&pp, &ppi, 0);
_e_0:
    return;
}

void st7789v_draw_png(point_ui16_t pt, FILE* pf)
{
    st7789v_draw_png_ex(pt, pf, 0, 0);
}

void st7789v_inversion_on(void)
{
    st7789v_config.is_inverted = 1;
    st7789v_cmd(CMD_INVON, 0, 0);
}
void st7789v_inversion_off(void)
{
    st7789v_config.is_inverted = 0;
    st7789v_cmd(CMD_INVOFF, 0, 0);
}

void st7789v_inversion_tgl(void)
{
#if CMD_INVON == CMD_INVOFF + 1
    //faster code if CMD_INVON == CMD_INVOFF + 1
    //The result of the logical negation operator ! is 1 if the value of its operand is 0,
    //0 if the value of its operand is non-zero.
    st7789v_config.is_inverted = !st7789v_inversion_get();
    st7789v_cmd(CMD_INVOFF + st7789v_config.is_inverted, 0, 0);
#else
    //to be portable
    if (st7789v_inversion_get())
        st7789v_inversion_off();
    else
        st7789v_inversion_on();

#endif
}
uint8_t st7789v_inversion_get(void)
{
    return st7789v_config.is_inverted;
}

//0x01 -> 0x02 -> 0x04 -> 0x08 -> 0x01
void st7789v_gamma_next(void)
{
    st7789v_gamma_set_direct(((st7789v_config.gamma << 1) | (st7789v_config.gamma >> 3)) & 0x0f);
}

//0x01 -> 0x08 -> 0x04 -> 0x02 -> 0x01
void st7789v_gamma_prev(void)
{
    st7789v_gamma_set_direct(((st7789v_config.gamma << 3) | (st7789v_config.gamma >> 1)) & 0x0f);
}

//use GAMMA_CURVE0 - GAMMA_CURVE3
void st7789v_gamma_set_direct(uint8_t gamma_enu)
{
    st7789v_config.gamma = gamma_enu;
    st7789v_cmd(CMD_GAMMA_SET, &st7789v_config.gamma, sizeof(st7789v_config.gamma));
}

//use 0 - 3
void st7789v_gamma_set(uint8_t gamma)
{
    if (gamma != st7789v_gamma_get())
        st7789v_gamma_set_direct(1 << (gamma & 0x03));
}

//returns 0 - 3
uint8_t st7789v_gamma_get()
{
    uint8_t position = 0;
    for (int8_t position = 3; position >= 0; --position) {
        if (st7789v_config.gamma == 1 << position)
            break;
    }

    return position;
}

void st7789v_brightness_enable(void)
{
    st7789v_ctrl_set(st7789v_config.control | MASK_CTRLD_BCTRL);
}

void st7789v_brightness_disable(void)
{
    st7789v_ctrl_set(st7789v_config.control & (~MASK_CTRLD_BCTRL));
}

void st7789v_brightness_set(uint8_t brightness)
{
    st7789v_config.brightness = brightness;
    //set brightness
    st7789v_cmd(CMD_WRDISBV, &st7789v_config.brightness, sizeof(st7789v_config.brightness));
}

uint8_t st7789v_brightness_get(void)
{
    return st7789v_config.brightness;
}

void st7789v_ctrl_set(uint8_t ctrl)
{
    st7789v_config.control = ctrl;
    st7789v_cmd(CMD_WRCTRLD, &st7789v_config.control, sizeof(st7789v_config.control));
}

#else //ST7789V_PNG_SUPPORT

void st7789v_draw_png(point_ui16_t pt, FILE* pf)
{
}

void st7789v_draw_png_ex(point_ui16_t pt, FILE* pf, color_t clr0, uint8_t rop) {}

#endif //ST7789V_PNG_SUPPORT

const display_t st7789v_display = {
    ST7789V_COLS,
    ST7789V_ROWS,
    st7789v_init,
    st7789v_done,
    st7789v_clear,
    st7789v_set_pixel,
    st7789v_draw_line,
    st7789v_draw_rect,
    st7789v_fill_rect,
    st7789v_draw_char,
    st7789v_draw_text,
    st7789v_draw_icon,
    st7789v_draw_png,
};

st7789v_config_t st7789v_config = {
    0, // spi handle pointer
    0, // CS pin
    0, // RS pin
    0, // RST pin
    0, // flags (DMA, MISO)
    0, // interface pixel format (5-6-5, hi-color)
    0, // memory data access control (no mirror XY)
    GAMMA_CURVE0, // gamma curve
    0, // brightness
    0, // inverted
    0, // default control reg value
};

//! @brief enable safe mode (direct acces + safe delay)
void st7789v_enable_safe_mode(void)
{
    st7789v_flg |= ST7789V_FLG_SAFE;
}

void st7789v_spi_tx_complete(void)
{
#ifdef ST7789V_USE_RTOS
    osSignalSet(st7789v_task_handle, ST7789V_SIG_SPI_TX);
#endif //ST7789V_USE_RTOS
}