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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since cc1f8d4 was 19490ce, checked in by Jakub Jermar <jakub@…>, 16 years ago

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