source: bootcd/isolinux/syslinux-6.03/com32/lib/sys/vesa/drawtxt.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2006-2008 H. Peter Anvin - All Rights Reserved
 *
 *   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.
 *
 * ----------------------------------------------------------------------- */

#include <inttypes.h>
#include <colortbl.h>
#include <string.h>
#include "vesa.h"
#include "video.h"
#include "fill.h"

/*
 * Visible cursor information
 */
static uint8_t cursor_pattern[FONT_MAX_HEIGHT];
static struct vesa_char *cursor_pointer = NULL;
static int cursor_x, cursor_y;

static inline void *copy_dword(void *dst, void *src, size_t dword_count)
{
    asm volatile ("rep; movsl":"+D" (dst), "+S"(src), "+c"(dword_count));
    return dst;                 /* Updated destination pointer */
}

static inline __attribute__ ((always_inline))
uint8_t alpha_val(uint8_t fg, uint8_t bg, uint8_t alpha)
{
    unsigned int tmp;

    tmp = __vesacon_srgb_to_linear[fg] * alpha;
    tmp += __vesacon_srgb_to_linear[bg] * (255 - alpha);

    return __vesacon_linear_to_srgb[tmp >> 12];
}

static uint32_t alpha_pixel(uint32_t fg, uint32_t bg)
{
    uint8_t alpha = fg >> 24;
    uint8_t fg_r = fg >> 16;
    uint8_t fg_g = fg >> 8;
    uint8_t fg_b = fg;
    uint8_t bg_r = bg >> 16;
    uint8_t bg_g = bg >> 8;
    uint8_t bg_b = bg;

    return
        (alpha_val(fg_r, bg_r, alpha) << 16) |
        (alpha_val(fg_g, bg_g, alpha) << 8) | (alpha_val(fg_b, bg_b, alpha));
}

static void vesacon_update_characters(int row, int col, int nrows, int ncols)
{
    const int height = __vesacon_font_height;
    const int width = FONT_WIDTH;
    uint32_t *bgrowptr, *bgptr, bgval, fgval;
    uint32_t fgcolor = 0, bgcolor = 0, color;
    uint8_t chbits = 0, chxbits = 0, chsbits = 0;
    int i, j, jx, pixrow, pixsrow;
    struct vesa_char *rowptr, *rowsptr, *cptr, *csptr;
    unsigned int bytes_per_pixel = __vesacon_bytes_per_pixel;
    unsigned long pixel_offset;
    uint32_t row_buffer[__vesa_info.mi.h_res], *rowbufptr;
    size_t fbrowptr;
    uint8_t sha;

    pixel_offset = ((row * height + VIDEO_BORDER) * __vesa_info.mi.h_res) +
        (col * width + VIDEO_BORDER);

    bgrowptr = &__vesacon_background[pixel_offset];
    fbrowptr = (row * height + VIDEO_BORDER) * __vesa_info.mi.logical_scan +
        (col * width + VIDEO_BORDER) * bytes_per_pixel;

    /* Note that we keep a 1-character guard area around the real text area... */
    rowptr = &__vesacon_text_display[(row+1)*(__vesacon_text_cols+2)+(col+1)];
    rowsptr = rowptr - ((__vesacon_text_cols+2)+1);
    pixrow = 0;
    pixsrow = height - 1;

    for (i = height * nrows; i >= 0; i--) {
        bgptr = bgrowptr;
        rowbufptr = row_buffer;

        cptr = rowptr;
        csptr = rowsptr;

        chsbits = __vesacon_graphics_font[csptr->ch][pixsrow];
        if (__unlikely(csptr == cursor_pointer))
            chsbits |= cursor_pattern[pixsrow];
        sha = console_color_table[csptr->attr].shadow;
        chsbits &= (sha & 0x02) ? 0xff : 0x00;
        chsbits ^= (sha & 0x01) ? 0xff : 0x00;
        chsbits <<= (width - 2);
        csptr++;

        /* Draw two pixels beyond the end of the line.  One for the shadow,
           and one to make sure we have a whole dword of data for the copy
           operation at the end.  Note that this code depends on the fact that
           all characters begin on dword boundaries in the frame buffer. */

        for (jx = 1, j = width * ncols + 1; j >= 0; j--) {
            chbits <<= 1;
            chsbits <<= 1;
            chxbits <<= 1;

            switch (jx) {
            case 1:
                chbits = __vesacon_graphics_font[cptr->ch][pixrow];
                if (__unlikely(cptr == cursor_pointer))
                    chbits |= cursor_pattern[pixrow];
                sha = console_color_table[cptr->attr].shadow;
                chxbits = chbits;
                chxbits &= (sha & 0x02) ? 0xff : 0x00;
                chxbits ^= (sha & 0x01) ? 0xff : 0x00;
                fgcolor = console_color_table[cptr->attr].argb_fg;
                bgcolor = console_color_table[cptr->attr].argb_bg;
                cptr++;
                jx--;
                break;
            case 0:
                chsbits = __vesacon_graphics_font[csptr->ch][pixsrow];
                if (__unlikely(csptr == cursor_pointer))
                    chsbits |= cursor_pattern[pixsrow];
                sha = console_color_table[csptr->attr].shadow;
                chsbits &= (sha & 0x02) ? 0xff : 0x00;
                chsbits ^= (sha & 0x01) ? 0xff : 0x00;
                csptr++;
                jx = width - 1;
                break;
            default:
                jx--;
                break;
            }

            /* If this pixel is raised, use the offsetted value */
            bgval = (chxbits & 0x80)
                ? bgptr[__vesa_info.mi.h_res + 1] : *bgptr;
            bgptr++;

            /* If this pixel is set, use the fg color, else the bg color */
            fgval = (chbits & 0x80) ? fgcolor : bgcolor;

            /* Produce the combined color pixel value */
            color = alpha_pixel(fgval, bgval);

            /* Apply the shadow (75% shadow) */
            if ((chsbits & ~chxbits) & 0x80) {
                color >>= 2;
                color &= 0x3f3f3f;
            }

            *rowbufptr++ = color;
        }

        /* Copy to frame buffer */
        __vesacon_copy_to_screen(fbrowptr, row_buffer, rowbufptr - row_buffer);

        bgrowptr += __vesa_info.mi.h_res;
        fbrowptr += __vesa_info.mi.logical_scan;

        if (++pixrow == height) {
            rowptr += __vesacon_text_cols + 2;
            pixrow = 0;
        }
        if (++pixsrow == height) {
            rowsptr += __vesacon_text_cols + 2;
            pixsrow = 0;
        }
    }
}

/* Bounding box for changed text.  The (x1, y1) coordinates are +1! */
static unsigned int upd_x0 = -1U, upd_x1, upd_y0 = -1U, upd_y1;

/* Update the range already touched by various variables */
void __vesacon_doit(void)
{
    if (upd_x1 > upd_x0 && upd_y1 > upd_y0) {
        vesacon_update_characters(upd_y0, upd_x0, upd_y1 - upd_y0,
                                  upd_x1 - upd_x0);
        upd_x0 = upd_y0 = -1U;
        upd_x1 = upd_y1 = 0;
    }
}

/* Mark a range for update; note argument sequence is the same as
   vesacon_update_characters() */
static inline void vesacon_touch(int row, int col, int rows, int cols)
{
    unsigned int y0 = row;
    unsigned int x0 = col;
    unsigned int y1 = y0 + rows;
    unsigned int x1 = x0 + cols;

    if (y0 < upd_y0)
        upd_y0 = y0;
    if (y1 > upd_y1)
        upd_y1 = y1;
    if (x0 < upd_x0)
        upd_x0 = x0;
    if (x1 > upd_x1)
        upd_x1 = x1;
}

/* Erase a region of the screen */
void __vesacon_erase(int x0, int y0, int x1, int y1, attr_t attr)
{
    int y;
    struct vesa_char *ptr = &__vesacon_text_display
        [(y0 + 1) * (__vesacon_text_cols + 2) + (x0 + 1)];
    struct vesa_char fill = {
        .ch = ' ',
        .attr = attr,
    };
    int ncols = x1 - x0 + 1;

    for (y = y0; y <= y1; y++) {
        vesacon_fill(ptr, fill, ncols);
        ptr += __vesacon_text_cols + 2;
    }

    vesacon_touch(y0, x0, y1 - y0 + 1, ncols);
}

/* Scroll the screen up */
void __vesacon_scroll_up(int nrows, attr_t attr)
{
    struct vesa_char *fromptr = &__vesacon_text_display
        [(nrows + 1) * (__vesacon_text_cols + 2)];
    struct vesa_char *toptr = &__vesacon_text_display
        [(__vesacon_text_cols + 2)];
    int dword_count =
        (__vesacon_text_rows - nrows) * (__vesacon_text_cols + 2);
    struct vesa_char fill = {
        .ch = ' ',
        .attr = attr,
    };

    toptr = copy_dword(toptr, fromptr, dword_count);

    dword_count = nrows * (__vesacon_text_cols + 2);

    vesacon_fill(toptr, fill, dword_count);

    vesacon_touch(0, 0, __vesacon_text_rows, __vesacon_text_cols);
}

/* Draw one character text at a specific area of the screen */
void __vesacon_write_char(int x, int y, uint8_t ch, attr_t attr)
{
    struct vesa_char *ptr = &__vesacon_text_display
        [(y + 1) * (__vesacon_text_cols + 2) + (x + 1)];

    ptr->ch = ch;
    ptr->attr = attr;

    vesacon_touch(y, x, 1, 1);
}

void __vesacon_set_cursor(int x, int y, bool visible)
{
    struct vesa_char *ptr = &__vesacon_text_display
        [(y + 1) * (__vesacon_text_cols + 2) + (x + 1)];

    if (cursor_pointer)
        vesacon_touch(cursor_y, cursor_x, 1, 1);

    if (!visible) {
        /* Invisible cursor */
        cursor_pointer = NULL;
    } else {
        cursor_pointer = ptr;
        vesacon_touch(y, x, 1, 1);
    }

    cursor_x = x;
    cursor_y = y;
}

void __vesacon_init_cursor(int font_height)
{
    int r0 = font_height - (font_height < 10 ? 2 : 3);

    if (r0 < 0)
        r0 = 0;

    memset(cursor_pattern, 0, font_height);
    cursor_pattern[r0] = 0xff;
    cursor_pattern[r0 + 1] = 0xff;
}

void __vesacon_redraw_text(void)
{
    vesacon_update_characters(0, 0, __vesacon_text_rows, __vesacon_text_cols);
}