system/include/pedigree/kernel/graphics/Graphics.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _GRAPHICS_H
#define _GRAPHICS_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"

class Framebuffer;

namespace Graphics
{
inline uint32_t createRgb(uint32_t r, uint32_t g, uint32_t b)
{
    return (r << 16) | (g << 8) | b;
}

enum PixelFormat
{
    Bits32_Argb,  // Alpha + RGB, with alpha in the highest byte
    Bits32_Rgba,  // RGB + alpha, with alpha in the lowest byte
    Bits32_Rgb,   // RGB, no alpha, essentially the same as above
    Bits32_Bgr,   // BGR, no alpha

    Bits24_Rgb,  // RGB in a 24-bit pack
    Bits24_Bgr,  // R and B bytes swapped

    Bits16_Argb,    // 4:4:4:4 ARGB, alpha most significant nibble
    Bits16_Rgb565,  // 5:6:5 RGB
    Bits16_Rgb555,  // 5:5:5 RGB

    Bits8_Idx,     // Index into a palette
    Bits8_Rgb332,  // Intensity values
};

inline size_t bitsPerPixel(PixelFormat format)
{
    switch (format)
    {
        case Bits32_Argb:
        case Bits32_Rgba:
        case Bits32_Rgb:
        case Bits32_Bgr:
            return 32;
        case Bits24_Rgb:
        case Bits24_Bgr:
            return 24;
        case Bits16_Argb:
        case Bits16_Rgb565:
        case Bits16_Rgb555:
            return 16;
        case Bits8_Idx:
        case Bits8_Rgb332:
            return 8;
    }

    return 0;
}

inline size_t bytesPerPixel(PixelFormat format)
{
    return bitsPerPixel(format) / 8;
}

struct Buffer
{
    uintptr_t base;

    size_t width;

    size_t height;

    PixelFormat format;

    size_t bytesPerPixel;

    size_t bufferId;

    void *pBacking;
};

inline bool convertPixel(
    uint32_t source, PixelFormat srcFormat, uint32_t &dest,
    PixelFormat destFormat)
{
    if ((srcFormat == destFormat) || (!source))
    {
        dest = source;
        return true;
    }

    // Amount of red/green/blue, in 8-bit intensity values
    uint8_t amtRed = 0, amtGreen = 0, amtBlue = 0, amtAlpha = 0;

    // Unpack the pixel as necessary
    if ((srcFormat == Bits32_Argb) || (srcFormat == Bits32_Rgb) ||
        (srcFormat == Bits24_Rgb))
    {
        if (srcFormat != Bits24_Rgb)
            amtAlpha = (source & 0xff000000) >> 24;
        amtRed = (source & 0xff0000) >> 16;
        amtGreen = (source & 0xff00) >> 8;
        amtBlue = (source & 0xff);
    }
    else if (srcFormat == Bits32_Rgba)
    {
        amtRed = (source & 0xff000000) >> 24;
        amtGreen = (source & 0xff0000) >> 16;
        amtBlue = (source & 0xff00) >> 8;
        amtAlpha = (source & 0xff);
    }
    else if ((srcFormat == Bits32_Bgr) || (srcFormat == Bits24_Bgr))
    {
        amtBlue = (source & 0xff0000) >> 16;
        amtGreen = (source & 0xff00) >> 8;
        amtRed = (source & 0xff);
    }
    else if (srcFormat == Bits16_Argb)
    {
        amtAlpha = (((source & 0xF000) >> 12) / 0xF) * 0xFF;
        amtRed = (((source & 0xF00) >> 8) / 0xF) * 0xFF;
        amtGreen = (((source & 0xF0) >> 4) / 0xF) * 0xFF;
        amtBlue = ((source & 0xF) / 0xF) * 0xFF;
    }
    else if (srcFormat == Bits16_Rgb565)
    {
        amtRed = (((source & 0xF800) >> 11) / 0x1F) * 0xFF;
        amtGreen = (((source & 0x7E0) >> 5) / 0x3F) * 0xFF;
        amtBlue = ((source & 0x1F) / 0x1F) * 0xFF;
    }
    else if (srcFormat == Bits16_Rgb555)
    {
        amtRed = (((source & 0xF800) >> 10) / 0x1F) * 0xFF;
        amtGreen = (((source & 0x3E0) >> 5) / 0x1F) * 0xFF;
        amtBlue = ((source & 0x1F) / 0x1F) * 0xFF;
    }
    else if (srcFormat == Bits8_Rgb332)
    {
        amtRed = (((source & 0xE0) >> 5) / 0x7) * 0xFF;
        amtGreen = (((source & 0x1C) >> 2) / 0x7) * 0xFF;
        amtBlue = ((source & 0x3) / 0x3) * 0xFF;
    }

    // Conversion code. Complicated and ugly. :(
    switch (destFormat)
    {
        case Bits32_Argb:
            dest =
                (amtAlpha << 24) | (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits32_Rgba:
            dest =
                (amtRed << 24) | (amtGreen << 16) | (amtBlue << 8) | amtAlpha;
            return true;
        case Bits32_Rgb:
            dest = (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits32_Bgr:
            dest = (amtRed << 8) | (amtGreen << 16) | amtBlue;
            return true;
        case Bits24_Rgb:
            dest = (amtRed << 16) | (amtGreen << 8) | amtBlue;
            return true;
        case Bits24_Bgr:
            dest = (amtBlue << 16) | (amtGreen << 8) | amtRed;
            return true;
        case Bits16_Rgb555:
            // 8-bit to 5-bit scaling. Lossy.
            amtRed >>= 3;
            amtGreen >>= 3;
            amtBlue >>= 3;

            dest = (amtRed << 10) | (amtGreen << 5) | (amtBlue);
            return true;
        case Bits16_Rgb565:
            // 8-bit to 5 and 6 -bit scaling. Lossy.
            amtRed >>= 3;
            amtGreen >>= 2;
            amtBlue >>= 3;

            dest = (amtRed << 11) | (amtGreen << 5) | (amtBlue);
            return true;
        case Bits16_Argb:
            // 8-bit to 4-bit scaling. Lossy.
            amtRed >>= 4;
            amtGreen >>= 4;
            amtBlue >>= 4;
            amtAlpha >>= 4;

            dest =
                (amtAlpha << 12) | (amtRed << 8) | (amtGreen << 4) | (amtBlue);
            return true;
        case Bits8_Idx:
            break;
        case Bits8_Rgb332:
            amtRed >>= 5;
            amtGreen >>= 5;
            amtBlue >>= 6;

            dest = (amtRed << 5) | (amtGreen << 2) | amtBlue;
            return true;
    }

    return false;
}

EXPORTED_PUBLIC Framebuffer *createFramebuffer(
    Framebuffer *pParent, size_t x, size_t y, size_t w, size_t h,
    void *pFbOverride = 0);

EXPORTED_PUBLIC void destroyFramebuffer(Framebuffer *pFramebuffer);
};  // namespace Graphics

#endif