ili9341.c

Go to the documentation of this file.

#include "user_config.h"

#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>

#include "display/font.h"
#include "display/ili9341.h"
#include "3rd_party/ili9341_adafruit.h"

// TFT master window definition
window tftwin;
window *tft = &tftwin;


void tft_Cmd(uint8_t cmd)
{
    tft_spi_TX(&cmd, 1, 1);
}

uint8_t tft_Data(uint8_t data)
{
    tft_spi_TXRX(&data, 1, 0);
    return(data);
}

void tft_Cmd_Data_TX(uint8_t cmd, uint8_t * data, int bytes)
{
// Do not change Command/Data control until SPI bus clear
    tft_spi_begin();

    tft_Cmd(cmd);

// Read result
    if (bytes > 0)
    {
        tft_spi_TX(data,bytes,0);
    }

    tft_spi_end();
}



int32_t tft_abs_window(window *win, int16_t x, int16_t y, int16_t w, int16_t h)
{
    uint8_t tmp[4];

    int16_t xl,yl;
    int32_t bytes;

    // FIXME do we want to return or use the constrained values ????
    if(tft_window_clip_args(win,&x,&y,&w,&h) )
        return(0);

    // Now We know the result will fit
    xl = x + w - 1;
    tmp[0] = x >> 8;
    tmp[1] = x & 0xff;
    tmp[2] = xl >> 8;
    tmp[3] = xl & 0xff;
    tft_Cmd_Data_TX(0x2A, tmp, 4);

    yl = y + h - 1;
    tmp[0] = y >> 8;
    tmp[1] = y & 0xff;
    tmp[2] = yl >> 8;
    tmp[3] = yl & 0xff;
    tft_Cmd_Data_TX(0x2B, tmp, 4);

    bytes = w;
    bytes *= h;
    return( bytes);
}

int32_t tft_rel_window(window *win, int16_t x, int16_t y, int16_t w, int16_t h)
{
    // function tft_abs_window clips
    return( tft_abs_window(win,x+win->x, y+win->y, w,h) );
}




MEMSPACE
uint32_t tft_readRegister(uint8_t command, uint8_t parameter)
{
    uint32_t result;

    tft_spi_begin();

    // Send Undocumented ILI9341 0xd9 as COMMAND
    tft_Cmd(0xd9);

    // We do not know what the 0x10 offset implies, undocumented, but is required.
    // Send ILI9341 parameter as DATA
    tft_Data(0x10 + parameter);

    // The real ILI9341 Command whose parameters we want to read
    // Send ILI9341 command as COMMAND
    tft_Cmd(command);

    // Read Result
    result=tft_Data(0);

    tft_spi_end();


#if ILI9341_DEBUG & 1
ets_uart_printf("cmd:%02x, par:%02x, read: %02x\n",
    0xff & command, 
    0xff & parameter, 
    0xff & result);
#endif

    return (result);
}


MEMSPACE
uint32_t tft_readId(void)
{
    uint32_t_bytes id;


    id.all = 0;
    id.bytes.b2 = tft_readRegister(0xd3, 1);    // Parameter 1
    id.bytes.b1 = tft_readRegister(0xd3, 2);    // Parameter 2
    id.bytes.b0 = tft_readRegister(0xd3, 3);    // Parameter 3

    return  id.all;
}



void tft_bit_blit(window *win, uint8_t *ptr, int16_t x, int16_t y, int16_t w, int16_t h)
{

    uint16_t color;
    int xx,yy;
    int32_t off;
    int32_t pixels;
    int wdcount;
    int ind;
    uint8_t buf[2*64];

    // FIXME - do we just want to constrain the values or ignore the request ???
    if ( tft_window_clip_args(tft,&x,&y,&w,&h) )
        return;

    if(!w || !h)
        return;

#if 1
// BIT BLIT

    pixels = tft_rel_window(win, x, y, w, h);
    if(pixels == 0)
        return;

// FIXME now we should consider clipping the pixel array
// Note: Clipping modifies offsets which in turn modifies blit array offsets
// We could use tft_drawPixel, and it clips - but that the pixel function is very slow
// For now we clip the arguments and use tft_rel_windows which also clips

    
    tft_spi_begin();

    tft_Cmd(0x2c);

    off = 0;
    ind = 0;
    wdcount = 0;

    for (yy=0; yy < h; ++yy)
    {
        for (xx=0;xx < w; ++xx)
        {
            if(bittestv(ptr, xx + off))
                color = win->fg;
            else
                color = win->bg;

            buf[ind++] = color >> 8;
            buf[ind++] = color & 0xff;

            if(ind >= sizeof(buf))
            {
                tft_spi_TX(buf,ind,0);
                ind = 0;
            }
        }
        wdcount += xx;
        if(wdcount > 0x3ff)
        {
            optimistic_yield(1000);
            //ets_wdt_disable();
            wdcount = 0;
        }
        off += w;
    }
    if(ind)
    {
        tft_spi_TX(buf,ind,0);
    }

    tft_spi_end();
#else
    off = 0;
    for (yy=0; yy < h; ++yy)
    {
        for (xx=0;xx < w; ++xx)
        {
            if(bittestv(ptr, xx + off))
                tft_drawPixel(win,x+xx,y+yy,fg);
            else
                tft_drawPixel(win,x+xx,y+yy,bg);
        }
        off += w;
    }
#endif
}

// =============================================================
// =============================================================




void tft_fillWin(window *win, uint16_t color)
{
    // tft_fillRectWH() clips
    tft_fillRectWH(win, 0,0, win->w, win->h, color);
}

void tft_flood(window *win, int16_t x, int16_t y, uint16_t border, uint16_t fill)
{
    uint16_t current;

    if(x < 0 || x >= win->w)
        return;
    if(y < 0 || y >= win->h)
        return;

    current = tft_readPixel(win,x,y);
    if(current == border || current == fill)
        return;

    tft_drawPixel(win,x,y,fill);
    tft_flood(win,x+1,y,border,fill);
    tft_flood(win,x,y+1,border,fill);
    tft_flood(win,x-1,y,border,fill);
    tft_flood(win,x,y-1,border,fill);
}



#define XYSTACK 64
static struct {
    int16_t x[XYSTACK+2];
    int16_t y[XYSTACK+2];
    int ind;
} xy;

int tft_push_xy(int16_t x, int16_t y)
{
    if(xy.ind >= XYSTACK)
    {
        printf("xy.ind stack >= %d\n",XYSTACK);
        return(0);
    }
    xy.x[xy.ind] = x;
    xy.y[xy.ind] = y;
    xy.ind++;
    return(1);
}

int tft_pop_xy(int16_t *x, int16_t *y)
{
    if(xy.ind <= 0)
        return(0);
    xy.ind--;
    *x = xy.x[xy.ind];
    *y = xy.y[xy.ind];
    return(1);
}

int tft_floodline(window *win, int16_t x, int16_t y, uint16_t border, uint16_t fill)
{
    int lineAbove, lineBelow;
    int16_t  xoff;
    int count = 0;

    // reset stack
    xy.ind = 0;

    if(x < 0 || x >= win->w)
    {
        printf("tft_floodline: X out of range\n");
        return(0);
    }
    if(y < 0 || y >= win->h)
    {
        printf("tft_floodline: Y out of range\n");
        return(0);
    }

    // test for stack full
    if(!tft_push_xy(x, y)) 
        return(0);

    // while we have stacked items
    // FIXME we can bypass readpixel - read any entire line interruped by the color check
    while(tft_pop_xy((int16_t *)&x, (int16_t *)&y))
    {
        if(x < 0 || x >= win->w)
        {
            printf("tft_floodline: X out of range\n");
            return(0);
        }
        if(y < 0 || y >= win->h)
        {
            printf("tft_floodline: Y out of range\n");
            return(0);
        }
        xoff = x;
        while(xoff >= 0 && tft_readPixel(win,xoff,y) != border ) 
            xoff--;
        xoff++;

        lineAbove = lineBelow = 0;

        while(xoff < win->w && tft_readPixel(win,xoff,y) != border)
        {
            tft_drawPixel(win,xoff,y,fill);
            if(++count >= 1000)
            {
                optimistic_yield(1000);
                count = 0;
            }


            if(!lineAbove && y > 0 && tft_readPixel(win,xoff,y-1) != border)
            {
                // test for stack full
                if(!tft_push_xy(xoff, y - 1)) 
                    return(0);
                lineAbove = 1;
            }
            else if(lineAbove && y > 0 && tft_readPixel(win,xoff,y-1) == border )
            {
                lineAbove = 0;
            }
            if(!lineBelow && y < (win->h-1) && tft_readPixel(win,xoff,y+1) != border )
            {
                // test for stack full
                if(!tft_push_xy(xoff, y + 1)) 
                    return(0);
                lineBelow = 1;
            }
            else if(lineBelow && y < (win->h-1) && tft_readPixel(win,xoff,y+1) == border)
            {
                lineBelow = 0;
            }
            xoff++;
        }
    }
    return(1);
}


#define MAXVEC 24
int tft_FillPolyLine(window *win, int16_t x, int16_t y, int w, uint16_t color)
{
    uint8_t data[3];
    uint16_t val;
    int pixels;
    int ind,state;
    int inside;
    int count;
    int16_t vec[MAXVEC+2];


    // tft_rel_window() clips
    pixels = tft_rel_window(win, x,y,w,1);
    if(!pixels)
        return(0);
    if(pixels != w)
    {
            printf("FillPoly: w(%d) != pixels(%d)\n", (int) w, pixels);
    }

    // scan
    tft_spi_begin();
    tft_Cmd(0x2e);  // Memory Read
    tft_Cmd(0); // NOP

    state = 0;
    ind = 0;
    inside = 0;
    while(pixels > 0)
    {
        data[0] = 0;
        data[1] = 0;
        data[2] = 0;
        tft_spi_RX(data, 3,1);
        val = tft_RGBto565(data[0],data[1],data[2]);

            switch(state)
            {
                case 0:
                    /* match state */
                    if(val == color)
                    {
                        /* go to wait for unmatched state */
                        state = 1;
                        ++inside;
                    }
                    break;
                case 1: 
                    /* wait for unmatched state */
                    /* match to unmatch state */
                    if(val != color)
                    {
                        if(inside & 1)
                        {
                            // Save offset of start of unset transition 
                            if(ind < MAXVEC)
                                vec[ind++] = x;
                        }
                        /* go to wait for matched state */
                        state = 2;
                    }

                    break;
                case 2:
                    /* unmatch to match */
                    /* wait for matched state */
                    if(val == color)
                    {
                        if(inside & 1)
                        {
                            // Save offset of LAST unmatched state
                            if(ind < MAXVEC)
                                vec[ind++] = x-1;
                        }
                        /* go to wait for unmatched state */
                        ++inside;
                        state = 1;
                        
                    }
                    break;
            }
        ++x;
        --pixels;
    }
    tft_spi_end();

    count = ind;
    if(count >= 2)
    {
#if 1
        int j;
        printf("count[%d] @ line %d\n", count, y);
        for(j=0;j<ind;++j)
            printf("%d \n", (int)vec[j]);
        printf("\n");
#endif
        ind = 0;
        while(count >= 2)
        {
            // tft_drawLine ( win , vec[ind], y, vec[ind+1], y, color );
            tft_drawFastHLine ( win , vec[ind], y, vec[ind+1]-vec[ind]+1, color );
            count -= 2;
            ind += 2;
        }
    }
    return(ind);
}

void tft_fillRectWH(window *win, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color)
{
    int32_t pixels;
    int32_t colors;
    int wdcount;
    int ind;
    uint8_t buf[2*64];

    // tft_rel_window clips
    pixels = tft_rel_window(win, x,y,w,h);
    if(!pixels)
        return;

    wdcount = 0;

    if(pixels > 0)
    {
        tft_spi_begin();

        tft_Cmd(0x2c);

        ind = 0;
        //We are sending words
        while(pixels > 0)
        {
            colors = pixels;
            if(colors > sizeof(buf)/2)
                colors = sizeof(buf)/2;

            pixels -= colors;
            wdcount += colors;

            if(!ind)
            {
                while(ind < sizeof(buf) && ind < colors*2)
                {
                    buf[ind++] = color >> 8;
                    buf[ind++] = color & 0xff;
                }
            }
            tft_spi_TX(buf,colors*2,0);
            if(wdcount > 0x3ff)
            {
                wdcount = 0;
                optimistic_yield(1000);
                // ets_wdt_disable();
            }
        }

        tft_spi_end();
    } // if(pixels > 0)

}

void tft_fillRectXY(window *win, int16_t x, int16_t y, int16_t xl, int16_t yl, uint16_t color)
{
    uint32_t repeat;
    int16_t w,h;

    if(x > xl)
        SWAP(x,xl);
    if(y > yl)
        SWAP(y,yl);

    w = xl - x + 1;
    h = yl - y + 1;
    // tft_fillRectWH() clips
    tft_fillRectWH(win, x, y, w, h, color);
}


void tft_drawPixel(window *win, int16_t x, int16_t y, int16_t color)
{
    uint8_t data[2];

// Clip pixel
    if(x < 0 || x >= win->w)
        return;
    if(y < 0 || y >= win->h)
        return;

    // tft_rel_window() clips
    if(! tft_rel_window(win, x,y,1,1))
        return;

    data[0] = color >>8;
    data[1] = color;
    tft_Cmd_Data_TX(0x2c, data, 2);

}

void tft_writeRect(window *win, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t *color)
{

    int32_t pixels;
    uint16_t pixel;
    int wdcount;
    int xx,yy;
    int ind;
    uint8_t buf[2*64];

    if(!w || !h)
        return;

// TODO CLIP window data - depends on blit array offset also
// We could use tft_drawPixel, and it clips - but that is slow

#if 1
    // tft_rel_window() clips limits
    pixels = tft_rel_window(win, x, y, w, h);
    if(!pixels)
        return;

    tft_spi_begin();

    tft_Cmd(0x2c);

    ind = 0;
    wdcount = 0;

    while(pixels-- > 0)
    {
        pixel = *color++;
        buf[ind++]=pixel >> 8;
        buf[ind++]=pixel & 0xff;
        if(ind >= sizeof(buf))
        {
            tft_spi_TX(buf,ind,0);
            wdcount += ind;
            ind = 0;
            if(wdcount > 0x3ff)
            {
                wdcount = 0;
                optimistic_yield(1000);
                //ets_wdt_disable();
            }
        }
    }

    if(ind)
    {
        tft_spi_TX(buf,ind,0);
    }

    tft_spi_end();

#else
    wdcount = 0;
    for (yy=0; yy < h; ++yy)
    {
        for (xx=0;xx < w; ++xx)
        {
            tft_drawPixel(win, x+xx,y+yy,*ptr++);
        }
        wdcount += w;
        if(wdcount >= 0x3ff)
        {
            wdcount = 0;
            optimistic_yield(1000);
            // ets_wdt_disable();
        }
    }
#endif
}



#define HSPI_PIX ((HSPI_FIFO_SIZE-2)/3)

void tft_readRect(window *win, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t *color)
{
    int32_t pixels;
    int wdcount;
    int rem;
    uint8_t cmd;
    uint8_t *ptr;
    // Command and Pixel buffer
    uint8_t data[64*3];

    // tft_rel_window() clips
    pixels = tft_rel_window(win, x,y,w,h);
    if(!pixels)
        return;

    cmd = 0x2e; // Memory Read

    wdcount = 0;
    while(pixels > 0)
    {
        tft_spi_begin();

        tft_Cmd(cmd);
        tft_Cmd(0); // NOP

        if(pixels > sizeof(data)/3)
            rem = sizeof(data)/3;
        else
            rem = pixels;

        pixels -= rem;

        wdcount += rem;

        // Send/Receive
        // Read 3 byte pixel data
        tft_spi_RX(data, rem*3,1);

        tft_spi_end();

        // Now reconvert 3 byte color data into 2 byte color data
        ptr = data;
        while(rem--)
        {
            // reuse the color buffer
            // overwrite the 3 byte/pixel with 2 byte/pixle only data
            *color++ = tft_RGBto565(ptr[0],ptr[1],ptr[2]);
            ptr += 3;
        }
        cmd = 0x3e; // Memory Read Continue

        if(wdcount >= 0x3ff)
        {
            optimistic_yield(1000);
            // ets_wdt_disable();
            wdcount = 0;
        }
    }
}

void tft_Vscroll(window *win, int dir)
{
    int i;
    int yfrom,yto;
    uint8_t buff[TFT_W*3];

    // FIXME unsupported
    // + == normal scroll - start at the top move down
    // 0 == nothing to do
    // - == reverse scroll - start at the bottom and move up
    if(dir <= 0)
        return;

    if(dir >= win->h)
    {
        // clear area that is vacated
        tft_fillRectWH(win, 0, 0, win->w, win->h, win->bg);
        return;
    }
    for(i=0; i < win->h;++i)
    {
        // source of scroll
        yfrom= i+dir;
        // target of scroll
        yto = i;

        if(yfrom >= (win->h-1))
        {
            // Clear to of window
            tft_fillRectWH(win, 0, yto, win->w, 1, win->bg);
        }
        else
        {
            // TOP
            tft_readRect(win, 0, yfrom, win->w, 1, (uint16_t *) buff);
            // DOWN
            tft_writeRect(win, 0, yto, win->w, 1, (uint16_t *)buff);
        }
    }
}

uint16_t tft_readPixel(window *win, int16_t x, int16_t y)
{
    uint8_t data[3];
    uint16_t color;

    // set window, also clips
    if(!tft_rel_window(win, x,y,1,1))
        return(0);

    tft_spi_begin();
    
    tft_Cmd(0x2e);
    tft_Cmd(0);     // NOP
    tft_spi_RX(data, 3, 1);

    tft_spi_end();
    
    color = tft_RGBto565(data[0],data[1],data[2]);
    return(color);
}



MEMSPACE
void tft_setRotation(uint8_t m)
{

    uint8_t data;
    tft->rotation = m & 3; // can't be higher than 3
    data = MADCTL_BGR;
    switch (tft->rotation)
    {
        case 0:
            data        |=  MADCTL_MX;
            tft->w  =   TFT_W;
            tft->x =    TFT_XOFF;
            tft->h  =   TFT_H;
            tft->y =    TFT_YOFF;
            break;
        case 1:
            data        |=  MADCTL_MV;
            tft->w  =   TFT_H;
            tft->x  =   TFT_YOFF;
            tft->h  =   TFT_W;
            tft->y  =   TFT_XOFF;
            break;
        case 2:
            data        |=  MADCTL_MY;
            tft->w  =   TFT_W;
            tft->x  =   TFT_XOFF;
            tft->h  =   TFT_H;
            tft->y =    TFT_YOFF;
            break;
        case 3:
            data = MADCTL_MX | MADCTL_MY | MADCTL_MV;
            tft->w  =   TFT_H;
            tft->x =    TFT_YOFF;
            tft->h  =   TFT_W;
            tft->y =    TFT_XOFF;
            break;
    }

    tft_Cmd_Data_TX(ILI9341_MADCTL, &data, 1);
}


void tft_565toRGB(uint16_t color, uint8_t *r, uint8_t *g, uint8_t *b)
{
    *r = ((0xf800 & color)>>8);
    *g = ((0x7e0 & color)>>3);
    *b = (0x1f & color) << 3;
}


MEMSPACE
void tft_invertDisplay(int flag)
{
    uint8_t cmd = flag ? ILI9341_INVON : ILI9341_INVOFF;

    tft_spi_begin();
    tft_Cmd(cmd);
    tft_spi_end();
}

MEMSPACE
int tft_window_clip(window *win)
{
    int clipped = 0;

    // Clip X
    if(win->x < tft->x)
    {
        win->x = tft->x;
        clipped++;
    }
    if(win->x > (tft->x + tft->w - 1))
    {
        win->x = (tft->x + tft->w - 1);
        clipped++;
    }

    // CLIP X,Y first
    // CLIP Y
    if(win->y < tft->y)
    {
        win->y = tft->y;
        clipped++;
    }
    if(win->y > (tft->y + tft->h - 1))
    {
        win->y = (tft->y + tft->h - 1);
        clipped++;
    }


    // CLIP W,H last
    // CLIP W
    if( (win->x + win->w - 1 ) > (tft->x + tft->w - 1) )
    {
        win->w = (tft->x + tft->w ) - win->x;
        clipped++;
    }

    // CLIP H
    if( (win->y + win->h - 1 ) > (tft->y + tft->h - 1) )
    {
        win->h = (tft->y + tft->h ) - win->y;
        clipped++;
    }
    return(clipped);
}

MEMSPACE
void tft_clip_xy(window *win, int16_t *X, int16_t *Y)
{

    int16_t X1 = *X;
    int16_t Y1 = *Y;

    if(X1 < win->x)
        X1 = win->x;
    if(X1 > (win->x + win->w - 1))
        X1 = (win->x + win->w - 1);

    if(Y1 < win->y)
        Y1 = win->y;
    if(Y1 > (win->y + win->w - 1))
        Y1 = (win->y + win->w - 1);
    *X = X1;
    *Y = Y1;
}



MEMSPACE
int tft_window_clip_args(window *win, int16_t *x, int16_t *y, int16_t *w, int16_t *h)
{
    int clipped = 0;

    // Clip X
    if(*x < win->x)
    {
        *x = win->x;
        clipped++;
    }
    if(*x > (win->x + win->w - 1))
    {
        *x = (win->x + win->w - 1);
        clipped++;
    }

    // CLIP Y
    if(*y < win->y)
    {
        *y = win->y;
        clipped++;
    }
    if(*y > (win->y + win->h - 1))
    {
        *y = (win->y + win->h - 1);
        clipped++;
    }

    // CLIP W
    if( (*x + *w - 1 ) > (win->x + win->w - 1) )
    {
        *w = (win->x + win->w ) - *x;
        clipped++;
    }

    // CLIP H
    if( (*y + *h - 1 ) > (win->y + win->h - 1) )
    {
        *h = (win->y + win->h ) - *y;
        clipped++;
    }
    return(clipped);
}

MEMSPACE
void tft_window_init(window *win, int16_t x, int16_t y, int16_t w, int16_t h)
{
    // Do Clipping checks for bogus values


    (void) tft_window_clip_args(tft,&x,&y,&w,&h);

    win->xpos       = 0;                            // current X position
    win->ypos       = 0;                            // current Y position
    win->font       = 0;                            // current font size
    win->flags      = WRAP_H;
    win->w          = w;
    win->x          = x;
    win->h          = h;
    win->y          = y;
    win->rotation   = 0;
    win->tabstop    = w/4;
    win->fg = 0xFFFF;
    win->bg = 0;
}



MEMSPACE
void tft_setTextColor(window *win,uint16_t fg, uint16_t bg)
{
    win->fg = fg;
    win->bg = bg;
}

MEMSPACE
void tft_setpos(window *win, int16_t x, int16_t y)
{
    win->xpos = x;
    win->ypos = y;
}

MEMSPACE
void tft_set_textpos(window *win, int16_t x, int16_t y)
{
    win->xpos = x * font_W(win->font);
    win->ypos = y * font_H(win->font);
}


MEMSPACE
void tft_set_font(window *win, uint16_t index)
{
    if(win->font > font_max())
        win->font = font_max();
    win->font = index;
}

MEMSPACE
void tft_font_fixed(window *win)
{
    win->flags &= ~FONT_VAR;
}


MEMSPACE
void tft_font_var(window *win)
{
    win->flags |= FONT_VAR;
}

int tft_get_font_height(window *win)
{
    int ret;
    _fontc f;
    ret = font_attr(win, ' ', &f);
    if(ret < 0)
        return 0;
    return(f.Height);
}


void tft_drawFastVLine(window *win,int16_t x, int16_t y,
int16_t h, uint16_t color)
{
    // function clips
    tft_fillRectWH(win, x,y ,1, h, color);
}


void tft_drawFastHLine(window *win, int16_t x, int16_t y,
int16_t w, uint16_t color)
{
    // function clips
    tft_fillRectWH(win, x,y ,w, 1, color);
}


#if 0
void tft_drawLine(window *win, int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color)
{
    int npts, i, delx, dely, xi, yi, diff;

    delx = (x1-x0); xi = SIGN(delx); delx = ABS(delx);
    dely = (y1-y0); yi = SIGN(dely); dely = ABS(dely);
    diff = (delx-dely);
    npts = MAX(delx,dely);

    for(i=0;i<=npts;++i) 
    {
        tft_drawPixel(win, x0, y0, color);
        if(diff >= 0) 
        {
            diff -= dely; x0 += xi;
            if(dely >= delx) 
            {
                diff +=delx; y0 +=yi;
            }
        }
        else 
        {
            diff += delx; y0 += yi;
            if(delx >= dely) 
            {
                diff -= dely; x0 += xi;
            }
        }
    }
}

#else
void tft_drawLine(window *win, int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color)
{

#define USE_OPTIMIZATION_DRAWLINE

    int16_t dx = ABS(x1 - x0);
    int16_t dy = -ABS(y1 - y0);
    int8_t sx = (x0 < x1) ? 1 : -1;
    int8_t sy = (y0 < y1) ? 1 : -1;
    int16_t err = dx + dy;
    int16_t e2 = 0;

#ifdef USE_OPTIMIZATION_DRAWLINE
    uint16_t startX = x0;
    uint16_t startY = y0;
#endif

    for (;;)
    {
#ifdef USE_OPTIMIZATION_DRAWLINE
            // Require correction
            if ((startX != x0) && (startY != y0)) // draw line and not draw point
            {

                tft_fillRectXY(win, startX, startY, x0 - sx, y0 - sy, color);
                startX = x0;
                startY = y0;
            }
#else
            tft_drawPixel(win, x0, y0, color);
#endif

        e2 = 2*err;
        if (e2 >= dy)
        {
            if (x0 == x1) break;
            err += dy;
            x0 += sx;
        }
        if (e2 <= dx)
        {
            if (y0 == y1) break;
            err += dx;
            y0 += sy;
        }
    }
#ifdef USE_OPTIMIZATION_DRAWLINE
    // function clips
    tft_fillRectXY(win, startX, startY, x0, y0, color);
#endif
}
#endif

int tft_Bezier2(window *win, p2_int16_t S, p2_int16_t C, p2_int16_t T, int steps, uint16_t color)
{
    float t, tinc, t1,p1,p2,p3;
    p2_int16_t Last,Point;
    int16_t X,Y;
    int ind = 0;
    int i;

    Last = S;
    t = 0;

    if(steps < 1)
        steps = 1;

    // FIXME we should compute a step size based on the start to end point distances
    tinc = 1.0 / (float) steps; // steps = 1 will just draw one line

    // Quadratic Bezier http://en.wikipedia.org/wiki/Bézier_curve
    // B(t) = (1-t)(1-t)S + 2(1-t)tC + t*tT, 0 <= t <= 1
    for (i = 0; i < steps; ++i)
    {
        t += tinc;

        t1 = (1.0 - t);
        p1 = t1 * t1;       /* (1.0 - t) (1.0 - t) */
        p2 = 2.0 * t1 * t;  /* 2(1.0 - t) * t */
        p3 = t * t;         /* t * t */

        Point.X = (int16_t) (p1 * (float)S.X + p2 * (float)C.X + p3 * (float)T.X);
        Point.Y = (int16_t) (p1 * (float)S.Y + p2 * (float)C.Y + p3 * (float)T.Y);
        // Do not plot a line until we actually move
        if(Last.X == Point.X && Last.Y == Point.Y)
            continue;
        tft_drawLine(win, Last.X, Last.Y, Point.X, Point.Y, color);
        Last = Point;
    }
    return(ind);
}

int tft_Bezier3(window *win, p2_int16_t S, p2_int16_t C1, p2_int16_t C2, p2_int16_t T, int steps, uint16_t color)
{
    float t, tinc, c0, t1,t2,p1,p2,p3,p4;
    p2_int16_t Last,Point;
    int16_t X,Y;
    int i;
    int ind;

    Last = S;

    if(steps < 1)
        steps = 1;

    ind = 0;

    t = 0;
    // FXIME we should compute a step size based on the start to end point distances
    tinc = 1.0 / (float) steps; // steps = 1 will just draw one line

    // Quadratic Bezier http://en.wikipedia.org/wiki/Bézier_curve
    // B(t) = (1-t)(1-t)*(1-t)*S + 3*(1-t)(1-t)*t*C1  + 3(1-t)*t*t*C2 + t*t*t*T, 0 <= t <= 1
    for (i = 0; i < steps; ++i)
    {
        t += tinc;
        t1 = (1.0 - t);
        t2 = t1 * t1;       /* (1-t)(1-t) */

        c0 = 3.0 * t1 * t;  /* 3(1-t) * t */

        p1 = t2 * t1;       /* (1-t)(1-t)(1-t) */
        p2 = c0 * t1;       /* 3(1-t)(1-t) * t */
        p3 = c0 * t;        /* 3(1-t) * t * t */
        p4 = t * t * t;     /* t * t * t */

        Point.X = (int16_t) (p1 * (float)S.X + p2 * (float)C1.X + p3 * (float) C2.X + p4 * (float)T.X);
        Point.Y = (int16_t) (p3 * (float)S.Y + p2 * (float)C1.Y + p3 * (float) C2.Y + p4 * (float)T.Y);

        // Do not plot a line until we actually move
        if(Last.X == X && Last.Y == Y)
            continue;
        tft_drawLine(win, Last.X, Last.Y, X, Y, color);
        Last = Point;
        ++ind;
    }
    return(ind);
}



MEMSPACE
void tft_cleareol(window *win)
{
    int ret, rem;
    _fontc f;
    ret = font_attr(win,' ', &f);
    if(ret < 0)
        return;
    rem = (win->w - 1 - win->xpos);
    if(rem > 0)
    {
        // function clips
        tft_fillRectWH(win, win->xpos, win->ypos, rem, f.Height, win->bg);
    }
    win->xpos = win->w; // one past end
}

MEMSPACE
void tft_clearline(window *win)
{
    int ret, rem;
    _fontc f;
    ret = font_attr(win,' ', &f);
    if(ret < 0)
        return;
    rem = (win->w - 1 - win->xpos);
    if(rem > 0)
    {
        // function clips
        tft_fillRectWH(win, 0, win->ypos, rem, f.Height, win->bg);
    }
    win->xpos = 0;
}



void tft_putch(window *win, int c)
{
    _fontc f;
    int ret;
    int width;
    int count;
    int rem;

    if(c < 0 || c > 0x7e)
        return;

    if(c >= ' ')
    {
        ret = font_attr(win, c, &f);
        if(ret < 0)
            return;
    }
    else 
    {
        // use space to get font attributes 
        ret = font_attr(win,' ', &f);
        if(ret < 0)
            return;
    }

    // Normal visible characters
    if(c >= ' ')
    {
        (void) tft_drawChar(win, c);
        return;
    }

    // Control characters
    if(c == '\n')
    {
        tft_cleareol(win);
        win->xpos = 0;
        win->ypos += f.Height;
    }
    if(c == '\f')
    {
        tft_fillWin(win,win->bg);
        win->xpos = 0;
        win->ypos = 0;
    }
    if(c == '\t')
    {
        count = win->tabstop - (win->xpos % win->tabstop);// skip size to next tabstop
        // Will we overflow ?
        if(win->xpos + count > win->w)
        {
            count = (win->xpos + count) - win->w -1;
            tft_cleareol(win);
            if(win->flags & WRAP_H)
            {
                tft_fillRectWH(win, 0, win->ypos, count, f.Height, win->bg);
                win->xpos = count;
                win->ypos += f.Height;
            }
        }
        else
        {
            tft_fillRectWH(win, win->xpos, win->ypos, count, f.Height, win->bg);
            win->xpos += count;
        }
    }
}


/* tft_printf removes the need for most of the draw string functions */