framebuffer.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/abi.h>
#include <sifteo/macros.h>
#include <sifteo/math.h>

namespace Sifteo {

template <unsigned tWidth, unsigned tHeight, unsigned tBitsPerPixel>
struct FBDrawable {
    _SYSAttachedVideoBuffer sys;

    static unsigned width() {
        return tWidth;
    }

    static unsigned height() {
        return tHeight;
    }

    static UInt2 size() {
        return vec(tWidth, tHeight);
    }

    static unsigned numColors() {
        return 1 << tBitsPerPixel;
    }

    static unsigned bitsPerPixel() {
        return tBitsPerPixel;
    }

    static unsigned sizeInBytes() {
        return tWidth * tHeight * tBitsPerPixel / 8;
    }

    static unsigned sizeInWords() {
        return tWidth * tHeight * tBitsPerPixel / 16;
    }

    void plot(UInt2 pos, unsigned colorIndex)
    {
        ASSERT(pos.x <= tWidth && pos.y <= tHeight);

        const unsigned pixelsPerByte = 8 / tBitsPerPixel;
        const unsigned bytesPerLine = tWidth / pixelsPerByte;
        const unsigned xByte = pos.x / pixelsPerByte;
        const unsigned xBit = (pos.x % pixelsPerByte) * tBitsPerPixel;
        const unsigned byteAddr = xByte + pos.y * bytesPerLine;
        const unsigned pixelMask = ((1 << tBitsPerPixel) - 1) << xBit;

        uint8_t byte = _SYS_vbuf_peekb(&sys.vbuf, byteAddr);
        byte &= ~pixelMask;
        byte |= colorIndex << xBit;
        _SYS_vbuf_pokeb(&sys.vbuf, byteAddr, byte);
    }

    static uint16_t expand16(unsigned colorIndex)
    {
        switch (tBitsPerPixel) {
            case 1:  return colorIndex ? 0xFFFF : 0x0000;
            case 2:  colorIndex |= colorIndex << 2;
            case 4:  colorIndex |= colorIndex << 4;
            case 8:  colorIndex |= colorIndex << 8;
            case 16: return colorIndex;
            default: ASSERT(0);
        }
    }

    void span(UInt2 pos, unsigned width, unsigned colorIndex)
    {
        ASSERT(pos.x <= tWidth && width <= tWidth &&
            (pos.x + width) <= tWidth && pos.y < tHeight);

        const unsigned pixelsPerWord = 16 / tBitsPerPixel;
        const unsigned wordsPerLine = tWidth / pixelsPerWord;
        const unsigned colorWord = expand16(colorIndex);

        // Calculate a base address in words, and
        // left/right boundaries relative to that in bits.
        unsigned addr = pos.x / pixelsPerWord + pos.y * wordsPerLine;
        int start = (pos.x % pixelsPerWord) * tBitsPerPixel;
        int end = start + width * tBitsPerPixel;

        while (end > 0) {
            if (start <= 0 && end >= 16) {
                // A run of complete words

                unsigned count = end / 16;
                _SYS_vbuf_fill(&sys.vbuf, addr, colorWord, count);
                addr += count;
                unsigned bits = count * 16;
                start -= bits;
                end -= bits;

            } else {
                // One partial word. (The first, last or only word)

                unsigned mask = bitRange<uint16_t>(start, end);
                unsigned word = _SYS_vbuf_peek(&sys.vbuf, addr);
                word &= ~mask;
                word |= colorWord & mask;
                _SYS_vbuf_poke(&sys.vbuf, addr, word);
                addr++;
                start -= 16;
                end -= 16;
            }
        }
    }

    void fill(UInt2 topLeft, UInt2 size, unsigned colorIndex)
    {
        while (size.y) {
            span(topLeft, size.x, colorIndex);
            size.y--;
            topLeft.y++;
        }
    }

    void fill(unsigned colorIndex)
    {
        _SYS_vbuf_fill(&sys.vbuf, 0, expand16(colorIndex), sizeInWords());
    }

    void bitmapSpan(UInt2 pos, unsigned width, const uint8_t *data)
    {
        ASSERT(pos.x <= tWidth && width <= tWidth &&
            (pos.x + width) <= tWidth && pos.y < tHeight);

        const unsigned pixelsPerByte = 8 / tBitsPerPixel;
        const unsigned bytesPerLine = tWidth / pixelsPerByte;

        // Base address in bits
        unsigned addr = pos.x / pixelsPerByte + pos.y * bytesPerLine;

        // Bitmap alignment
        unsigned shift = (pos.x % pixelsPerByte) * tBitsPerPixel;
        unsigned invShift = 8 - shift;

        // Initial mask range, in bits, relative to the base address
        int start = shift;
        int end = start + width * tBitsPerPixel;

        while (end > 0) {
            // One source byte at a time, splatted to either one or two
            // destination bytes in VRAM.

            uint8_t source = *data;
            data++;

            // First byte
            unsigned mask = (0xFF << shift) & bitRange<uint16_t>(start, end);
            unsigned byte = _SYS_vbuf_peekb(&sys.vbuf, addr);
            byte &= ~mask;
            byte |= (source << shift) & mask;
            _SYS_vbuf_pokeb(&sys.vbuf, addr, byte);

            addr++;
            start -= 8;
            end -= 8;

            // Optional second byte
            if (shift) {
                unsigned mask = (0xFF >> invShift) & bitRange<uint16_t>(start, end);
                unsigned byte = _SYS_vbuf_peekb(&sys.vbuf, addr);
                byte &= ~mask;
                byte |= (source >> invShift) & mask;
                _SYS_vbuf_pokeb(&sys.vbuf, addr, byte);
            }
        }
    }

    void bitmap(UInt2 topLeft, UInt2 size, const uint8_t *data, unsigned stride)
    {
        while (size.y) {
            bitmapSpan(topLeft, size.x, data);
            size.y--;
            topLeft.y++;
            data += stride;
        }
    }

    void set(const uint16_t *data) {
        _SYS_vbuf_write(&sys.vbuf, 0, data, sizeInWords());
    }

    _SYSVideoBuffer &videoBuffer() {
        return sys.vbuf;
    }

    CubeID cube() const {
        return sys.cube;
    }
};


typedef FBDrawable<32,32,4> FB32Drawable;

typedef FBDrawable<64,64,1> FB64Drawable;

typedef FBDrawable<128,48,1> FB128Drawable;


struct StampDrawable {
    _SYSAttachedVideoBuffer sys;

    void resizeFB(Int2 pixelSize) {
        ASSERT((pixelSize.x & 1) == 0 &&
            pixelSize.x * pixelSize.y <= 1536 &&
            pixelSize.x <= 128 &&
            pixelSize.y <= 128);
    
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, stamp_pitch)/2,
            (pixelSize.x >> 1) | (pixelSize.y << 8));
    }

    template <unsigned tWidth, unsigned tHeight>
    FBDrawable<tWidth, tHeight, 4>& getFB()
    {
        auto &fb = *reinterpret_cast<FBDrawable<tWidth, tHeight, 4>*>(this);
        ASSERT(&fb.sys == &sys);
        return fb;
    }

    template <unsigned tWidth, unsigned tHeight>
    FBDrawable<tWidth, tHeight, 4>& initFB()
    {
        _SYS_finish();
        resizeFB(vec(tWidth, tHeight));
        return getFB<tWidth, tHeight>();
    }
    
    void setHWindow(uint8_t firstColumn, uint8_t numColumns) {
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, stamp_x)/2,
            firstColumn | (numColumns << 8));
    }

    void setBox(Int2 topLeft, Int2 size) {
        _SYS_vbuf_poke(&sys.vbuf, offsetof(_SYSVideoRAM, first_line)/2,
            topLeft.y | (size.y << 8));
        setHWindow(topLeft.x, size.x);
    }

    void setKeyIndex(unsigned index) {
        _SYS_vbuf_pokeb(&sys.vbuf, offsetof(_SYSVideoRAM, stamp_key), index);
    }

    void disableKey() {
        setKeyIndex(16);
    }

    _SYSVideoBuffer &videoBuffer() {
        return sys.vbuf;
    }

    CubeID cube() const {
        return sys.cube;
    }
};


};  // namespace Sifteo