Pixels.h

/*
 * Pixels. Graphics library for TFT displays.
 *
 * Copyright (C) 2012-2013  Igor Repinetski
 *
 * The code is written in C/C++ for Arduino and can be easily ported to any microcontroller by rewritting the low level pin access functions.
 *
 * Text output methods of the library rely on Pixelmeister's font data format. See: http://pd4ml.com/pixelmeister
 *
 * This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
 *
 * Commercial use of the library is possible for licensees of "Pixelmeister (for industry)" product.
 *
 * This library includes some code portions and algoritmic ideas derived from works of
 * - Andreas Schiffler -- aschiffler at ferzkopp dot net (SDL_gfx Project)
 * - K. Townsend http://microBuilder.eu (lpc1343codebase Project)
 */

/*
 * Currently supported platforms:
 *
 * 1. Reference platform: Arduino Mega, TFT_PQ 2.4 (ILI9325 controller), ITDB02 MEGA Shield v1.1
 *
 * More platforms coming soon
 */

#ifndef PIXELS_BASE_H
#define PIXELS_BASE_H

// #define DISABLE_ANTIALIASING 1

#if defined(__AVR__) || defined(TEENSYDUINO)
    #include <Arduino.h>

    #define regtype volatile uint8_t
    #define regsize uint8_t

    #define cbi(reg, bitmask) *reg &= ~bitmask
    #define sbi(reg, bitmask) *reg |= bitmask
    #define pulse_high(reg, bitmask) sbi(reg, bitmask); cbi(reg, bitmask);
    #define pulse_low(reg, bitmask) cbi(reg, bitmask); sbi(reg, bitmask);

#elif defined(__SAM3X8E__)
    #include <Arduino.h>
    #define PROGMEM
    #define prog_uchar const unsigned char
    #define pgm_read_byte(x)        (*((char *)x))
    #define pgm_read_word(x)        ( ((*((unsigned char *)x + 1)) << 8) + (*((unsigned char *)x)))
    #define pgm_read_byte_near(x)   (*((char *)x))
    #define pgm_read_byte_far(x)    (*((char *)x))
//  #define pgm_read_word(x)        (*((short *)(x & 0xfffffffe)))
//  #define pgm_read_word_near(x)   (*((short *)(x & 0xfffffffe))
//  #define pgm_read_word_far(x)    (*((short *)(x & 0xfffffffe)))
    #define pgm_read_word_near(x)   ( ((*((unsigned char *)x + 1)) << 8) + (*((unsigned char *)x)))
    #define pgm_read_word_far(x)    ( ((*((unsigned char *)x + 1)) << 8) + (*((unsigned char *)x))))
    #define PSTR(x)  x
#else
    #define PROGMEM
    #define prog_uchar byte

    #define regtype volatile uint32_t
    #define regsize uint16_t
#endif

#define swap(a, b) {int16_t buf = a; a = b; b = buf;}

#define BITMASK_FONT 1
#define ANTIALIASED_FONT 2
#define HEADER_LENGTH 5

#define SCROLL_SMOOTH 1
#define SCROLL_CLEAN 2

#define FILL_TOPDOWN 0
#define FILL_LEFTRIGHT 0
#define FILL_DOWNTOP 1
#define FILL_RIGHTLEFT 2

#define ORIGIN_RELATIVE true // origin relative to a current scroll position
#define ORIGIN_ABSOLUTE false // origin matches physical device pixel coordinates

#define PORTRAIT 0
#define LANDSCAPE 1
#define PORTRAIT_FLIP 2
#define LANDSCAPE_FLIP 3

#define ipart(X) ((int16_t)(X))
#define round(X) ((uint16_t)(((double)(X))+0.5))
#define fpart(X) (((double)(X))-(double)ipart(X))
#define rfpart(X) (1.0-fpart(X))

extern regtype *registerCS; // chip select
extern regsize bitmaskCS;

#define chipSelect() cbi(registerCS, bitmaskCS)
#define chipDeselect() sbi(registerCS, bitmaskCS)

class RGB {
public:
    uint8_t red;
    uint8_t green;
    uint8_t blue;

    RGB(uint8_t r, uint8_t g, uint8_t b);
    RGB();

    RGB convert565toRGB(uint16_t color);
    uint16_t convertRGBto565(RGB color);
    uint16_t convertTo565();
};

class PixelsBase {
protected:
    /* device physical dimension in portrait orientation */
    int16_t deviceWidth;
    int16_t deviceHeight;

    /* device logical dimension in current orientation */
    int16_t width;
    int16_t height;

    boolean landscape;

    uint8_t orientation;

    boolean relativeOrigin;

    /* currently selected font */
    prog_uchar* currentFont;

    RGB foreground;
    RGB background;

    double lineWidth;

    uint8_t fillDirection;
    boolean antialiasing;

    boolean scrollSupported;
    boolean scrollEnabled;

    int16_t currentScroll;
    int16_t flipScroll;
    boolean scrollCleanMode;

    void printString(int16_t xx, int16_t yy, String text, boolean clean, int8_t kerning[] = NULL);
    void drawGlyph(int16_t fontType, boolean clean, int16_t xx, int16_t yy,
                               int16_t height, prog_uchar* data, int16_t ptr, int16_t length);

    virtual void setRegion(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {};
    void setCurrentPixel(RGB color);
    void setCurrentPixel(int16_t color);
    void fill(int b, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    virtual void quickFill(int b, int16_t x1, int16_t y1, int16_t x2, int16_t y2) {};
    void putColor(int16_t x, int16_t y, boolean steep, double weight);
    RGB computeColor(RGB, double weight);
    RGB computeColor(RGB fg, uint8_t opacity);

    void resetRegion();

    void hLine(int16_t x1, int16_t y1, int16_t x2);
    void vLine(int16_t x1, int16_t y1, int16_t y2);

    virtual void deviceWriteData(uint8_t hi, uint8_t lo) {};

    virtual void scrollCmd() {};

    virtual void drawCircleAntialiaced(int16_t x, int16_t y, int16_t radius, boolean bordermode);
    virtual void drawFatLineAntialiased(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    virtual void drawLineAntialiased(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    virtual void drawRoundRectangleAntialiased(int16_t x, int16_t y, int16_t width, int16_t height, int16_t rx, int16_t ry, boolean bordermode);

    int16_t* loadFileBytes(String);

public:
    PixelsBase(uint16_t width, uint16_t height);
    virtual void init() {};
    void setOrientation(uint8_t orientation);
    inline uint8_t getOrientation() {
        return orientation;
    }
    virtual void enableAntialiasing(boolean enable) {
        antialiasing = false;
    }

    inline boolean isAntialiased() {
        return antialiasing;
    }
    inline void enableScroll(boolean enable) {
        scrollEnabled = enable;
    }
    inline boolean canScroll() {
        return scrollEnabled & scrollSupported;
    }
    inline void setLineWidth(double width) {
        lineWidth = width;
    }
    inline double getLineWidth() {
        return lineWidth;
    }
    inline int16_t getWidth() {
        return width;
    }
    inline int16_t getHeight() {
        return height;
    }
    inline void setOriginRelative() {
        relativeOrigin = true;
    }
    inline void setOriginAbsolute() {
        relativeOrigin = false;
    }
    inline boolean isOriginRelative() {
        return relativeOrigin;
    }
    virtual void setFillDirection(uint8_t direction) {};
    void clear();
    inline void setBackground(uint8_t r, uint8_t g, uint8_t b) {
        setBackground(RGB(r, g, b));
    }
    inline void setColor(uint8_t r, uint8_t g, uint8_t b) {
        setColor(RGB(r, g, b));
    }
    inline void setBackground(RGB color) {
        background = color;
    }
    inline void setColor(RGB color) {
        foreground = color;
    }
    inline RGB getBackground() {
        return background;
    }
    inline RGB getColor() {
        return foreground;
    }
    RGB getPixel(int16_t x, int16_t y);
    void drawPixel(int16_t x, int16_t y);
    void drawLine(int16_t x1, int16_t y1, int16_t x2, int16_t y2);
    void drawCircle(int16_t x, int16_t y, int16_t radius);
    void drawOval(int16_t x, int16_t y, int16_t width, int16_t height);
    void drawRectangle(int16_t x, int16_t y, int16_t width, int16_t height);
    void drawRoundRectangle(int16_t x, int16_t y, int16_t width, int16_t height, int16_t r);
    void fillCircle(int16_t x, int16_t y, int16_t radius);
    void fillOval(int16_t x, int16_t y, int16_t width, int16_t height);
    void fillRectangle(int16_t x, int16_t y, int16_t width, int16_t height);
    void fillRoundRectangle(int16_t x, int16_t y, int16_t width, int16_t height, int16_t r);
    int8_t drawBitmap(int16_t x, int16_t y, int16_t width, int16_t height, prog_uint16_t* data);
    int8_t drawCompressedBitmap(int16_t x, int16_t y, uint8_t* data);
    void drawIcon(int16_t xx, int16_t yy, prog_uchar data[]);
    void cleanIcon(int16_t xx, int16_t yy, prog_uchar data[]);
    int8_t loadBitmap(int16_t x, int16_t y, int16_t width, int16_t height, String path);
    void scroll(int16_t dy, int16_t x1, int16_t x2, int8_t flags);
    void scroll(int16_t dy, int8_t flags);
    int setFont(prog_uchar font[]);
    void print(int16_t xx, int16_t yy, String text, int8_t kerning[] = NULL);
    void cleanText(int16_t xx, int16_t yy, String text, int8_t kerning[] = NULL);
    int16_t getTextLineHeight();
    int16_t getTextBaseline();
    int16_t getTextWidth(String text, int8_t kerning[] = NULL);
};

class BitStream {
private:
    uint8_t* data;
    size_t size;
    int32_t bitpos;

public:
    BitStream (uint8_t* src_buffer, size_t byte_size, int8_t offset = 0) {
        bitpos = offset;
        data = src_buffer;
        size = byte_size + (offset>>3);
    }

    bool endOfData() {
        return ((bitpos + 1) >> 3) >= size;
    }

    uint8_t testCurrentByte() {
        uint8_t res = (uint8_t)pgm_read_byte_near(data + (bitpos>>3));
        return res;
    }

    uint8_t readBit() {
        uint8_t res = (uint8_t)(pgm_read_byte_near(data + (bitpos>>3)) & (uint8_t)( (uint16_t)0x80 >> (bitpos & 7) ));
        bitpos++;
        return res;
    }

    uint8_t readBits(uint8_t len) {

        uint16_t end_offset = (bitpos + len - 1)>>3;
        if ( end_offset >= size ) {
            return 0;
        }

        uint8_t i;
        uint16_t byte_offset = bitpos >> 3;
        if (byte_offset == end_offset) {
            uint16_t x = pgm_read_byte_near(data + byte_offset);
            i = (uint8_t)(x >> (8 - ((bitpos & 7) + len))) & ((1 << len) - 1);
        } else {
            uint16_t x = ((uint16_t)pgm_read_byte_near(data + byte_offset) << 8) + pgm_read_byte_near(data + end_offset);
            i = (uint8_t)(x >> (16 - ((bitpos & 7) + len))) & ((1 << len) - 1);
        }
        bitpos += len;
        return i;
    }

    uint16_t readNumber() {
        int16_t count;

        int8_t ctr = 1;
        int16_t base = 2;
        do {
            if ( readBit() == 0 ) {
                uint8_t bits = readBits(ctr);
                count = base + bits;
                break;
            } else {
                ctr++;
                base *= 2;
                if ( ctr == 7 ) {
                    uint8_t bits = readBits(ctr);
                    count = base + bits;
                    break;
                }
            }
        } while ( true );

        return (uint16_t)count;
    }
};

#endif