DisplayList.h

Go to the documentation of this file.

/****
 * DisplayList.h
 *
 * Copyright 2021 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming-Graphics Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 * @author: May 2021 - mikee47 <mike@sillyhouse.net>
 *
 ****/

#pragma once

#include <HSPI/Request.h>
#include "AddressWindow.h"
#include "Buffer.h"
#include "Blend.h"
#include <FlashString/Array.hpp>
#include <memory>

#define DEFINE_RB_COMMAND(cmd, len, ...) uint8_t(uint8_t(DisplayList::Code::command) | (len << 4)), cmd, ##__VA_ARGS__,
#define DEFINE_RB_COMMAND_LONG(cmd, len, ...)                                                                          \
    uint8_t(uint8_t(DisplayList::Code::command) | 0xf0), len, cmd, ##__VA_ARGS__,
#define DEFINE_RB_DELAY(ms) uint8_t(DisplayList::Code::delay), ms,
#define DEFINE_RB_ARRAY(name, ...) DEFINE_FSTR_ARRAY_LOCAL(name, uint8_t, ##__VA_ARGS__)

namespace Graphics
{
#define GRAPHICS_DL_COMMAND_LIST(XX)                                                                                   \
    XX(none, 0, "")                                                                                                    \
    XX(command, 2 + 1, "General command: arglen, cmd, args")                                                           \
    XX(repeat, 1 + 2 + 2, "Repeated data block: WRITE, len, repeat, data")                                             \
    XX(setColumn, 2 + 2, "Set column: len, start")                                                                     \
    XX(setRow, 2 + 2, "Set row: len, start")                                                                           \
    XX(writeStart, 0, "Start writing command")                                                                         \
    XX(writeData, 2, "Write data: len, data")                                                                          \
    XX(writeDataBuffer, 1 + 2 + sizeof(void*), "Write data: cmd, len, dataptr")                                        \
    XX(readStart, 2 + sizeof(void*), "Read data: len, bufptr (first packet after setting address)")                    \
    XX(read, 2 + sizeof(void*), "Read data: len, bufptr (Second and subsequent packets)")                              \
    XX(callback, 2 + sizeof(void*) + 3, "Callback: paramlen, callback, ALIGN4, params")                                \
    XX(delay, 1, "Wait n milliseconds before continuing")

struct FillInfo {
    using Callback = void (*)(FillInfo& info);

    uint8_t* dstptr;
    PackedColor color;
    uint16_t length;

    static IRAM_ATTR void callbackRGB565(FillInfo& info)
    {
        BlendAlpha::blendRGB565(__builtin_bswap16(info.color.value), info.dstptr, info.length, info.color.alpha);
    }
};

__forceinline uint16_t swapBytes(uint16_t w)
{
    return (w >> 8) | (w << 8);
}

__forceinline uint32_t makeWord(uint16_t w1, uint16_t w2)
{
    return uint32_t(swapBytes(w1)) | (swapBytes(w2) << 16);
}

class DisplayList
{
public:
    enum class Code : uint8_t {
#define XX(code, arglen, desc) code,
        GRAPHICS_DL_COMMAND_LIST(XX)
#undef XX
    };

    enum CodeArgLengths : uint8_t {
#define XX(code, arglen, desc) codelen_##code = 1 + arglen,
        GRAPHICS_DL_COMMAND_LIST(XX)
#undef XX
    };

    static String toString(Code code);

    union Header {
        // Maximum value for header len field. 31 means 'length follows header'
        static constexpr uint8_t lenMax{15};

        struct {
            Code code : 4;
            uint8_t len : 4; // Set to lenMax if length follows buffer
        };
        uint8_t u8;
    };

    static_assert(sizeof(Header) == 1, "Header wrong size");

    using Callback = void (*)(void* parameterData);

    struct Entry {
        Code code;
        uint16_t length;
        uint16_t repeats;
        void* data;
        Callback callback;
        uint16_t value;
        uint8_t cmd;
    };

    DisplayList(AddressWindow& addrWindow, size_t bufferSize) : addrWindow(addrWindow), capacity(bufferSize)
    {
        buffer.reset(new uint8_t[bufferSize]{});
    }

    DisplayList(AddressWindow& addrWindow, const FSTR::ObjectBase& data) : DisplayList(addrWindow, data.size())
    {
        data.read(0, buffer.get(), data.size());
        size = data.length();
    }

    DisplayList(AddressWindow& addrWindow, const void* data, size_t length) : DisplayList(addrWindow, length)
    {
        memcpy(buffer.get(), data, length);
        size = length;
    }

    void reset();

    bool isEmpty() const
    {
        return size == 0;
    }

    uint16_t freeSpace() const
    {
        return capacity - size;
    }

    uint16_t readOffset() const
    {
        return offset;
    }

    uint16_t used() const
    {
        assert(size <= capacity);
        return size;
    }

    const uint8_t* getContent() const
    {
        return buffer.get();
    }

    uint8_t* getBuffer(uint16_t& available);

    uint8_t* getBuffer(uint16_t minBytes, uint16_t& available)
    {
        auto buf = getBuffer(available);
        return (buf != nullptr && available >= minBytes) ? buf : nullptr;
    }

    void commit(uint16_t length);

    bool writeCommand(uint8_t command, uint32_t data, uint8_t length)
    {
        return writeCommand(command, &data, length);
    }

    bool writeCommand(uint8_t command, const void* data, uint16_t length);

    bool writeData(const void* data, uint16_t length);

    bool writeDataBuffer(SharedBuffer& data, size_t offset, uint16_t length);

    bool blockFill(const void* data, uint16_t length, uint32_t repeat);

    bool setAddrWindow(const Rect& rect);

    bool setPixel(PackedColor color, uint8_t bytesPerPixel, Point pt);

    bool readMem(void* buffer, uint16_t length);

    bool writeCallback(Callback callback, void* params, uint16_t paramLength);

    bool fill(const Rect& rect, PackedColor color, uint8_t bytesPerPixel, FillInfo::Callback callback);

    bool canLockBuffer()
    {
        return lockCount < maxLockedBuffers;
    }

    bool lockBuffer(SharedBuffer& buffer);

    bool require(uint16_t length)
    {
        return size + length <= capacity;
    }

    bool readEntry(Entry& info);

    void prepare(Callback callback, void* param)
    {
        this->callback = callback;
        this->param = param;
        offset = 0;
    }

protected:
    void write(uint8_t c)
    {
        buffer[size++] = c;
    }

    void writeHeader(Code code, uint16_t length)
    {
        // debug_i("%p writeHeader(%s, %u)", this, toString(code).c_str(), length);
        if(length < Header::lenMax) {
            Header hdr{code, uint8_t(length)};
            write(hdr.u8);
        } else {
            Header hdr{code, Header::lenMax};
            write(hdr.u8);
            writeVar(length);
        }
    }

    void write16(uint16_t c)
    {
        write((c >> 8) | 0x80);
        write(c & 0xff);
    }

    void write(const void* data, uint16_t length)
    {
        if(length != 0) {
            memcpy(&buffer[size], data, length);
            size += length;
        }
    }

    void writeVar(uint16_t count)
    {
        if(count >= 0x80) {
            write16(count);
        } else {
            write(count);
        }
    }

    Code getWriteCode()
    {
        return addrWindow.setMode(AddressWindow::Mode::write) ? Code::writeStart : Code::writeData;
    }

    Code getReadCode()
    {
        return addrWindow.setMode(AddressWindow::Mode::read) ? Code::readStart : Code::read;
    }

    void internalSetAddrWindow(const Rect& rect);

    void IRAM_ATTR read(void* data, uint16_t len)
    {
        memcpy(data, &buffer[offset], len);
        offset += len;
    }

    uint16_t IRAM_ATTR readVar()
    {
        uint16_t var = buffer[offset++];
        if(var & 0x80) {
            var = (var & 0x7f) << 8;
            var |= buffer[offset++];
        }
        return var;
    }

    static constexpr size_t maxLockedBuffers{8};

    Callback callback{nullptr};
    void* param{nullptr};
    std::unique_ptr<uint8_t[]> buffer;
    uint16_t size{0};   
    uint16_t offset{0}; 

private:
    AddressWindow& addrWindow;
    uint16_t capacity;
    SharedBuffer lockedBuffers[maxLockedBuffers];
#ifdef ENABLE_GRAPHICS_RAM_TRACKING
    size_t maxBufferUsage{0};
#endif
    uint8_t lockCount{0};
};

} // namespace Graphics

inline String toString(Graphics::DisplayList::Code code)
{
    return Graphics::DisplayList::toString(code);
}