source: mainline/uspace/srv/fb/fb.c@ a1d89ad

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a1d89ad was 4527fb5, checked in by Jiri Svoboda <jirik.svoboda@…>, 17 years ago

The pre-rendered glyphs are not viewport-specific. This was taking too much time and memory.
  • Property mode set to 100644
File size: 39.3 KB
Line 
1/*
2 * Copyright (c) 2008 Martin Decky
3 * Copyright (c) 2006 Jakub Vana
4 * Copyright (c) 2006 Ondrej Palkovsky
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * - Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * - The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * @defgroup fb Graphical framebuffer
33 * @brief HelenOS graphical framebuffer.
34 * @ingroup fbs
35 * @{
36 */
37
38/** @file
39 */
40
41#include <stdlib.h>
42#include <unistd.h>
43#include <string.h>
44#include <ddi.h>
45#include <sysinfo.h>
46#include <align.h>
47#include <as.h>
48#include <ipc/fb.h>
49#include <ipc/ipc.h>
50#include <ipc/ns.h>
51#include <ipc/services.h>
52#include <kernel/errno.h>
53#include <kernel/genarch/fb/visuals.h>
54#include <console/color.h>
55#include <console/style.h>
56#include <async.h>
57#include <bool.h>
58
59#include "font-8x16.h"
60#include "fb.h"
61#include "main.h"
62#include "../console/screenbuffer.h"
63#include "ppm.h"
64
65#include "pointer.xbm"
66#include "pointer_mask.xbm"
67
68#define DEFAULT_BGCOLOR 0xf0f0f0
69#define DEFAULT_FGCOLOR 0x000000
70
71#define GLYPH_UNAVAIL '?'
72
73#define MAX_ANIM_LEN 8
74#define MAX_ANIMATIONS 4
75#define MAX_PIXMAPS 256 /**< Maximum number of saved pixmaps */
76#define MAX_VIEWPORTS 128 /**< Viewport is a rectangular area on the screen */
77
78/** Function to render a pixel from a RGB value. */
79typedef void (*rgb_conv_t)(void *, uint32_t);
80
81/** Function to draw a glyph. */
82typedef void (*dg_t)(unsigned int x, unsigned int y, bool cursor,
83 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
84
85struct {
86 uint8_t *fb_addr;
87
88 unsigned int xres;
89 unsigned int yres;
90
91 unsigned int scanline;
92 unsigned int glyphscanline;
93
94 unsigned int pixelbytes;
95 unsigned int glyphbytes;
96
97 /** Pre-rendered mask for rendering glyphs. Specific for the visual. */
98 uint8_t *glyphs;
99
100 rgb_conv_t rgb_conv;
101} screen;
102
103/** Backbuffer character cell. */
104typedef struct {
105 uint32_t glyph;
106 uint32_t fg_color;
107 uint32_t bg_color;
108} bb_cell_t;
109
110typedef struct {
111 bool initialized;
112 unsigned int x;
113 unsigned int y;
114 unsigned int width;
115 unsigned int height;
116
117 /* Text support in window */
118 unsigned int cols;
119 unsigned int rows;
120
121 /*
122 * Style and glyphs for text printing
123 */
124
125 /** Current attributes. */
126 attr_rgb_t attr;
127
128 uint8_t *bgpixel;
129
130 /**
131 * Glyph drawing function for this viewport. Different viewports
132 * might use different drawing functions depending on whether their
133 * scanlines are aligned on a word boundary.
134 */
135 dg_t dglyph;
136
137 /* Auto-cursor position */
138 bool cursor_active;
139 unsigned int cur_col;
140 unsigned int cur_row;
141 bool cursor_shown;
142
143 /* Back buffer */
144 bb_cell_t *backbuf;
145 unsigned int bbsize;
146} viewport_t;
147
148typedef struct {
149 bool initialized;
150 bool enabled;
151 unsigned int vp;
152
153 unsigned int pos;
154 unsigned int animlen;
155 unsigned int pixmaps[MAX_ANIM_LEN];
156} animation_t;
157
158static animation_t animations[MAX_ANIMATIONS];
159static bool anims_enabled;
160
161typedef struct {
162 unsigned int width;
163 unsigned int height;
164 uint8_t *data;
165} pixmap_t;
166
167static pixmap_t pixmaps[MAX_PIXMAPS];
168static viewport_t viewports[128];
169
170static bool client_connected = false; /**< Allow only 1 connection */
171
172static uint32_t color_table[16] = {
173 [COLOR_BLACK] = 0x000000,
174 [COLOR_BLUE] = 0x0000f0,
175 [COLOR_GREEN] = 0x00f000,
176 [COLOR_CYAN] = 0x00f0f0,
177 [COLOR_RED] = 0xf00000,
178 [COLOR_MAGENTA] = 0xf000f0,
179 [COLOR_YELLOW] = 0xf0f000,
180 [COLOR_WHITE] = 0xf0f0f0,
181
182 [8 + COLOR_BLACK] = 0x000000,
183 [8 + COLOR_BLUE] = 0x0000ff,
184 [8 + COLOR_GREEN] = 0x00ff00,
185 [8 + COLOR_CYAN] = 0x00ffff,
186 [8 + COLOR_RED] = 0xff0000,
187 [8 + COLOR_MAGENTA] = 0xff00ff,
188 [8 + COLOR_YELLOW] = 0xffff00,
189 [8 + COLOR_WHITE] = 0xffffff,
190};
191
192static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a);
193static int rgb_from_style(attr_rgb_t *rgb, int style);
194static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
195 ipcarg_t bg_color, ipcarg_t flags);
196
197static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
198 ipcarg_t bg_color, ipcarg_t attr);
199
200static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
201 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
202static void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
203 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
204
205static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
206 unsigned int row);
207
208
209#define RED(x, bits) ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
210#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
211#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
212
213#define COL2X(col) ((col) * FONT_WIDTH)
214#define ROW2Y(row) ((row) * FONT_SCANLINES)
215
216#define X2COL(x) ((x) / FONT_WIDTH)
217#define Y2ROW(y) ((y) / FONT_SCANLINES)
218
219#define FB_POS(x, y) ((y) * screen.scanline + (x) * screen.pixelbytes)
220#define BB_POS(vport, col, row) ((row) * vport->cols + (col))
221#define GLYPH_POS(glyph, y, cursor) (((glyph) + (cursor) * FONT_GLYPHS) * screen.glyphbytes + (y) * screen.glyphscanline)
222
223
224/** ARGB 8:8:8:8 conversion
225 *
226 */
227static void rgb_0888(void *dst, uint32_t rgb)
228{
229 *((uint32_t *) dst) = rgb & 0xffffff;
230}
231
232
233/** ABGR 8:8:8:8 conversion
234 *
235 */
236static void bgr_0888(void *dst, uint32_t rgb)
237{
238 *((uint32_t *) dst)
239 = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
240}
241
242
243/** RGB 8:8:8 conversion
244 *
245 */
246static void rgb_888(void *dst, uint32_t rgb)
247{
248 ((uint8_t *) dst)[0] = BLUE(rgb, 8);
249 ((uint8_t *) dst)[1] = GREEN(rgb, 8);
250 ((uint8_t *) dst)[2] = RED(rgb, 8);
251}
252
253
254/** BGR 8:8:8 conversion
255 *
256 */
257static void bgr_888(void *dst, uint32_t rgb)
258{
259 ((uint8_t *) dst)[0] = RED(rgb, 8);
260 ((uint8_t *) dst)[1] = GREEN(rgb, 8);
261 ((uint8_t *) dst)[2] = BLUE(rgb, 8);
262}
263
264
265/** RGB 5:5:5 conversion
266 *
267 */
268static void rgb_555(void *dst, uint32_t rgb)
269{
270 *((uint16_t *) dst)
271 = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
272}
273
274
275/** RGB 5:6:5 conversion
276 *
277 */
278static void rgb_565(void *dst, uint32_t rgb)
279{
280 *((uint16_t *) dst)
281 = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
282}
283
284
285/** RGB 3:2:3
286 *
287 */
288static void rgb_323(void *dst, uint32_t rgb)
289{
290 *((uint8_t *) dst)
291 = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
292}
293
294/** Draw a filled rectangle.
295 *
296 * @note Need real implementation that does not access VRAM twice.
297 */
298static void draw_filled_rect(unsigned int x0, unsigned int y0, unsigned int x1,
299 unsigned int y1, uint32_t color)
300{
301 unsigned int x, y;
302 unsigned int copy_bytes;
303
304 uint8_t *sp, *dp;
305 uint8_t cbuf[4];
306
307 if (y0 >= y1 || x0 >= x1) return;
308 screen.rgb_conv(cbuf, color);
309
310 sp = &screen.fb_addr[FB_POS(x0, y0)];
311 dp = sp;
312
313 /* Draw the first line. */
314 for (x = x0; x < x1; x++) {
315 memcpy(dp, cbuf, screen.pixelbytes);
316 dp += screen.pixelbytes;
317 }
318
319 dp = sp + screen.scanline;
320 copy_bytes = (x1 - x0) * screen.pixelbytes;
321
322 /* Draw the remaining lines by copying. */
323 for (y = y0 + 1; y < y1; y++) {
324 memcpy(dp, sp, copy_bytes);
325 dp += screen.scanline;
326 }
327}
328
329/** Redraw viewport.
330 *
331 * @param vport Viewport to redraw
332 *
333 */
334static void vport_redraw(viewport_t *vport)
335{
336 unsigned int row, col;
337
338 for (row = 0; row < vport->rows; row++) {
339 for (col = 0; col < vport->cols; col++) {
340 draw_vp_glyph(vport, false, col, row);
341 }
342 }
343
344 if (COL2X(vport->cols) < vport->width) {
345 draw_filled_rect(
346 vport->x + COL2X(vport->cols), vport->y,
347 vport->x + vport->width, vport->y + vport->height,
348 vport->attr.bg_color);
349 }
350
351 if (ROW2Y(vport->rows) < vport->height) {
352 draw_filled_rect(
353 vport->x, vport->y + ROW2Y(vport->rows),
354 vport->x + vport->width, vport->y + vport->height,
355 vport->attr.bg_color);
356 }
357}
358
359static void backbuf_clear(bb_cell_t *backbuf, size_t len, uint32_t fg_color,
360 uint32_t bg_color)
361{
362 unsigned i;
363
364 for (i = 0; i < len; i++) {
365 backbuf[i].glyph = 0;
366 backbuf[i].fg_color = fg_color;
367 backbuf[i].bg_color = bg_color;
368 }
369}
370
371/** Clear viewport.
372 *
373 * @param vport Viewport to clear
374 *
375 */
376static void vport_clear(viewport_t *vport)
377{
378 backbuf_clear(vport->backbuf, vport->cols * vport->rows,
379 vport->attr.fg_color, vport->attr.bg_color);
380 vport_redraw(vport);
381}
382
383/** Scroll viewport by the specified number of lines.
384 *
385 * @param vport Viewport to scroll
386 * @param lines Number of lines to scroll
387 *
388 */
389static void vport_scroll(viewport_t *vport, int lines)
390{
391 unsigned int row, col;
392 unsigned int x, y;
393 uint32_t glyph;
394 uint32_t fg_color;
395 uint32_t bg_color;
396 bb_cell_t *bbp, *xbp;
397
398 /*
399 * Redraw.
400 */
401
402 y = vport->y;
403 for (row = 0; row < vport->rows; row++) {
404 x = vport->x;
405 for (col = 0; col < vport->cols; col++) {
406 if ((row + lines >= 0) && (row + lines < vport->rows)) {
407 xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
408 bbp = &vport->backbuf[BB_POS(vport, col, row)];
409
410 glyph = xbp->glyph;
411 fg_color = xbp->fg_color;
412 bg_color = xbp->bg_color;
413
414 if (bbp->glyph == glyph &&
415 bbp->fg_color == xbp->fg_color &&
416 bbp->bg_color == xbp->bg_color) {
417 x += FONT_WIDTH;
418 continue;
419 }
420 } else {
421 glyph = 0;
422 fg_color = vport->attr.fg_color;
423 bg_color = vport->attr.bg_color;
424 }
425
426 (*vport->dglyph)(x, y, false, screen.glyphs, glyph,
427 fg_color, bg_color);
428 x += FONT_WIDTH;
429 }
430 y += FONT_SCANLINES;
431 }
432
433 /*
434 * Scroll backbuffer.
435 */
436
437 if (lines > 0) {
438 memmove(vport->backbuf, vport->backbuf + vport->cols * lines,
439 vport->cols * (vport->rows - lines) * sizeof(bb_cell_t));
440 backbuf_clear(&vport->backbuf[BB_POS(vport, 0, vport->rows - lines)],
441 vport->cols * lines, vport->attr.fg_color, vport->attr.bg_color);
442 } else {
443 memmove(vport->backbuf - vport->cols * lines, vport->backbuf,
444 vport->cols * (vport->rows + lines) * sizeof(bb_cell_t));
445 backbuf_clear(vport->backbuf, - vport->cols * lines,
446 vport->attr.fg_color, vport->attr.bg_color);
447 }
448}
449
450/** Render glyphs
451 *
452 * Convert glyphs from device independent font
453 * description to current visual representation.
454 */
455static void render_glyphs(void)
456{
457 unsigned int glyph;
458
459 for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
460 unsigned int y;
461
462 for (y = 0; y < FONT_SCANLINES; y++) {
463 unsigned int x;
464
465 for (x = 0; x < FONT_WIDTH; x++) {
466 screen.rgb_conv(&screen.glyphs[GLYPH_POS(glyph, y, false) + x * screen.pixelbytes],
467 (fb_font[glyph][y] & (1 << (7 - x)))
468 ? 0xffffff : 0x000000);
469
470 screen.rgb_conv(&screen.glyphs[GLYPH_POS(glyph, y, true) + x * screen.pixelbytes],
471 (fb_font[glyph][y] & (1 << (7 - x)))
472 ? 0x000000 : 0xffffff);
473 }
474 }
475 }
476}
477
478
479/** Create new viewport
480 *
481 * @param x Origin of the viewport (x).
482 * @param y Origin of the viewport (y).
483 * @param width Width of the viewport.
484 * @param height Height of the viewport.
485 *
486 * @return New viewport number.
487 *
488 */
489static int vport_create(unsigned int x, unsigned int y,
490 unsigned int width, unsigned int height)
491{
492 unsigned int i;
493
494 for (i = 0; i < MAX_VIEWPORTS; i++) {
495 if (!viewports[i].initialized)
496 break;
497 }
498 if (i == MAX_VIEWPORTS)
499 return ELIMIT;
500
501 unsigned int cols = width / FONT_WIDTH;
502 unsigned int rows = height / FONT_SCANLINES;
503 unsigned int bbsize = cols * rows * sizeof(bb_cell_t);
504 unsigned int word_size = sizeof(unsigned long);
505
506 bb_cell_t *backbuf = (bb_cell_t *) malloc(bbsize);
507 if (!backbuf)
508 return ENOMEM;
509
510 uint8_t *bgpixel = (uint8_t *) malloc(screen.pixelbytes);
511 if (!bgpixel) {
512 free(backbuf);
513 return ENOMEM;
514 }
515
516 backbuf_clear(backbuf, cols * rows, DEFAULT_FGCOLOR, DEFAULT_BGCOLOR);
517 memset(bgpixel, 0, screen.pixelbytes);
518
519 viewports[i].x = x;
520 viewports[i].y = y;
521 viewports[i].width = width;
522 viewports[i].height = height;
523
524 viewports[i].cols = cols;
525 viewports[i].rows = rows;
526
527 viewports[i].attr.bg_color = DEFAULT_BGCOLOR;
528 viewports[i].attr.fg_color = DEFAULT_FGCOLOR;
529
530 viewports[i].bgpixel = bgpixel;
531
532 /*
533 * Conditions necessary to select aligned version:
534 *
535 * - word size is divisible by pixelbytes
536 * - cell scanline size is divisible by word size
537 * - cell scanlines are word-aligned
538 */
539 if ((word_size % screen.pixelbytes) == 0 &&
540 (FONT_WIDTH * screen.pixelbytes) % word_size == 0 &&
541 (x * screen.pixelbytes) % word_size == 0 &&
542 screen.scanline % word_size == 0) {
543
544 viewports[i].dglyph = draw_glyph_aligned;
545 } else {
546 viewports[i].dglyph = draw_glyph_fallback;
547 }
548
549 viewports[i].cur_col = 0;
550 viewports[i].cur_row = 0;
551 viewports[i].cursor_active = false;
552 viewports[i].cursor_shown = false;
553
554 viewports[i].bbsize = bbsize;
555 viewports[i].backbuf = backbuf;
556
557 viewports[i].initialized = true;
558
559 screen.rgb_conv(viewports[i].bgpixel, viewports[i].attr.bg_color);
560
561 return i;
562}
563
564
565/** Initialize framebuffer as a chardev output device
566 *
567 * @param addr Address of the framebuffer
568 * @param xres Screen width in pixels
569 * @param yres Screen height in pixels
570 * @param visual Bits per pixel (8, 16, 24, 32)
571 * @param scan Bytes per one scanline
572 *
573 */
574static bool screen_init(void *addr, unsigned int xres, unsigned int yres,
575 unsigned int scan, unsigned int visual)
576{
577 unsigned int glyphsize;
578 uint8_t *glyphs;
579 switch (visual) {
580 case VISUAL_INDIRECT_8:
581 screen.rgb_conv = rgb_323;
582 screen.pixelbytes = 1;
583 break;
584 case VISUAL_RGB_5_5_5:
585 screen.rgb_conv = rgb_555;
586 screen.pixelbytes = 2;
587 break;
588 case VISUAL_RGB_5_6_5:
589 screen.rgb_conv = rgb_565;
590 screen.pixelbytes = 2;
591 break;
592 case VISUAL_RGB_8_8_8:
593 screen.rgb_conv = rgb_888;
594 screen.pixelbytes = 3;
595 break;
596 case VISUAL_BGR_8_8_8:
597 screen.rgb_conv = bgr_888;
598 screen.pixelbytes = 3;
599 break;
600 case VISUAL_RGB_8_8_8_0:
601 screen.rgb_conv = rgb_888;
602 screen.pixelbytes = 4;
603 break;
604 case VISUAL_RGB_0_8_8_8:
605 screen.rgb_conv = rgb_0888;
606 screen.pixelbytes = 4;
607 break;
608 case VISUAL_BGR_0_8_8_8:
609 screen.rgb_conv = bgr_0888;
610 screen.pixelbytes = 4;
611 break;
612 default:
613 return false;
614 }
615
616 screen.fb_addr = (unsigned char *) addr;
617 screen.xres = xres;
618 screen.yres = yres;
619 screen.scanline = scan;
620
621 screen.glyphscanline = FONT_WIDTH * screen.pixelbytes;
622 screen.glyphbytes = screen.glyphscanline * FONT_SCANLINES;
623
624 glyphsize = 2 * FONT_GLYPHS * screen.glyphbytes;
625 glyphs = (uint8_t *) malloc(glyphsize);
626 if (!glyphs)
627 return false;
628
629 memset(glyphs, 0, glyphsize);
630 screen.glyphs = glyphs;
631
632 render_glyphs();
633
634 /* Create first viewport */
635 vport_create(0, 0, xres, yres);
636
637 return true;
638}
639
640
641/** Draw a glyph, takes advantage of alignment.
642 *
643 * This version can only be used if the following conditions are met:
644 *
645 * - word size is divisible by pixelbytes
646 * - cell scanline size is divisible by word size
647 * - cell scanlines are word-aligned
648 *
649 * It makes use of the pre-rendered mask to process (possibly) several
650 * pixels at once (word size / pixelbytes pixels at a time are processed)
651 * making it very fast. Most notably this version is not applicable at 24 bits
652 * per pixel.
653 *
654 * @param x x coordinate of top-left corner on screen.
655 * @param y y coordinate of top-left corner on screen.
656 * @param cursor Draw glyph with cursor
657 * @param glyphs Pointer to font bitmap.
658 * @param glyph Code of the glyph to draw.
659 * @param fg_color Foreground color.
660 * @param bg_color Backgroudn color.
661 */
662static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
663 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color)
664{
665 unsigned int i, yd;
666 unsigned long fg_buf, bg_buf;
667 unsigned long *maskp, *dp;
668 unsigned long mask;
669 unsigned int ww, d_add;
670
671 /*
672 * Prepare a pair of words, one filled with foreground-color
673 * pattern and the other filled with background-color pattern.
674 */
675 for (i = 0; i < sizeof(unsigned long) / screen.pixelbytes; i++) {
676 screen.rgb_conv(&((uint8_t *)&fg_buf)[i * screen.pixelbytes],
677 fg_color);
678 screen.rgb_conv(&((uint8_t *)&bg_buf)[i * screen.pixelbytes],
679 bg_color);
680 }
681
682 /* Pointer to the current position in the mask. */
683 maskp = (unsigned long *) &glyphs[GLYPH_POS(glyph, 0, cursor)];
684
685 /* Pointer to the current position on the screen. */
686 dp = (unsigned long *) &screen.fb_addr[FB_POS(x, y)];
687
688 /* Width of the character cell in words. */
689 ww = FONT_WIDTH * screen.pixelbytes / sizeof(unsigned long);
690
691 /* Offset to add when moving to another screen scanline. */
692 d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
693
694 for (yd = 0; yd < FONT_SCANLINES; yd++) {
695 /*
696 * Now process the cell scanline, combining foreground
697 * and background color patters using the pre-rendered mask.
698 */
699 for (i = 0; i < ww; i++) {
700 mask = *maskp++;
701 *dp++ = (fg_buf & mask) | (bg_buf & ~mask);
702 }
703
704 /* Move to the beginning of the next scanline of the cell. */
705 dp = (unsigned long *) ((uint8_t *) dp + d_add);
706 }
707}
708
709/** Draw a glyph, fallback version.
710 *
711 * This version does not make use of the pre-rendered mask, it uses
712 * the font bitmap directly. It works always, but it is slower.
713 *
714 * @param x x coordinate of top-left corner on screen.
715 * @param y y coordinate of top-left corner on screen.
716 * @param cursor Draw glyph with cursor
717 * @param glyphs Pointer to font bitmap.
718 * @param glyph Code of the glyph to draw.
719 * @param fg_color Foreground color.
720 * @param bg_color Backgroudn color.
721 */
722void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
723 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color)
724{
725 unsigned int i, j, yd;
726 uint8_t fg_buf[4], bg_buf[4];
727 uint8_t *dp, *sp;
728 unsigned int d_add;
729 uint8_t b;
730
731 /* Pre-render 1x the foreground and background color pixels. */
732 if (cursor) {
733 screen.rgb_conv(fg_buf, bg_color);
734 screen.rgb_conv(bg_buf, fg_color);
735 } else {
736 screen.rgb_conv(fg_buf, fg_color);
737 screen.rgb_conv(bg_buf, bg_color);
738 }
739
740 /* Pointer to the current position on the screen. */
741 dp = (uint8_t *) &screen.fb_addr[FB_POS(x, y)];
742
743 /* Offset to add when moving to another screen scanline. */
744 d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
745
746 for (yd = 0; yd < FONT_SCANLINES; yd++) {
747 /* Byte containing bits of the glyph scanline. */
748 b = fb_font[glyph][yd];
749
750 for (i = 0; i < FONT_WIDTH; i++) {
751 /* Choose color based on the current bit. */
752 sp = (b & 0x80) ? fg_buf : bg_buf;
753
754 /* Copy the pixel. */
755 for (j = 0; j < screen.pixelbytes; j++) {
756 *dp++ = *sp++;
757 }
758
759 /* Move to the next bit. */
760 b = b << 1;
761 }
762
763 /* Move to the beginning of the next scanline of the cell. */
764 dp += d_add;
765 }
766}
767
768/** Draw glyph at specified position in viewport.
769 *
770 * @param vport Viewport identification
771 * @param cursor Draw glyph with cursor
772 * @param col Screen position relative to viewport
773 * @param row Screen position relative to viewport
774 *
775 */
776static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
777 unsigned int row)
778{
779 unsigned int x = vport->x + COL2X(col);
780 unsigned int y = vport->y + ROW2Y(row);
781
782 uint32_t glyph;
783 uint32_t fg_color;
784 uint32_t bg_color;
785
786 glyph = vport->backbuf[BB_POS(vport, col, row)].glyph;
787 fg_color = vport->backbuf[BB_POS(vport, col, row)].fg_color;
788 bg_color = vport->backbuf[BB_POS(vport, col, row)].bg_color;
789
790 (*vport->dglyph)(x, y, cursor, screen.glyphs, glyph,
791 fg_color, bg_color);
792}
793
794/** Hide cursor if it is shown
795 *
796 */
797static void cursor_hide(viewport_t *vport)
798{
799 if ((vport->cursor_active) && (vport->cursor_shown)) {
800 draw_vp_glyph(vport, false, vport->cur_col, vport->cur_row);
801 vport->cursor_shown = false;
802 }
803}
804
805
806/** Show cursor if cursor showing is enabled
807 *
808 */
809static void cursor_show(viewport_t *vport)
810{
811 /* Do not check for cursor_shown */
812 if (vport->cursor_active) {
813 draw_vp_glyph(vport, true, vport->cur_col, vport->cur_row);
814 vport->cursor_shown = true;
815 }
816}
817
818
819/** Invert cursor, if it is enabled
820 *
821 */
822static void cursor_blink(viewport_t *vport)
823{
824 if (vport->cursor_shown)
825 cursor_hide(vport);
826 else
827 cursor_show(vport);
828}
829
830
831/** Draw character at given position relative to viewport
832 *
833 * @param vport Viewport identification
834 * @param c Character to draw
835 * @param col Screen position relative to viewport
836 * @param row Screen position relative to viewport
837 *
838 */
839static void draw_char(viewport_t *vport, wchar_t c, unsigned int col, unsigned int row)
840{
841 bb_cell_t *bbp;
842
843 /* Do not hide cursor if we are going to overwrite it */
844 if ((vport->cursor_active) && (vport->cursor_shown) &&
845 ((vport->cur_col != col) || (vport->cur_row != row)))
846 cursor_hide(vport);
847
848 bbp = &vport->backbuf[BB_POS(vport, col, row)];
849 bbp->glyph = fb_font_glyph(c);
850 bbp->fg_color = vport->attr.fg_color;
851 bbp->bg_color = vport->attr.bg_color;
852
853 draw_vp_glyph(vport, false, col, row);
854
855 vport->cur_col = col;
856 vport->cur_row = row;
857
858 vport->cur_col++;
859 if (vport->cur_col >= vport->cols) {
860 vport->cur_col = 0;
861 vport->cur_row++;
862 if (vport->cur_row >= vport->rows)
863 vport->cur_row--;
864 }
865
866 cursor_show(vport);
867}
868
869/** Draw text data to viewport.
870 *
871 * @param vport Viewport id
872 * @param data Text data.
873 * @param x Leftmost column of the area.
874 * @param y Topmost row of the area.
875 * @param w Number of rows.
876 * @param h Number of columns.
877 */
878static void draw_text_data(viewport_t *vport, keyfield_t *data, unsigned int x,
879 unsigned int y, unsigned int w, unsigned int h)
880{
881 unsigned int i, j;
882 bb_cell_t *bbp;
883 attrs_t *a;
884 attr_rgb_t rgb;
885
886 for (j = 0; j < h; j++) {
887 for (i = 0; i < w; i++) {
888 unsigned int col = x + i;
889 unsigned int row = y + j;
890
891 bbp = &vport->backbuf[BB_POS(vport, col, row)];
892
893 a = &data[j * w + i].attrs;
894 rgb_from_attr(&rgb, a);
895
896 bbp->glyph = fb_font_glyph(data[j * w + i].character);
897 bbp->fg_color = rgb.fg_color;
898 bbp->bg_color = rgb.bg_color;
899
900 draw_vp_glyph(vport, false, col, row);
901 }
902 }
903 cursor_show(vport);
904}
905
906
907static void putpixel_pixmap(void *data, unsigned int x, unsigned int y, uint32_t color)
908{
909 int pm = *((int *) data);
910 pixmap_t *pmap = &pixmaps[pm];
911 unsigned int pos = (y * pmap->width + x) * screen.pixelbytes;
912
913 screen.rgb_conv(&pmap->data[pos], color);
914}
915
916
917static void putpixel(void *data, unsigned int x, unsigned int y, uint32_t color)
918{
919 viewport_t *vport = (viewport_t *) data;
920 unsigned int dx = vport->x + x;
921 unsigned int dy = vport->y + y;
922
923 screen.rgb_conv(&screen.fb_addr[FB_POS(dx, dy)], color);
924}
925
926
927/** Return first free pixmap
928 *
929 */
930static int find_free_pixmap(void)
931{
932 unsigned int i;
933
934 for (i = 0; i < MAX_PIXMAPS; i++)
935 if (!pixmaps[i].data)
936 return i;
937
938 return -1;
939}
940
941
942/** Create a new pixmap and return appropriate ID
943 *
944 */
945static int shm2pixmap(unsigned char *shm, size_t size)
946{
947 int pm;
948 pixmap_t *pmap;
949
950 pm = find_free_pixmap();
951 if (pm == -1)
952 return ELIMIT;
953
954 pmap = &pixmaps[pm];
955
956 if (ppm_get_data(shm, size, &pmap->width, &pmap->height))
957 return EINVAL;
958
959 pmap->data = malloc(pmap->width * pmap->height * screen.pixelbytes);
960 if (!pmap->data)
961 return ENOMEM;
962
963 ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, putpixel_pixmap, (void *) &pm);
964
965 return pm;
966}
967
968
969/** Handle shared memory communication calls
970 *
971 * Protocol for drawing pixmaps:
972 * - FB_PREPARE_SHM(client shm identification)
973 * - IPC_M_AS_AREA_SEND
974 * - FB_DRAW_PPM(startx, starty)
975 * - FB_DROP_SHM
976 *
977 * Protocol for text drawing
978 * - IPC_M_AS_AREA_SEND
979 * - FB_DRAW_TEXT_DATA
980 *
981 * @param callid Callid of the current call
982 * @param call Current call data
983 * @param vp Active viewport
984 *
985 * @return false if the call was not handled byt this function, true otherwise
986 *
987 * Note: this function is not threads safe, you would have
988 * to redefine static variables with __thread
989 *
990 */
991static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
992{
993 static keyfield_t *interbuffer = NULL;
994 static size_t intersize = 0;
995
996 static unsigned char *shm = NULL;
997 static ipcarg_t shm_id = 0;
998 static size_t shm_size;
999
1000 bool handled = true;
1001 int retval = EOK;
1002 viewport_t *vport = &viewports[vp];
1003 unsigned int x;
1004 unsigned int y;
1005 unsigned int w;
1006 unsigned int h;
1007
1008 switch (IPC_GET_METHOD(*call)) {
1009 case IPC_M_SHARE_OUT:
1010 /* We accept one area for data interchange */
1011 if (IPC_GET_ARG1(*call) == shm_id) {
1012 void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
1013 shm_size = IPC_GET_ARG2(*call);
1014 if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
1015 shm = dest;
1016 else
1017 shm_id = 0;
1018
1019 if (shm[0] != 'P')
1020 return false;
1021
1022 return true;
1023 } else {
1024 intersize = IPC_GET_ARG2(*call);
1025 receive_comm_area(callid, call, (void *) &interbuffer);
1026 }
1027 return true;
1028 case FB_PREPARE_SHM:
1029 if (shm_id)
1030 retval = EBUSY;
1031 else
1032 shm_id = IPC_GET_ARG1(*call);
1033 break;
1034
1035 case FB_DROP_SHM:
1036 if (shm) {
1037 as_area_destroy(shm);
1038 shm = NULL;
1039 }
1040 shm_id = 0;
1041 break;
1042
1043 case FB_SHM2PIXMAP:
1044 if (!shm) {
1045 retval = EINVAL;
1046 break;
1047 }
1048 retval = shm2pixmap(shm, shm_size);
1049 break;
1050 case FB_DRAW_PPM:
1051 if (!shm) {
1052 retval = EINVAL;
1053 break;
1054 }
1055 x = IPC_GET_ARG1(*call);
1056 y = IPC_GET_ARG2(*call);
1057
1058 if ((x > vport->width) || (y > vport->height)) {
1059 retval = EINVAL;
1060 break;
1061 }
1062
1063 ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
1064 IPC_GET_ARG2(*call), vport->width - x, vport->height - y, putpixel, (void *) vport);
1065 break;
1066 case FB_DRAW_TEXT_DATA:
1067 x = IPC_GET_ARG1(*call);
1068 y = IPC_GET_ARG2(*call);
1069 w = IPC_GET_ARG3(*call);
1070 h = IPC_GET_ARG4(*call);
1071 if (!interbuffer) {
1072 retval = EINVAL;
1073 break;
1074 }
1075 if (x + w > vport->cols || y + h > vport->rows) {
1076 retval = EINVAL;
1077 break;
1078 }
1079 if (intersize < w * h * sizeof(*interbuffer)) {
1080 retval = EINVAL;
1081 break;
1082 }
1083 draw_text_data(vport, interbuffer, x, y, w, h);
1084 break;
1085 default:
1086 handled = false;
1087 }
1088
1089 if (handled)
1090 ipc_answer_0(callid, retval);
1091 return handled;
1092}
1093
1094
1095static void copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
1096{
1097 unsigned int width = vport->width;
1098 unsigned int height = vport->height;
1099
1100 if (width + vport->x > screen.xres)
1101 width = screen.xres - vport->x;
1102 if (height + vport->y > screen.yres)
1103 height = screen.yres - vport->y;
1104
1105 unsigned int realwidth = pmap->width <= width ? pmap->width : width;
1106 unsigned int realheight = pmap->height <= height ? pmap->height : height;
1107
1108 unsigned int srcrowsize = vport->width * screen.pixelbytes;
1109 unsigned int realrowsize = realwidth * screen.pixelbytes;
1110
1111 unsigned int y;
1112 for (y = 0; y < realheight; y++) {
1113 unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
1114 memcpy(pmap->data + srcrowsize * y, screen.fb_addr + tmp, realrowsize);
1115 }
1116}
1117
1118
1119/** Save viewport to pixmap
1120 *
1121 */
1122static int save_vp_to_pixmap(viewport_t *vport)
1123{
1124 int pm;
1125 pixmap_t *pmap;
1126
1127 pm = find_free_pixmap();
1128 if (pm == -1)
1129 return ELIMIT;
1130
1131 pmap = &pixmaps[pm];
1132 pmap->data = malloc(screen.pixelbytes * vport->width * vport->height);
1133 if (!pmap->data)
1134 return ENOMEM;
1135
1136 pmap->width = vport->width;
1137 pmap->height = vport->height;
1138
1139 copy_vp_to_pixmap(vport, pmap);
1140
1141 return pm;
1142}
1143
1144
1145/** Draw pixmap on screen
1146 *
1147 * @param vp Viewport to draw on
1148 * @param pm Pixmap identifier
1149 *
1150 */
1151static int draw_pixmap(int vp, int pm)
1152{
1153 pixmap_t *pmap = &pixmaps[pm];
1154 viewport_t *vport = &viewports[vp];
1155
1156 unsigned int width = vport->width;
1157 unsigned int height = vport->height;
1158
1159 if (width + vport->x > screen.xres)
1160 width = screen.xres - vport->x;
1161 if (height + vport->y > screen.yres)
1162 height = screen.yres - vport->y;
1163
1164 if (!pmap->data)
1165 return EINVAL;
1166
1167 unsigned int realwidth = pmap->width <= width ? pmap->width : width;
1168 unsigned int realheight = pmap->height <= height ? pmap->height : height;
1169
1170 unsigned int srcrowsize = vport->width * screen.pixelbytes;
1171 unsigned int realrowsize = realwidth * screen.pixelbytes;
1172
1173 unsigned int y;
1174 for (y = 0; y < realheight; y++) {
1175 unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
1176 memcpy(screen.fb_addr + tmp, pmap->data + y * srcrowsize, realrowsize);
1177 }
1178
1179 return EOK;
1180}
1181
1182
1183/** Tick animation one step forward
1184 *
1185 */
1186static void anims_tick(void)
1187{
1188 unsigned int i;
1189 static int counts = 0;
1190
1191 /* Limit redrawing */
1192 counts = (counts + 1) % 8;
1193 if (counts)
1194 return;
1195
1196 for (i = 0; i < MAX_ANIMATIONS; i++) {
1197 if ((!animations[i].animlen) || (!animations[i].initialized) ||
1198 (!animations[i].enabled))
1199 continue;
1200
1201 draw_pixmap(animations[i].vp, animations[i].pixmaps[animations[i].pos]);
1202 animations[i].pos = (animations[i].pos + 1) % animations[i].animlen;
1203 }
1204}
1205
1206
1207static unsigned int pointer_x;
1208static unsigned int pointer_y;
1209static bool pointer_shown, pointer_enabled;
1210static int pointer_vport = -1;
1211static int pointer_pixmap = -1;
1212
1213
1214static void mouse_show(void)
1215{
1216 int i, j;
1217 int visibility;
1218 int color;
1219 int bytepos;
1220
1221 if ((pointer_shown) || (!pointer_enabled))
1222 return;
1223
1224 /* Save image under the pointer. */
1225 if (pointer_vport == -1) {
1226 pointer_vport = vport_create(pointer_x, pointer_y, pointer_width, pointer_height);
1227 if (pointer_vport < 0)
1228 return;
1229 } else {
1230 viewports[pointer_vport].x = pointer_x;
1231 viewports[pointer_vport].y = pointer_y;
1232 }
1233
1234 if (pointer_pixmap == -1)
1235 pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]);
1236 else
1237 copy_vp_to_pixmap(&viewports[pointer_vport], &pixmaps[pointer_pixmap]);
1238
1239 /* Draw mouse pointer. */
1240 for (i = 0; i < pointer_height; i++)
1241 for (j = 0; j < pointer_width; j++) {
1242 bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
1243 visibility = pointer_mask_bits[bytepos] &
1244 (1 << (j % 8));
1245 if (visibility) {
1246 color = pointer_bits[bytepos] &
1247 (1 << (j % 8)) ? 0 : 0xffffff;
1248 if (pointer_x + j < screen.xres && pointer_y +
1249 i < screen.yres)
1250 putpixel(&viewports[0], pointer_x + j,
1251 pointer_y + i, color);
1252 }
1253 }
1254 pointer_shown = 1;
1255}
1256
1257
1258static void mouse_hide(void)
1259{
1260 /* Restore image under the pointer. */
1261 if (pointer_shown) {
1262 draw_pixmap(pointer_vport, pointer_pixmap);
1263 pointer_shown = 0;
1264 }
1265}
1266
1267
1268static void mouse_move(unsigned int x, unsigned int y)
1269{
1270 mouse_hide();
1271 pointer_x = x;
1272 pointer_y = y;
1273 mouse_show();
1274}
1275
1276
1277static int anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1278{
1279 bool handled = true;
1280 int retval = EOK;
1281 int i, nvp;
1282 int newval;
1283
1284 switch (IPC_GET_METHOD(*call)) {
1285 case FB_ANIM_CREATE:
1286 nvp = IPC_GET_ARG1(*call);
1287 if (nvp == -1)
1288 nvp = vp;
1289 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1290 !viewports[nvp].initialized) {
1291 retval = EINVAL;
1292 break;
1293 }
1294 for (i = 0; i < MAX_ANIMATIONS; i++) {
1295 if (!animations[i].initialized)
1296 break;
1297 }
1298 if (i == MAX_ANIMATIONS) {
1299 retval = ELIMIT;
1300 break;
1301 }
1302 animations[i].initialized = 1;
1303 animations[i].animlen = 0;
1304 animations[i].pos = 0;
1305 animations[i].enabled = 0;
1306 animations[i].vp = nvp;
1307 retval = i;
1308 break;
1309 case FB_ANIM_DROP:
1310 i = IPC_GET_ARG1(*call);
1311 if (i >= MAX_ANIMATIONS || i < 0) {
1312 retval = EINVAL;
1313 break;
1314 }
1315 animations[i].initialized = 0;
1316 break;
1317 case FB_ANIM_ADDPIXMAP:
1318 i = IPC_GET_ARG1(*call);
1319 if (i >= MAX_ANIMATIONS || i < 0 ||
1320 !animations[i].initialized) {
1321 retval = EINVAL;
1322 break;
1323 }
1324 if (animations[i].animlen == MAX_ANIM_LEN) {
1325 retval = ELIMIT;
1326 break;
1327 }
1328 newval = IPC_GET_ARG2(*call);
1329 if (newval < 0 || newval > MAX_PIXMAPS ||
1330 !pixmaps[newval].data) {
1331 retval = EINVAL;
1332 break;
1333 }
1334 animations[i].pixmaps[animations[i].animlen++] = newval;
1335 break;
1336 case FB_ANIM_CHGVP:
1337 i = IPC_GET_ARG1(*call);
1338 if (i >= MAX_ANIMATIONS || i < 0) {
1339 retval = EINVAL;
1340 break;
1341 }
1342 nvp = IPC_GET_ARG2(*call);
1343 if (nvp == -1)
1344 nvp = vp;
1345 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1346 !viewports[nvp].initialized) {
1347 retval = EINVAL;
1348 break;
1349 }
1350 animations[i].vp = nvp;
1351 break;
1352 case FB_ANIM_START:
1353 case FB_ANIM_STOP:
1354 i = IPC_GET_ARG1(*call);
1355 if (i >= MAX_ANIMATIONS || i < 0) {
1356 retval = EINVAL;
1357 break;
1358 }
1359 newval = (IPC_GET_METHOD(*call) == FB_ANIM_START);
1360 if (newval ^ animations[i].enabled) {
1361 animations[i].enabled = newval;
1362 anims_enabled += newval ? 1 : -1;
1363 }
1364 break;
1365 default:
1366 handled = 0;
1367 }
1368 if (handled)
1369 ipc_answer_0(callid, retval);
1370 return handled;
1371}
1372
1373
1374/** Handler for messages concerning pixmap handling
1375 *
1376 */
1377static int pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1378{
1379 bool handled = true;
1380 int retval = EOK;
1381 int i, nvp;
1382
1383 switch (IPC_GET_METHOD(*call)) {
1384 case FB_VP_DRAW_PIXMAP:
1385 nvp = IPC_GET_ARG1(*call);
1386 if (nvp == -1)
1387 nvp = vp;
1388 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1389 !viewports[nvp].initialized) {
1390 retval = EINVAL;
1391 break;
1392 }
1393 i = IPC_GET_ARG2(*call);
1394 retval = draw_pixmap(nvp, i);
1395 break;
1396 case FB_VP2PIXMAP:
1397 nvp = IPC_GET_ARG1(*call);
1398 if (nvp == -1)
1399 nvp = vp;
1400 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1401 !viewports[nvp].initialized)
1402 retval = EINVAL;
1403 else
1404 retval = save_vp_to_pixmap(&viewports[nvp]);
1405 break;
1406 case FB_DROP_PIXMAP:
1407 i = IPC_GET_ARG1(*call);
1408 if (i >= MAX_PIXMAPS) {
1409 retval = EINVAL;
1410 break;
1411 }
1412 if (pixmaps[i].data) {
1413 free(pixmaps[i].data);
1414 pixmaps[i].data = NULL;
1415 }
1416 break;
1417 default:
1418 handled = 0;
1419 }
1420
1421 if (handled)
1422 ipc_answer_0(callid, retval);
1423 return handled;
1424
1425}
1426
1427static int rgb_from_style(attr_rgb_t *rgb, int style)
1428{
1429 switch (style) {
1430 case STYLE_NORMAL:
1431 rgb->fg_color = color_table[COLOR_BLACK];
1432 rgb->bg_color = color_table[COLOR_WHITE];
1433 break;
1434 case STYLE_EMPHASIS:
1435 rgb->fg_color = color_table[COLOR_RED];
1436 rgb->bg_color = color_table[COLOR_WHITE];
1437 break;
1438 default:
1439 return EINVAL;
1440 }
1441
1442 return EOK;
1443}
1444
1445static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
1446 ipcarg_t bg_color, ipcarg_t flags)
1447{
1448 fg_color = (fg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
1449 bg_color = (bg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
1450
1451 rgb->fg_color = color_table[fg_color];
1452 rgb->bg_color = color_table[bg_color];
1453
1454 return EOK;
1455}
1456
1457static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a)
1458{
1459 int rc;
1460
1461 switch (a->t) {
1462 case at_style:
1463 rc = rgb_from_style(rgb, a->a.s.style);
1464 break;
1465 case at_idx:
1466 rc = rgb_from_idx(rgb, a->a.i.fg_color,
1467 a->a.i.bg_color, a->a.i.flags);
1468 break;
1469 case at_rgb:
1470 *rgb = a->a.r;
1471 rc = EOK;
1472 break;
1473 }
1474
1475 return rc;
1476}
1477
1478static int fb_set_style(viewport_t *vport, ipcarg_t style)
1479{
1480 return rgb_from_style(&vport->attr, (int) style);
1481}
1482
1483static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
1484 ipcarg_t bg_color, ipcarg_t flags)
1485{
1486 return rgb_from_idx(&vport->attr, fg_color, bg_color, flags);
1487}
1488
1489/** Function for handling connections to FB
1490 *
1491 */
1492static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
1493{
1494 unsigned int vp = 0;
1495 viewport_t *vport = &viewports[vp];
1496
1497 if (client_connected) {
1498 ipc_answer_0(iid, ELIMIT);
1499 return;
1500 }
1501
1502 /* Accept connection */
1503 client_connected = true;
1504 ipc_answer_0(iid, EOK);
1505
1506 while (true) {
1507 ipc_callid_t callid;
1508 ipc_call_t call;
1509 int retval;
1510 unsigned int i;
1511 int scroll;
1512 wchar_t ch;
1513 unsigned int row, col;
1514
1515 if ((vport->cursor_active) || (anims_enabled))
1516 callid = async_get_call_timeout(&call, 250000);
1517 else
1518 callid = async_get_call(&call);
1519
1520 mouse_hide();
1521 if (!callid) {
1522 cursor_blink(vport);
1523 anims_tick();
1524 mouse_show();
1525 continue;
1526 }
1527
1528 if (shm_handle(callid, &call, vp))
1529 continue;
1530
1531 if (pixmap_handle(callid, &call, vp))
1532 continue;
1533
1534 if (anim_handle(callid, &call, vp))
1535 continue;
1536
1537 switch (IPC_GET_METHOD(call)) {
1538 case IPC_M_PHONE_HUNGUP:
1539 client_connected = false;
1540
1541 /* Cleanup other viewports */
1542 for (i = 1; i < MAX_VIEWPORTS; i++)
1543 vport->initialized = false;
1544
1545 /* Exit thread */
1546 return;
1547
1548 case FB_PUTCHAR:
1549 ch = IPC_GET_ARG1(call);
1550 row = IPC_GET_ARG2(call);
1551 col = IPC_GET_ARG3(call);
1552
1553 if ((col >= vport->cols) || (row >= vport->rows)) {
1554 retval = EINVAL;
1555 break;
1556 }
1557 ipc_answer_0(callid, EOK);
1558
1559 draw_char(vport, ch, col, row);
1560
1561 /* Message already answered */
1562 continue;
1563 case FB_CLEAR:
1564 vport_clear(vport);
1565 cursor_show(vport);
1566 retval = EOK;
1567 break;
1568 case FB_CURSOR_GOTO:
1569 row = IPC_GET_ARG1(call);
1570 col = IPC_GET_ARG2(call);
1571
1572 if ((col >= vport->cols) || (row >= vport->rows)) {
1573 retval = EINVAL;
1574 break;
1575 }
1576 retval = EOK;
1577
1578 cursor_hide(vport);
1579 vport->cur_col = col;
1580 vport->cur_row = row;
1581 cursor_show(vport);
1582 break;
1583 case FB_CURSOR_VISIBILITY:
1584 cursor_hide(vport);
1585 vport->cursor_active = IPC_GET_ARG1(call);
1586 cursor_show(vport);
1587 retval = EOK;
1588 break;
1589 case FB_GET_CSIZE:
1590 ipc_answer_2(callid, EOK, vport->rows, vport->cols);
1591 continue;
1592 case FB_SCROLL:
1593 scroll = IPC_GET_ARG1(call);
1594 if ((scroll > (int) vport->rows) || (scroll < (-(int) vport->rows))) {
1595 retval = EINVAL;
1596 break;
1597 }
1598 cursor_hide(vport);
1599 vport_scroll(vport, scroll);
1600 cursor_show(vport);
1601 retval = EOK;
1602 break;
1603 case FB_VIEWPORT_SWITCH:
1604 i = IPC_GET_ARG1(call);
1605 if (i >= MAX_VIEWPORTS) {
1606 retval = EINVAL;
1607 break;
1608 }
1609 if (!viewports[i].initialized) {
1610 retval = EADDRNOTAVAIL;
1611 break;
1612 }
1613 cursor_hide(vport);
1614 vp = i;
1615 vport = &viewports[vp];
1616 cursor_show(vport);
1617 retval = EOK;
1618 break;
1619 case FB_VIEWPORT_CREATE:
1620 retval = vport_create(IPC_GET_ARG1(call) >> 16,
1621 IPC_GET_ARG1(call) & 0xffff,
1622 IPC_GET_ARG2(call) >> 16,
1623 IPC_GET_ARG2(call) & 0xffff);
1624 break;
1625 case FB_VIEWPORT_DELETE:
1626 i = IPC_GET_ARG1(call);
1627 if (i >= MAX_VIEWPORTS) {
1628 retval = EINVAL;
1629 break;
1630 }
1631 if (!viewports[i].initialized) {
1632 retval = EADDRNOTAVAIL;
1633 break;
1634 }
1635 viewports[i].initialized = false;
1636 if (viewports[i].bgpixel)
1637 free(viewports[i].bgpixel);
1638 if (viewports[i].backbuf)
1639 free(viewports[i].backbuf);
1640 retval = EOK;
1641 break;
1642 case FB_SET_STYLE:
1643 retval = fb_set_style(vport, IPC_GET_ARG1(call));
1644 break;
1645 case FB_SET_COLOR:
1646 retval = fb_set_color(vport, IPC_GET_ARG1(call),
1647 IPC_GET_ARG2(call), IPC_GET_ARG3(call));
1648 break;
1649 case FB_SET_RGB_COLOR:
1650 vport->attr.fg_color = IPC_GET_ARG1(call);
1651 vport->attr.bg_color = IPC_GET_ARG2(call);
1652 retval = EOK;
1653 break;
1654 case FB_GET_RESOLUTION:
1655 ipc_answer_2(callid, EOK, screen.xres, screen.yres);
1656 continue;
1657 case FB_POINTER_MOVE:
1658 pointer_enabled = true;
1659 mouse_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
1660 retval = EOK;
1661 break;
1662 default:
1663 retval = ENOENT;
1664 }
1665 ipc_answer_0(callid, retval);
1666 }
1667}
1668
1669/** Initialization of framebuffer
1670 *
1671 */
1672int fb_init(void)
1673{
1674 async_set_client_connection(fb_client_connection);
1675
1676 void *fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
1677 unsigned int fb_offset = sysinfo_value("fb.offset");
1678 unsigned int fb_width = sysinfo_value("fb.width");
1679 unsigned int fb_height = sysinfo_value("fb.height");
1680 unsigned int fb_scanline = sysinfo_value("fb.scanline");
1681 unsigned int fb_visual = sysinfo_value("fb.visual");
1682
1683 unsigned int fbsize = fb_scanline * fb_height;
1684 void *fb_addr = as_get_mappable_page(fbsize);
1685
1686 if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
1687 ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
1688 return -1;
1689
1690 if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
1691 return 0;
1692
1693 return -1;
1694}
1695
1696/**
1697 * @}
1698 */
Note: See TracBrowser for help on using the repository browser.