WebSVN – HelenOS – Diff – /branches/dynload/uspace/srv/fb/fb.c

 #include <ipc/ipc.h>
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <kernel/errno.h>
 #include <kernel/genarch/fb/visuals.h>
-#include <console/color.h>
+#include <io/color.h>
-#include <console/style.h>
+#include <io/style.h>
 #include <async.h>
+#include <fibril.h>
 #include <bool.h>
+#include <stdio.h>
+#include <byteorder.h>
 #include "font-8x16.h"
 #include "fb.h"
 #include "main.h"
 #include "../console/screenbuffer.h"
 static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
     unsigned int row);
-#define RED(x, bits)                 ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
+#define RED(x, bits)                 (((x) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1))
-#define GREEN(x, bits)               ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
+#define GREEN(x, bits)               (((x) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1))
-#define BLUE(x, bits)                ((x >> (8 - bits)) & ((1 << bits) - 1))
+#define BLUE(x, bits)                (((x) >> (8 - (bits))) & ((1 << (bits)) - 1))
 #define COL2X(col)                   ((col) * FONT_WIDTH)
 #define ROW2Y(row)                   ((row) * FONT_SCANLINES)
 #define X2COL(x)                     ((x) / FONT_WIDTH)
 #define FB_POS(x, y)                 ((y) * screen.scanline + (x) * screen.pixelbytes)
 #define BB_POS(vport, col, row)      ((row) * vport->cols + (col))
 #define GLYPH_POS(glyph, y, cursor)  (((glyph) + (cursor) * FONT_GLYPHS) * screen.glyphbytes + (y) * screen.glyphscanline)
+/*
-/** ARGB 8:8:8:8 conversion
+ * RGB conversion and mask functions.
+ *
+ * These functions write an RGB value to some memory in some predefined format.
+ * The naming convention corresponds to the format created by these functions.
+ * The functions use the so called network order (i.e. big endian) with respect
+ * to their names.
  */
 static void rgb_0888(void *dst, uint32_t rgb)
+{
-    *((uint32_t *) dst) = rgb & 0x00ffffff;
+    *((uint32_t *) dst) = host2uint32_t_be((0 << 24) |
+        (RED(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | (BLUE(rgb, 8)));
+}
+static void bgr_0888(void *dst, uint32_t rgb)
+{
+    *((uint32_t *) dst) = host2uint32_t_be((0 << 24) |
+        (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | (RED(rgb, 8)));
+}
 static void mask_0888(void *dst, bool mask)
+{
-    *((uint32_t *) dst) = (mask ? 0x00ffffff : 0);
+    bgr_0888(dst, mask ? 0xffffff : 0);
+}
+static void rgb_8880(void *dst, uint32_t rgb)
+{
+    *((uint32_t *) dst) = host2uint32_t_be((RED(rgb, 8) << 24) |
+        (GREEN(rgb, 8) << 16) | (BLUE(rgb, 8) << 8) | 0);
+}
-/** ABGR 8:8:8:8 conversion
- *
- */
-static void bgr_0888(void *dst, uint32_t rgb)
+static void bgr_8880(void *dst, uint32_t rgb)
+{
-    *((uint32_t *) dst)
+    *((uint32_t *) dst) = host2uint32_t_be((BLUE(rgb, 8) << 24) |
-        = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
+        (GREEN(rgb, 8) << 16) | (RED(rgb, 8) << 8) | 0);
+}
+static void mask_8880(void *dst, bool mask)
+{
+    bgr_8880(dst, mask ? 0xffffff : 0);
+}
-/** RGB 8:8:8 conversion
- *
- */
 static void rgb_888(void *dst, uint32_t rgb)
+{
+    ((uint8_t *) dst)[0] = RED(rgb, 8);
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
+    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
+}
+static void bgr_888(void *dst, uint32_t rgb)
+{
     ((uint8_t *) dst)[0] = BLUE(rgb, 8);
     ((uint8_t *) dst)[1] = GREEN(rgb, 8);
     ((uint8_t *) dst)[2] = RED(rgb, 8);
+}
 static void mask_888(void *dst, bool mask)
+{
-    if (mask) {
-        ((uint8_t *) dst)[0] = 0xff;
-        ((uint8_t *) dst)[1] = 0xff;
-        ((uint8_t *) dst)[2] = 0xff;
-    } else {
-        ((uint8_t *) dst)[0] = 0;
-        ((uint8_t *) dst)[1] = 0;
-        ((uint8_t *) dst)[2] = 0;
+    bgr_888(dst, mask ? 0xffffff : 0);
-    }
+}
-/** BGR 8:8:8 conversion
- *
- */
-static void bgr_888(void *dst, uint32_t rgb)
+static void rgb_555_be(void *dst, uint32_t rgb)
+{
-    ((uint8_t *) dst)[0] = RED(rgb, 8);
+    *((uint16_t *) dst) = host2uint16_t_be(RED(rgb, 5) << 10 |
-    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
-    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
+        GREEN(rgb, 5) << 5 | BLUE(rgb, 5));
+}
-/** RGB 5:5:5 conversion
- *
- */
-static void rgb_555(void *dst, uint32_t rgb)
+static void rgb_555_le(void *dst, uint32_t rgb)
+{
-    *((uint16_t *) dst)
+    *((uint16_t *) dst) = host2uint16_t_le(RED(rgb, 5) << 10 |
-        = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
+        GREEN(rgb, 5) << 5 | BLUE(rgb, 5));
+}
-static void mask_555(void *dst, bool mask)
+static void rgb_565_be(void *dst, uint32_t rgb)
+{
-    *((uint16_t *) dst) = (mask ? 0x7fff : 0);
+    *((uint16_t *) dst) = host2uint16_t_be(RED(rgb, 5) << 11 |
+        GREEN(rgb, 6) << 5 | BLUE(rgb, 5));
+}
+static void rgb_565_le(void *dst, uint32_t rgb)
+{
+    *((uint16_t *) dst) = host2uint16_t_le(RED(rgb, 5) << 11 |
+        GREEN(rgb, 6) << 5 | BLUE(rgb, 5));
+}
-/** RGB 5:6:5 conversion
- *
- */
-static void rgb_565(void *dst, uint32_t rgb)
+static void mask_555(void *dst, bool mask)
+{
-    *((uint16_t *) dst)
-        = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
+    rgb_555_be(dst, mask ? 0xffffff : 0);
+}
 static void mask_565(void *dst, bool mask)
+{
-    *((uint16_t *) dst) = (mask ? 0xffff : 0);
+    rgb_565_be(dst, mask ? 0xffffff : 0);
+}
-/** RGB 3:2:3
- *
- */
-static void rgb_323(void *dst, uint32_t rgb)
+static void bgr_323(void *dst, uint32_t rgb)
+{
     *((uint8_t *) dst)
         = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
+}
 static void mask_323(void *dst, bool mask)
+{
-    *((uint8_t *) dst) = (mask ? 0xff : 0);
+    bgr_323(dst, mask ? 0x0 : ~0x0);
+}
 /** Draw a filled rectangle.
+ *
  * @note Need real implementation that does not access VRAM twice.
  * @param vport Viewport to redraw
+ *
  */
 static void vport_redraw(viewport_t *vport)
+{
-    unsigned int row;
     unsigned int col;
+    unsigned int row;
     for (row = 0; row < vport->rows; row++) {
         for (col = 0; col < vport->cols; col++) {
             draw_vp_glyph(vport, false, col, row);
+        }
  * @param lines Number of lines to scroll
+ *
  */
 static void vport_scroll(viewport_t *vport, int lines)
+{
-    unsigned int row;
     unsigned int col;
+    unsigned int row;
     unsigned int x;
     unsigned int y;
     uint32_t glyph;
     uint32_t fg_color;
     uint32_t bg_color;
     y = vport->y;
     for (row = 0; row < vport->rows; row++) {
         x = vport->x;
         for (col = 0; col < vport->cols; col++) {
+            if (((int) row + lines >= 0) &&
-            if ((row + lines >= 0) && (row + lines < vport->rows)) {
+                ((int) row + lines < (int) vport->rows)) {
                 xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
                 bbp = &vport->backbuf[BB_POS(vport, col, row)];
                 glyph = xbp->glyph;
                 fg_color = xbp->fg_color;
+ *
  */
 static bool screen_init(void *addr, unsigned int xres, unsigned int yres,
     unsigned int scan, unsigned int visual)
+{
     switch (visual) {
     case VISUAL_INDIRECT_8:
-        screen.rgb_conv = rgb_323;
+        screen.rgb_conv = bgr_323;
         screen.mask_conv = mask_323;
         screen.pixelbytes = 1;
         break;
-    case VISUAL_RGB_5_5_5:
+    case VISUAL_RGB_5_5_5_LE:
+        screen.rgb_conv = rgb_555_le;
+        screen.mask_conv = mask_555;
+        screen.pixelbytes = 2;
+        break;
+    case VISUAL_RGB_5_5_5_BE:
-        screen.rgb_conv = rgb_555;
+        screen.rgb_conv = rgb_555_be;
         screen.mask_conv = mask_555;
         screen.pixelbytes = 2;
         break;
-    case VISUAL_RGB_5_6_5:
+    case VISUAL_RGB_5_6_5_LE:
+        screen.rgb_conv = rgb_565_le;
+        screen.mask_conv = mask_565;
+        screen.pixelbytes = 2;
+        break;
+    case VISUAL_RGB_5_6_5_BE:
-        screen.rgb_conv = rgb_565;
+        screen.rgb_conv = rgb_565_be;
         screen.mask_conv = mask_565;
         screen.pixelbytes = 2;
         break;
     case VISUAL_RGB_8_8_8:
         screen.rgb_conv = rgb_888;
         screen.rgb_conv = bgr_888;
         screen.mask_conv = mask_888;
         screen.pixelbytes = 3;
         break;
     case VISUAL_RGB_8_8_8_0:
-        screen.rgb_conv = rgb_888;
+        screen.rgb_conv = rgb_8880;
-        screen.mask_conv = mask_888;
+        screen.mask_conv = mask_8880;
         screen.pixelbytes = 4;
         break;
     case VISUAL_RGB_0_8_8_8:
         screen.rgb_conv = rgb_0888;
         screen.mask_conv = mask_0888;
     case VISUAL_BGR_0_8_8_8:
         screen.rgb_conv = bgr_0888;
         screen.mask_conv = mask_0888;
         screen.pixelbytes = 4;
         break;
+    case VISUAL_BGR_8_8_8_0:
+        screen.rgb_conv = bgr_8880;
+        screen.mask_conv = mask_8880;
+        screen.pixelbytes = 4;
+        break;
     default:
         return false;
+    }
     screen.fb_addr = (unsigned char *) addr;
  * @param call   Current call data
  * @param vp     Active viewport
+ *
  * @return false if the call was not handled byt this function, true otherwise
+ *
- * Note: this function is not threads safe, you would have
+ * Note: this function is not thread-safe, you would have
- * to redefine static variables with __thread
+ * to redefine static variables with fibril_local.
+ *
  */
 static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+{
     static keyfield_t *interbuffer = NULL;
     case IPC_M_SHARE_OUT:
         /* We accept one area for data interchange */
         if (IPC_GET_ARG1(*call) == shm_id) {
             void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
             shm_size = IPC_GET_ARG2(*call);
-            if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
+            if (ipc_answer_1(callid, EOK, (sysarg_t) dest)) {
-                shm = dest;
-            else
                 shm_id = 0;
+                return false;
+            }
+            shm = dest;
             if (shm[0] != 'P')
                 return false;
             return true;
         ipc_call_t call;
         int retval;
         unsigned int i;
         int scroll;
         wchar_t ch;
-        unsigned int row, col;
+        unsigned int col, row;
         if ((vport->cursor_active) || (anims_enabled))
             callid = async_get_call_timeout(&call, 250000);
         else
             callid = async_get_call(&call);
             /* Exit thread */
             return;
         case FB_PUTCHAR:
             ch = IPC_GET_ARG1(call);
-            row = IPC_GET_ARG2(call);
+            col = IPC_GET_ARG2(call);
-            col = IPC_GET_ARG3(call);
+            row = IPC_GET_ARG3(call);
             if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
+            }
             vport_clear(vport);
             cursor_show(vport);
             retval = EOK;
             break;
         case FB_CURSOR_GOTO:
-            row = IPC_GET_ARG1(call);
+            col = IPC_GET_ARG1(call);
-            col = IPC_GET_ARG2(call);
+            row = IPC_GET_ARG2(call);
             if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
+            }
             vport->cursor_active = IPC_GET_ARG1(call);
             cursor_show(vport);
             retval = EOK;
             break;
         case FB_GET_CSIZE:
-            ipc_answer_2(callid, EOK, vport->rows, vport->cols);
+            ipc_answer_2(callid, EOK, vport->cols, vport->rows);
+            continue;
+        case FB_GET_COLOR_CAP:
+            ipc_answer_1(callid, EOK, FB_CCAP_RGB);
             continue;
         case FB_SCROLL:
             scroll = IPC_GET_ARG1(call);
             if ((scroll > (int) vport->rows) || (scroll < (-(int) vport->rows))) {
                 retval = EINVAL;
     unsigned int fb_offset = sysinfo_value("fb.offset");
     unsigned int fb_width = sysinfo_value("fb.width");
     unsigned int fb_height = sysinfo_value("fb.height");
     unsigned int fb_scanline = sysinfo_value("fb.scanline");
     unsigned int fb_visual = sysinfo_value("fb.visual");
     unsigned int fbsize = fb_scanline * fb_height;
     void *fb_addr = as_get_mappable_page(fbsize);
     if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
         ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
         return -1;
     if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
         return 0;
     return -1;
+}
 /**
  * @}

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fb/fb.c – Rev 4348 → 4691