aboutsummaryrefslogtreecommitdiffstats
path: root/com32/lib/sys/vesa/efi/drawtxt.c
blob: 85a9e9746d960f6a2444fd2b1335b58ba0fcf039 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
/* ----------------------------------------------------------------------- *
 *
 *   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);
}