Index: uspace/lib/fb/Makefile =================================================================== --- uspace/lib/fb/Makefile (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/Makefile (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,37 @@ +# +# Copyright (c) 2011 Martin Decky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libfb + +SOURCES = \ + fb.c \ + imgmap.c \ + screenbuffer.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/fb/fb.c =================================================================== --- uspace/lib/fb/fb.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/fb.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,289 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include "fb.h" + +static async_exch_t *vp_exchange_begin(async_sess_t *sess, vp_handle_t vp) +{ + vp_handle_t cur_vp = (vp_handle_t) async_remote_state_acquire(sess); + async_exch_t *exch = async_exchange_begin(sess); + + if (cur_vp != vp) { + int ret = async_req_1_0(exch, FB_VP_FOCUS, vp); + if (ret != EOK) { + async_exchange_end(exch); + return NULL; + } + + async_remote_state_update(sess, (void *) vp); + } + + return exch; +} + +static void vp_exchange_end(async_exch_t *exch) +{ + async_remote_state_release_exchange(exch); +} + +int fb_get_resolution(async_sess_t *sess, sysarg_t *maxx, sysarg_t *maxy) +{ + async_exch_t *exch = async_exchange_begin(sess); + int ret = async_req_0_2(exch, FB_GET_RESOLUTION, maxx, maxy); + async_exchange_end(exch); + + return ret; +} + +int fb_yield(async_sess_t *sess) +{ + async_exch_t *exch = async_exchange_begin(sess); + int ret = async_req_0_0(exch, FB_YIELD); + async_exchange_end(exch); + + return ret; +} + +int fb_claim(async_sess_t *sess) +{ + async_exch_t *exch = async_exchange_begin(sess); + int ret = async_req_0_0(exch, FB_CLAIM); + async_exchange_end(exch); + + return ret; +} + +int fb_pointer_update(async_sess_t *sess, sysarg_t x, sysarg_t y, bool visible) +{ + async_exch_t *exch = async_exchange_begin(sess); + int ret = async_req_3_0(exch, FB_POINTER_UPDATE, x, y, visible); + async_exchange_end(exch); + + return ret; +} + +vp_handle_t fb_vp_create(async_sess_t *sess, sysarg_t x, sysarg_t y, + sysarg_t width, sysarg_t height) +{ + async_exch_t *exch = async_exchange_begin(sess); + + vp_handle_t handle; + int ret = async_req_4_1(exch, FB_VP_CREATE, x, y, width, height, + &handle); + + async_exchange_end(exch); + + if (ret != EOK) + return 0; + + return handle; +} + +frontbuf_handle_t fb_frontbuf_create(async_sess_t *sess, + screenbuffer_t *frontbuf) +{ + async_exch_t *exch = async_exchange_begin(sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, FB_FRONTBUF_CREATE, &answer); + int rc = async_share_out_start(exch, frontbuf, AS_AREA_READ + | AS_AREA_WRITE | AS_AREA_CACHEABLE); + + async_exchange_end(exch); + + sysarg_t ret; + async_wait_for(req, &ret); + + if ((rc != EOK) || (ret != EOK)) + return 0; + + return (frontbuf_handle_t) IPC_GET_ARG1(answer); +} + +imagemap_handle_t fb_imagemap_create(async_sess_t *sess, imgmap_t *imgmap) +{ + async_exch_t *exch = async_exchange_begin(sess); + + ipc_call_t answer; + aid_t req = async_send_0(exch, FB_IMAGEMAP_CREATE, &answer); + int rc = async_share_out_start(exch, imgmap, AS_AREA_READ + | AS_AREA_WRITE | AS_AREA_CACHEABLE); + + async_exchange_end(exch); + + sysarg_t ret; + async_wait_for(req, &ret); + + if ((rc != EOK) || (ret != EOK)) + return 0; + + return (imagemap_handle_t) IPC_GET_ARG1(answer); +} + +sequence_handle_t fb_sequence_create(async_sess_t *sess) +{ + async_exch_t *exch = async_exchange_begin(sess); + + sysarg_t ret; + int rc = async_req_0_1(exch, FB_SEQUENCE_CREATE, &ret); + + async_exchange_end(exch); + + if (rc != EOK) + return 0; + + return (sequence_handle_t) ret; +} + +int fb_vp_get_dimensions(async_sess_t *sess, vp_handle_t vp, sysarg_t *cols, + sysarg_t *rows) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_0_2(exch, FB_VP_GET_DIMENSIONS, cols, rows); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_get_caps(async_sess_t *sess, vp_handle_t vp, console_caps_t *ccaps) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + + sysarg_t rv; + int ret = async_req_0_1(exch, FB_VP_GET_CAPS, &rv); + + vp_exchange_end(exch); + + if (ret == EOK) + *ccaps = (console_caps_t) rv; + + return ret; +} + +int fb_vp_clear(async_sess_t *sess, vp_handle_t vp) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_0_0(exch, FB_VP_CLEAR); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_cursor_update(async_sess_t *sess, vp_handle_t vp, + frontbuf_handle_t frontbuf) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_1_0(exch, FB_VP_CURSOR_UPDATE, frontbuf); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_set_style(async_sess_t *sess, vp_handle_t vp, console_style_t style) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_1_0(exch, FB_VP_SET_STYLE, style); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_putchar(async_sess_t *sess, vp_handle_t vp, sysarg_t col, + sysarg_t row, wchar_t ch) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_3_0(exch, FB_VP_PUTCHAR, col, row, ch); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_update(async_sess_t *sess, vp_handle_t vp, frontbuf_handle_t frontbuf) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_1_0(exch, FB_VP_UPDATE, frontbuf); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_damage(async_sess_t *sess, vp_handle_t vp, frontbuf_handle_t frontbuf, + sysarg_t col, sysarg_t row, sysarg_t cols, sysarg_t rows) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_5_0(exch, FB_VP_DAMAGE, frontbuf, col, row, + cols, rows); + vp_exchange_end(exch); + + return ret; +} + +int fb_vp_imagemap_damage(async_sess_t *sess, vp_handle_t vp, + imagemap_handle_t imagemap, sysarg_t x, sysarg_t y, sysarg_t width, + sysarg_t height) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_5_0(exch, FB_VP_IMAGEMAP_DAMAGE, imagemap, x, y, + width, height); + vp_exchange_end(exch); + + return ret; +} + +int fb_sequence_add_imagemap(async_sess_t *sess, sequence_handle_t sequence, + imagemap_handle_t imagemap) +{ + async_exch_t *exch = async_exchange_begin(sess); + int ret = async_req_2_0(exch, FB_SEQUENCE_ADD_IMAGEMAP, sequence, + imagemap); + async_exchange_end(exch); + + return ret; +} + +int fb_vp_sequence_start(async_sess_t *sess, vp_handle_t vp, + sequence_handle_t sequence) +{ + async_exch_t *exch = vp_exchange_begin(sess, vp); + int ret = async_req_1_0(exch, FB_VP_SEQUENCE_START, sequence); + vp_exchange_end(exch); + + return ret; +} + +/** @} + */ Index: uspace/lib/fb/fb.h =================================================================== --- uspace/lib/fb/fb.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/fb.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef IMGMAP_FB_H_ +#define IMGMAP_FB_H_ + +#include +#include +#include +#include +#include + +typedef enum { + /** Screen methods */ + FB_GET_RESOLUTION = IPC_FIRST_USER_METHOD, + FB_YIELD, + FB_CLAIM, + FB_POINTER_UPDATE, + + /** Object methods */ + FB_VP_CREATE, + FB_VP_DESTROY, + FB_FRONTBUF_CREATE, + FB_FRONTBUF_DESTROY, + FB_IMAGEMAP_CREATE, + FB_IMAGEMAP_DESTROY, + FB_SEQUENCE_CREATE, + FB_SEQUENCE_DESTROY, + FB_SEQUENCE_ADD_IMAGEMAP, + + /** Viewport stateful methods */ + FB_VP_FOCUS, + FB_VP_CLEAR, + FB_VP_GET_DIMENSIONS, + FB_VP_GET_CAPS, + + /** Style methods (viewport specific) */ + FB_VP_CURSOR_UPDATE, + FB_VP_SET_STYLE, + FB_VP_SET_COLOR, + FB_VP_SET_RGB_COLOR, + + /** Text methods (viewport specific) */ + FB_VP_PUTCHAR, + FB_VP_UPDATE, + FB_VP_DAMAGE, + + /** Imagemap methods (viewport specific) */ + FB_VP_IMAGEMAP_DAMAGE, + + /** Sequence methods (viewport specific) */ + FB_VP_SEQUENCE_START, + FB_VP_SEQUENCE_STOP +} fb_request_t; + +/** Forward declarations */ +struct screenbuffer; +struct imgmap; + +typedef struct screenbuffer screenbuffer_t; +typedef struct imgmap imgmap_t; + +typedef uint32_t pixel_t; + +typedef sysarg_t vp_handle_t; +typedef sysarg_t frontbuf_handle_t; +typedef sysarg_t imagemap_handle_t; +typedef sysarg_t sequence_handle_t; + +extern int fb_get_resolution(async_sess_t *, sysarg_t *, sysarg_t *); +extern int fb_yield(async_sess_t *); +extern int fb_claim(async_sess_t *); +extern int fb_pointer_update(async_sess_t *, sysarg_t, sysarg_t, bool); + +extern vp_handle_t fb_vp_create(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, + sysarg_t); +extern frontbuf_handle_t fb_frontbuf_create(async_sess_t *, screenbuffer_t *); +extern imagemap_handle_t fb_imagemap_create(async_sess_t *, imgmap_t *); +extern sequence_handle_t fb_sequence_create(async_sess_t *); + +extern int fb_vp_get_dimensions(async_sess_t *, vp_handle_t, sysarg_t *, + sysarg_t *); +extern int fb_vp_get_caps(async_sess_t *, vp_handle_t, console_caps_t *); +extern int fb_vp_clear(async_sess_t *, vp_handle_t); + +extern int fb_vp_cursor_update(async_sess_t *, vp_handle_t, frontbuf_handle_t); +extern int fb_vp_set_style(async_sess_t *, vp_handle_t, console_style_t); + +extern int fb_vp_putchar(async_sess_t *, vp_handle_t, sysarg_t, sysarg_t, + wchar_t); +extern int fb_vp_update(async_sess_t *, vp_handle_t, frontbuf_handle_t); +extern int fb_vp_damage(async_sess_t *, vp_handle_t, frontbuf_handle_t, + sysarg_t, sysarg_t, sysarg_t, sysarg_t); + +extern int fb_vp_imagemap_damage(async_sess_t *, vp_handle_t, imagemap_handle_t, + sysarg_t, sysarg_t, sysarg_t, sysarg_t); + +extern int fb_sequence_add_imagemap(async_sess_t *, sequence_handle_t, + imagemap_handle_t); +extern int fb_vp_sequence_start(async_sess_t *, vp_handle_t, sequence_handle_t); + +#endif + +/** @} + */ Index: uspace/lib/fb/imgmap.c =================================================================== --- uspace/lib/fb/imgmap.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/imgmap.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,549 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup imgmap + * @{ + */ +/** + * @file + */ + +#include +#include +#include +#include +#include +#include +#include "imgmap.h" + +struct imgmap { + size_t size; + imgmap_flags_t flags; + sysarg_t width; + sysarg_t height; + visual_t visual; + uint8_t data[]; +}; + +/** RGB conversion and mask functions. + * + * These functions write an RGB pixel value to a memory location + * in a predefined format. The naming convention corresponds to + * the names of the visuals and the format created by these functions. + * The functions use the so called network bit order (i.e. big endian) + * with respect to their names. + */ + +#define RED(pixel, bits) (((pixel) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1)) +#define GREEN(pixel, bits) (((pixel) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1)) +#define BLUE(pixel, bits) (((pixel) >> (8 - (bits))) & ((1 << (bits)) - 1)) + +void pixel2rgb_0888(void *dst, pixel_t pixel) +{ + *((uint32_t *) dst) = host2uint32_t_be( + (RED(pixel, 8) << 16) | (GREEN(pixel, 8) << 8) | (BLUE(pixel, 8))); +} + +void pixel2bgr_0888(void *dst, pixel_t pixel) +{ + *((uint32_t *) dst) = host2uint32_t_be( + (BLUE(pixel, 8) << 16) | (GREEN(pixel, 8) << 8) | (RED(pixel, 8))); +} + +void pixel2rgb_8880(void *dst, pixel_t pixel) +{ + *((uint32_t *) dst) = host2uint32_t_be( + (RED(pixel, 8) << 24) | (GREEN(pixel, 8) << 16) | (BLUE(pixel, 8) << 8)); +} + +void pixel2bgr_8880(void *dst, pixel_t pixel) +{ + *((uint32_t *) dst) = host2uint32_t_be( + (BLUE(pixel, 8) << 24) | (GREEN(pixel, 8) << 16) | (RED(pixel, 8) << 8)); +} + +void pixel2rgb_888(void *dst, pixel_t pixel) +{ + ((uint8_t *) dst)[0] = RED(pixel, 8); + ((uint8_t *) dst)[1] = GREEN(pixel, 8); + ((uint8_t *) dst)[2] = BLUE(pixel, 8); +} + +void pixel2bgr_888(void *dst, pixel_t pixel) +{ + ((uint8_t *) dst)[0] = BLUE(pixel, 8); + ((uint8_t *) dst)[1] = GREEN(pixel, 8); + ((uint8_t *) dst)[2] = RED(pixel, 8); +} + +void pixel2rgb_555_be(void *dst, pixel_t pixel) +{ + *((uint16_t *) dst) = host2uint16_t_be( + (RED(pixel, 5) << 10) | (GREEN(pixel, 5) << 5) | (BLUE(pixel, 5))); +} + +void pixel2rgb_555_le(void *dst, pixel_t pixel) +{ + *((uint16_t *) dst) = host2uint16_t_le( + (RED(pixel, 5) << 10) | (GREEN(pixel, 5) << 5) | (BLUE(pixel, 5))); +} + +void pixel2rgb_565_be(void *dst, pixel_t pixel) +{ + *((uint16_t *) dst) = host2uint16_t_be( + (RED(pixel, 5) << 11) | (GREEN(pixel, 6) << 5) | (BLUE(pixel, 5))); +} + +void pixel2rgb_565_le(void *dst, pixel_t pixel) +{ + *((uint16_t *) dst) = host2uint16_t_le( + (RED(pixel, 5) << 11) | (GREEN(pixel, 6) << 5) | (BLUE(pixel, 5))); +} + +void pixel2bgr_323(void *dst, pixel_t pixel) +{ + *((uint8_t *) dst) = + ~((RED(pixel, 3) << 5) | (GREEN(pixel, 2) << 3) | BLUE(pixel, 3)); +} + +void pixel2gray_8(void *dst, pixel_t pixel) +{ + uint32_t red = RED(pixel, 8) * 5034375; + uint32_t green = GREEN(pixel, 8) * 9886846; + uint32_t blue = BLUE(pixel, 8) * 1920103; + + *((uint8_t *) dst) = (red + green + blue) >> 24; +} + +void visual_mask_0888(void *dst, bool mask) +{ + pixel2bgr_0888(dst, mask ? 0xffffff : 0); +} + +void visual_mask_8880(void *dst, bool mask) +{ + pixel2bgr_8880(dst, mask ? 0xffffff : 0); +} + +void visual_mask_888(void *dst, bool mask) +{ + pixel2bgr_888(dst, mask ? 0xffffff : 0); +} + +void visual_mask_555(void *dst, bool mask) +{ + pixel2rgb_555_be(dst, mask ? 0xffffff : 0); +} + +void visual_mask_565(void *dst, bool mask) +{ + pixel2rgb_565_be(dst, mask ? 0xffffff : 0); +} + +void visual_mask_323(void *dst, bool mask) +{ + pixel2bgr_323(dst, mask ? 0x0 : ~0x0); +} + +void visual_mask_8(void *dst, bool mask) +{ + pixel2gray_8(dst, mask ? 0xffffff : 0); +} + +pixel_t rgb_0888_2pixel(void *src) +{ + return (uint32_t_be2host(*((uint32_t *) src)) & 0xffffff); +} + +pixel_t bgr_0888_2pixel(void *src) +{ + uint32_t val = uint32_t_be2host(*((uint32_t *) src)); + return (((val & 0xff0000) >> 16) | (val & 0xff00) | ((val & 0xff) << 16)); +} + +pixel_t rgb_8880_2pixel(void *src) +{ + return (uint32_t_be2host(*((uint32_t *) src)) >> 8); +} + +pixel_t bgr_8880_2pixel(void *src) +{ + uint32_t val = uint32_t_be2host(*((uint32_t *) src)); + return (((val & 0xff000000) >> 24) | ((val & 0xff0000) >> 8) | ((val & 0xff00) << 8)); +} + +pixel_t rgb_888_2pixel(void *src) +{ + uint8_t red = ((uint8_t *) src)[0]; + uint8_t green = ((uint8_t *) src)[1]; + uint8_t blue = ((uint8_t *) src)[2]; + + return ((red << 16) | (green << 8) | (blue)); +} + +pixel_t bgr_888_2pixel(void *src) +{ + uint8_t blue = ((uint8_t *) src)[0]; + uint8_t green = ((uint8_t *) src)[1]; + uint8_t red = ((uint8_t *) src)[2]; + + return ((red << 16) | (green << 8) | (blue)); +} + +pixel_t rgb_555_be_2pixel(void *src) +{ + uint16_t val = uint16_t_be2host(*((uint16_t *) src)); + return (((val & 0x7c00) << 9) | ((val & 0x3e0) << 6) | ((val & 0x1f) << 3)); +} + +pixel_t rgb_555_le_2pixel(void *src) +{ + uint16_t val = uint16_t_le2host(*((uint16_t *) src)); + return (((val & 0x7c00) << 9) | ((val & 0x3e0) << 6) | ((val & 0x1f) << 3)); +} + +pixel_t rgb_565_be_2pixel(void *src) +{ + uint16_t val = uint16_t_be2host(*((uint16_t *) src)); + return (((val & 0xf800) << 8) | ((val & 0x7e0) << 5) | ((val & 0x1f) << 3)); +} + +pixel_t rgb_565_le_2pixel(void *src) +{ + uint16_t val = uint16_t_le2host(*((uint16_t *) src)); + return (((val & 0xf800) << 8) | ((val & 0x7e0) << 5) | ((val & 0x1f) << 3)); +} + +pixel_t bgr_323_2pixel(void *src) +{ + uint8_t val = ~(*((uint8_t *) src)); + return (((val & 0xe0) << 16) | ((val & 0x18) << 11) | ((val & 0x7) << 5)); +} + +pixel_t gray_8_2pixel(void *src) +{ + uint8_t val = *((uint8_t *) src); + return ((val << 16) | (val << 8) | (val)); +} + +typedef struct { + uint8_t id_length; + uint8_t cmap_type; + uint8_t img_type; + + uint16_t cmap_first_entry; + uint16_t cmap_entries; + uint8_t cmap_bpp; + + uint16_t startx; + uint16_t starty; + uint16_t width; + uint16_t height; + uint8_t img_bpp; + uint8_t img_descr; +} __attribute__((packed)) tga_header_t; + +typedef enum { + CMAP_NOT_PRESENT = 0, + CMAP_PRESENT = 1, + CMAP_RESERVED_START = 2, + CMAP_PRIVATE_START = 128 +} cmap_type_t; + +typedef enum { + IMG_EMTPY = 0, + IMG_CMAP = 1, + IMG_BGRA = 2, + IMG_GRAY = 3, + IMG_CMAP_RLE = 9, + IMG_BGRA_RLE = 10, + IMG_GRAY_RLE = 11 +} img_type_t; + +typedef struct { + cmap_type_t cmap_type; + img_type_t img_type; + + uint16_t cmap_first_entry; + uint16_t cmap_entries; + uint8_t cmap_bpp; + + uint16_t startx; + uint16_t starty; + uint16_t width; + uint16_t height; + uint8_t img_bpp; + uint8_t img_alpha_bpp; + uint8_t img_alpha_dir; + + void *id_data; + size_t id_length; + + void *cmap_data; + size_t cmap_length; + + void *img_data; + size_t img_length; +} tga_t; + +/** Decode Truevision TGA header + * + * @param[in] data Memory representation of TGA. + * @param[in] size Size of the representation (in bytes). + * @param[out] tga Decoded TGA. + * + * @return True on succesful decoding. + * @return False on failure. + * + */ +static bool decode_tga_header(void *data, size_t size, tga_t *tga) +{ + /* Header sanity check */ + if (size < sizeof(tga_header_t)) + return false; + + tga_header_t *head = (tga_header_t *) data; + + /* Image ID field */ + tga->id_data = data + sizeof(tga_header_t); + tga->id_length = head->id_length; + + if (size < sizeof(tga_header_t) + tga->id_length) + return false; + + /* Color map type */ + tga->cmap_type = head->cmap_type; + + /* Image type */ + tga->img_type = head->img_type; + + /* Color map specification */ + tga->cmap_first_entry = uint16_t_le2host(head->cmap_first_entry); + tga->cmap_entries = uint16_t_le2host(head->cmap_entries); + tga->cmap_bpp = head->cmap_bpp; + tga->cmap_data = tga->id_data + tga->id_length; + tga->cmap_length = ALIGN_UP(tga->cmap_entries * tga->cmap_bpp, 8) >> 3; + + if (size < sizeof(tga_header_t) + tga->id_length + + tga->cmap_length) + return false; + + /* Image specification */ + tga->startx = uint16_t_le2host(head->startx); + tga->starty = uint16_t_le2host(head->starty); + tga->width = uint16_t_le2host(head->width); + tga->height = uint16_t_le2host(head->height); + tga->img_bpp = head->img_bpp; + tga->img_alpha_bpp = head->img_descr & 0x0f; + tga->img_alpha_dir = (head->img_descr & 0xf0) >> 4; + tga->img_data = tga->cmap_data + tga->cmap_length; + tga->img_length = ALIGN_UP(tga->width * tga->height * tga->img_bpp, 8) >> 3; + + if (size < sizeof(tga_header_t) + tga->id_length + + tga->cmap_length + tga->img_length) + return false; + + return true; +} + +void imgmap_put_pixel(imgmap_t *imgmap, sysarg_t x, sysarg_t y, pixel_t pixel) +{ + if ((x >= imgmap->width) || (y >= imgmap->height)) + return; + + size_t offset = y * imgmap->width + x; + + switch (imgmap->visual) { + case VISUAL_RGB_0_8_8_8: + pixel2rgb_0888(((uint32_t *) imgmap->data) + offset, pixel); + break; + default: + break; + } +} + +pixel_t imgmap_get_pixel(imgmap_t *imgmap, sysarg_t x, sysarg_t y) +{ + if ((x >= imgmap->width) || (y >= imgmap->height)) + return 0; + + size_t offset = y * imgmap->width + x; + + switch (imgmap->visual) { + case VISUAL_RGB_0_8_8_8: + return rgb_0888_2pixel(((uint32_t *) imgmap->data) + offset); + default: + return 0; + } +} + +imgmap_t *imgmap_create(sysarg_t width, sysarg_t height, visual_t visual, + imgmap_flags_t flags) +{ + size_t bsize; + + switch (visual) { + case VISUAL_RGB_0_8_8_8: + bsize = (width * height) << 2; + break; + default: + return NULL; + } + + size_t size = sizeof(imgmap_t) + bsize; + imgmap_t *imgmap; + + if ((flags & IMGMAP_FLAG_SHARED) == IMGMAP_FLAG_SHARED) { + imgmap = (imgmap_t *) as_get_mappable_page(size); + + if (as_area_create((void *) imgmap, size, AS_AREA_READ | + AS_AREA_WRITE | AS_AREA_CACHEABLE) != (void *) imgmap) + return NULL; + } else { + imgmap = (imgmap_t *) malloc(size); + if (imgmap == NULL) + return NULL; + } + + imgmap->size = size; + imgmap->flags = flags; + imgmap->width = width; + imgmap->height = height; + imgmap->visual = visual; + + memset(imgmap->data, 0, bsize); + + return imgmap; +} + +/** Decode Truevision TGA format + * + * Decode Truevision TGA format and create an image map + * from it. The supported variants of TGA are currently + * limited to uncompressed 24 bit true-color images without + * alpha channel. + * + * @param[in] data Memory representation of TGA. + * @param[in] size Size of the representation (in bytes). + * @param[in] flags Image map creation flags. + * + * @return Newly allocated image map. + * @return NULL on error or unsupported format. + * + */ +imgmap_t *imgmap_decode_tga(void *data, size_t size, imgmap_flags_t flags) +{ + tga_t tga; + if (!decode_tga_header(data, size, &tga)) + return NULL; + + /* + * Check for unsupported features. + */ + + switch (tga.cmap_type) { + case CMAP_NOT_PRESENT: + break; + default: + /* Unsupported */ + return NULL; + } + + switch (tga.img_type) { + case IMG_BGRA: + if (tga.img_bpp != 24) + return NULL; + break; + case IMG_GRAY: + if (tga.img_bpp != 8) + return NULL; + break; + default: + /* Unsupported */ + return NULL; + } + + if (tga.img_alpha_bpp != 0) + return NULL; + + sysarg_t twidth = tga.startx + tga.width; + sysarg_t theight = tga.starty + tga.height; + + imgmap_t *imgmap = imgmap_create(twidth, theight, VISUAL_RGB_0_8_8_8, + flags); + if (imgmap == NULL) + return NULL; + + /* + * TGA is encoded in a bottom-up manner, the true-color + * variant is in BGR 8:8:8 encoding. + */ + + switch (tga.img_type) { + case IMG_BGRA: + for (sysarg_t y = tga.starty; y < theight; y++) { + for (sysarg_t x = tga.startx; x < twidth; x++) { + size_t offset = + ((y - tga.starty) * tga.width + (x - tga.startx)) * 3; + + pixel_t pixel = + bgr_888_2pixel(((uint8_t *) tga.img_data) + offset); + imgmap_put_pixel(imgmap, x, theight - y - 1, pixel); + } + } + break; + case IMG_GRAY: + for (sysarg_t y = tga.starty; y < theight; y++) { + for (sysarg_t x = tga.startx; x < twidth; x++) { + size_t offset = + (y - tga.starty) * tga.width + (x - tga.startx); + + pixel_t pixel = + gray_8_2pixel(((uint8_t *) tga.img_data) + offset); + imgmap_put_pixel(imgmap, x, theight - y - 1, pixel); + } + } + break; + default: + break; + } + + return imgmap; +} + +void imgmap_get_resolution(imgmap_t *imgmap, sysarg_t *width, sysarg_t *height) +{ + assert(width); + assert(height); + + *width = imgmap->width; + *height = imgmap->height; +} + +/** @} + */ Index: uspace/lib/fb/imgmap.h =================================================================== --- uspace/lib/fb/imgmap.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/imgmap.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup imgmap + * @{ + */ +/** + * @file + */ + +#ifndef IMGMAP_IMGMAP_H_ +#define IMGMAP_IMGMAP_H_ + +#include +#include +#include +#include "fb.h" + +typedef enum { + IMGMAP_FLAG_NONE = 0, + IMGMAP_FLAG_SHARED = 1 +} imgmap_flags_t; + +/** Function to render a pixel. */ +typedef void (*pixel2visual_t)(void *, pixel_t); + +/** Function to render a bit mask. */ +typedef void (*visual_mask_t)(void *, bool); + +/** Function to retrieve a pixel. */ +typedef pixel_t (*visual2pixel_t)(void *); + +extern void pixel2rgb_0888(void *, pixel_t); +extern void pixel2bgr_0888(void *, pixel_t); +extern void pixel2rgb_8880(void *, pixel_t); +extern void pixel2bgr_8880(void *, pixel_t); +extern void pixel2rgb_888(void *, pixel_t); +extern void pixel2bgr_888(void *, pixel_t); +extern void pixel2rgb_555_be(void *, pixel_t); +extern void pixel2rgb_555_le(void *, pixel_t); +extern void pixel2rgb_565_be(void *, pixel_t); +extern void pixel2rgb_565_le(void *, pixel_t); +extern void pixel2bgr_323(void *, pixel_t); +extern void pixel2gray_8(void *, pixel_t); + +extern void visual_mask_0888(void *, bool); +extern void visual_mask_8880(void *, bool); +extern void visual_mask_888(void *, bool); +extern void visual_mask_555(void *, bool); +extern void visual_mask_565(void *, bool); +extern void visual_mask_323(void *, bool); +extern void visual_mask_8(void *, bool); + +extern pixel_t rgb_0888_2pixel(void *); +extern pixel_t bgr_0888_2pixel(void *); +extern pixel_t rgb_8880_2pixel(void *); +extern pixel_t bgr_8880_2pixel(void *); +extern pixel_t rgb_888_2pixel(void *); +extern pixel_t bgr_888_2pixel(void *); +extern pixel_t rgb_555_be_2pixel(void *); +extern pixel_t rgb_555_le_2pixel(void *); +extern pixel_t rgb_565_be_2pixel(void *); +extern pixel_t rgb_565_le_2pixel(void *); +extern pixel_t bgr_323_2pixel(void *); +extern pixel_t gray_8_2pixel(void *); + +extern imgmap_t *imgmap_create(sysarg_t, sysarg_t, visual_t, imgmap_flags_t); +extern void imgmap_put_pixel(imgmap_t *, sysarg_t, sysarg_t, pixel_t); +extern pixel_t imgmap_get_pixel(imgmap_t *, sysarg_t, sysarg_t); + +extern imgmap_t *imgmap_decode_tga(void *, size_t, imgmap_flags_t); +extern void imgmap_get_resolution(imgmap_t *, sysarg_t *, sysarg_t *); + +#endif + +/** @} + */ Index: uspace/lib/fb/screenbuffer.c =================================================================== --- uspace/lib/fb/screenbuffer.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/screenbuffer.c (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,394 @@ +/* + * Copyright (c) 2006 Josef Cejka + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup console + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include "screenbuffer.h" + +/** Structure for buffering state of one virtual console. + * + */ +struct screenbuffer { + size_t size; /**< Structure size */ + screenbuffer_flag_t flags; /**< Screenbuffer flags */ + + sysarg_t cols; /**< Number of columns */ + sysarg_t rows; /**< Number of rows */ + + sysarg_t col; /**< Current column */ + sysarg_t row; /**< Current row */ + bool cursor_visible; /**< Cursor visibility */ + + char_attrs_t attrs; /**< Current attributes */ + + sysarg_t top_row; /**< The first row in the cyclic buffer */ + charfield_t data[]; /**< Screen contents (cyclic buffer) */ +}; + +/** Create a screenbuffer. + * + * @param[in] cols Number of columns. + * @param[in] rows Number of rows. + * @param[in] flags Screenbuffer flags. + * + * @return New screenbuffer. + * @return NULL on failure. + * + */ +screenbuffer_t *screenbuffer_create(sysarg_t cols, sysarg_t rows, + screenbuffer_flag_t flags) +{ + size_t size = + sizeof(screenbuffer_t) + cols * rows * sizeof(charfield_t); + screenbuffer_t *scrbuf; + + if ((flags & SCREENBUFFER_FLAG_SHARED) == SCREENBUFFER_FLAG_SHARED) { + scrbuf = (screenbuffer_t *) as_get_mappable_page(size); + + if (as_area_create((void *) scrbuf, size, AS_AREA_READ | + AS_AREA_WRITE | AS_AREA_CACHEABLE) != (void *) scrbuf) + return NULL; + } else { + scrbuf = (screenbuffer_t *) malloc(size); + if (scrbuf == NULL) + return NULL; + } + + scrbuf->size = size; + scrbuf->flags = flags; + scrbuf->cols = cols; + scrbuf->rows = rows; + scrbuf->cursor_visible = false; + + scrbuf->attrs.type = CHAR_ATTR_STYLE; + scrbuf->attrs.val.style = STYLE_NORMAL; + + scrbuf->top_row = 0; + screenbuffer_clear(scrbuf); + + return scrbuf; +} + +/** Return keyfield by coordinates + * + * The back buffer is organized as a cyclic buffer. + * Therefore we must take into account the topmost column. + * + * @param scrbuf Screenbuffer + * @param col Column position on screen + * @param row Row position on screen + * + * @return Keyfield structure on (row, col) + * + */ +charfield_t *screenbuffer_field_at(screenbuffer_t *scrbuf, sysarg_t col, + sysarg_t row) +{ + return scrbuf->data + + ((row + scrbuf->top_row) % scrbuf->rows) * scrbuf->cols + + col; +} + +bool screenbuffer_cursor_at(screenbuffer_t *scrbuf, sysarg_t col, sysarg_t row) +{ + return ((scrbuf->cursor_visible) && (scrbuf->col == col) && + (scrbuf->row == row)); +} + +sysarg_t screenbuffer_get_top_row(screenbuffer_t *scrbuf) +{ + return scrbuf->top_row; +} + +static sysarg_t screenbuffer_update_rows(screenbuffer_t *scrbuf) +{ + if (scrbuf->row == scrbuf->rows) { + scrbuf->row = scrbuf->rows - 1; + scrbuf->top_row = (scrbuf->top_row + 1) % scrbuf->rows; + screenbuffer_clear_row(scrbuf, scrbuf->row); + + return scrbuf->rows; + } + + return 2; +} + +static sysarg_t screenbuffer_update_cols(screenbuffer_t *scrbuf) +{ + /* Column overflow */ + if (scrbuf->col == scrbuf->cols) { + scrbuf->col = 0; + scrbuf->row++; + return screenbuffer_update_rows(scrbuf); + } + + return 1; +} + +/** Store one character to screenbuffer. + * + * Its position is determined by scrbuf->col + * and scrbuf->row. + * + * @param scrbuf Screenbuffer. + * @param ch Character to store. + * @param update Update coordinates. + * + * @return Number of rows which have been affected. In usual + * situations this is 1. If the current position was + * updated to a new row, this value is 2. + * + */ +sysarg_t screenbuffer_putchar(screenbuffer_t *scrbuf, wchar_t ch, bool update) +{ + assert(scrbuf->col < scrbuf->cols); + assert(scrbuf->row < scrbuf->rows); + + charfield_t *field = + screenbuffer_field_at(scrbuf, scrbuf->col, scrbuf->row); + + field->ch = ch; + field->attrs = scrbuf->attrs; + field->flags |= CHAR_FLAG_DIRTY; + + if (update) { + scrbuf->col++; + return screenbuffer_update_cols(scrbuf); + } + + return 1; +} + +/** Jump to a new row in screenbuffer. + * + * @param scrbuf Screenbuffer. + * + * @return Number of rows which have been affected. In usual + * situations this is 2 (the original row and the new + * row). + * + */ +sysarg_t screenbuffer_newline(screenbuffer_t *scrbuf) +{ + assert(scrbuf->col < scrbuf->cols); + assert(scrbuf->row < scrbuf->rows); + + scrbuf->col = 0; + scrbuf->row++; + + return screenbuffer_update_rows(scrbuf); +} + +/** Jump to a new row in screenbuffer. + * + * @param scrbuf Screenbuffer. + * @param tab_size Tab size. + * + * @return Number of rows which have been affected. In usual + * situations this is 1. If the current position was + * updated to a new row, this value is 2. + * + */ +sysarg_t screenbuffer_tabstop(screenbuffer_t *scrbuf, sysarg_t tab_size) +{ + assert(scrbuf->col < scrbuf->cols); + assert(scrbuf->row < scrbuf->rows); + + sysarg_t spaces = tab_size - scrbuf->cols % tab_size; + sysarg_t flush = 1; + + for (sysarg_t i = 0; i < spaces; i++) + flush += screenbuffer_putchar(scrbuf, ' ', true) - 1; + + return flush; +} + +/** Jump to the previous character in screenbuffer. + * + * Currently no scrollback is supported. + * + * @param scrbuf Screenbuffer. + * + * @return Number of rows which have been affected. In usual + * situations this is 1. If the current position was + * updated to the previous row, this value is 2. + * @return 0 if no backspace is possible. + * + */ +sysarg_t screenbuffer_backspace(screenbuffer_t *scrbuf) +{ + assert(scrbuf->col < scrbuf->cols); + assert(scrbuf->row < scrbuf->rows); + + if ((scrbuf->col == 0) && (scrbuf->row == 0)) + return 0; + + if (scrbuf->col == 0) { + scrbuf->col = scrbuf->cols - 1; + scrbuf->row--; + + screenbuffer_putchar(scrbuf, ' ', false); + return 2; + } + + scrbuf->col--; + screenbuffer_putchar(scrbuf, ' ', false); + return 1; +} + +/** Clear the screenbuffer. + * + * @param scrbuf Screenbuffer. + * + */ +void screenbuffer_clear(screenbuffer_t *scrbuf) +{ + for (size_t pos = 0; pos < (scrbuf->cols * scrbuf->rows); pos++) { + scrbuf->data[pos].ch = 0; + scrbuf->data[pos].attrs = scrbuf->attrs; + scrbuf->data[pos].flags = CHAR_FLAG_DIRTY; + } + + scrbuf->col = 0; + scrbuf->row = 0; +} + +/** Update current screenbuffer coordinates + * + * @param scrbuf Screenbuffer. + * @param col New column. + * @param row New row. + * + */ +void screenbuffer_set_cursor(screenbuffer_t *scrbuf, sysarg_t col, sysarg_t row) +{ + scrbuf->col = col; + scrbuf->row = row; +} + +void screenbuffer_set_cursor_visibility(screenbuffer_t *scrbuf, bool visible) +{ + scrbuf->cursor_visible = visible; +} + +/** Get current screenbuffer coordinates + * + * @param scrbuf Screenbuffer. + * @param col Column. + * @param row Row. + * + */ +void screenbuffer_get_cursor(screenbuffer_t *scrbuf, sysarg_t *col, + sysarg_t *row) +{ + assert(col); + assert(row); + + *col = scrbuf->col; + *row = scrbuf->row; +} + +bool screenbuffer_get_cursor_visibility(screenbuffer_t *scrbuf) +{ + return scrbuf->cursor_visible; +} + +/** Clear one buffer row. + * + * @param scrbuf Screenbuffer. + * @param row Row to clear. + * + */ +void screenbuffer_clear_row(screenbuffer_t *scrbuf, sysarg_t row) +{ + for (sysarg_t col = 0; col < scrbuf->cols; col++) { + charfield_t *field = + screenbuffer_field_at(scrbuf, col, row); + + field->ch = 0; + field->attrs = scrbuf->attrs; + field->flags |= CHAR_FLAG_DIRTY; + } +} + +/** Set screenbuffer style. + * + * @param scrbuf Screenbuffer. + * @param style Style. + * + */ +void screenbuffer_set_style(screenbuffer_t *scrbuf, console_style_t style) +{ + scrbuf->attrs.type = CHAR_ATTR_STYLE; + scrbuf->attrs.val.style = style; +} + +/** Set screenbuffer color. + * + * @param scrbuf Screenbuffer. + * @param bgcolor Background color. + * @param fgcolor Foreground color. + * @param attr Color attribute. + * + */ +void screenbuffer_set_color(screenbuffer_t *scrbuf, console_color_t bgcolor, + console_color_t fgcolor, console_color_attr_t attr) +{ + scrbuf->attrs.type = CHAR_ATTR_INDEX; + scrbuf->attrs.val.index.bgcolor = bgcolor; + scrbuf->attrs.val.index.fgcolor = fgcolor; + scrbuf->attrs.val.index.attr = attr; +} + +/** Set screenbuffer RGB color. + * + * @param scrbuf Screenbuffer. + * @param bgcolor Background color. + * @param fgcolor Foreground color. + * + */ +void screenbuffer_set_rgb_color(screenbuffer_t *scrbuf, pixel_t bgcolor, + pixel_t fgcolor) +{ + scrbuf->attrs.type = CHAR_ATTR_RGB; + scrbuf->attrs.val.rgb.bgcolor = bgcolor; + scrbuf->attrs.val.rgb.fgcolor = fgcolor; +} + +/** @} + */ Index: uspace/lib/fb/screenbuffer.h =================================================================== --- uspace/lib/fb/screenbuffer.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) +++ uspace/lib/fb/screenbuffer.h (revision 7c014d1fbbe9734e6ee3616fac584d8cc996df36) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2006 Josef Cejka + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef IMGMAP_SCREENBUFFER_H__ +#define IMGMAP_SCREENBUFFER_H__ + +#include +#include +#include +#include +#include "fb.h" + +typedef enum { + SCREENBUFFER_FLAG_NONE = 0, + SCREENBUFFER_FLAG_SHARED = 1 +} screenbuffer_flag_t; + +typedef enum { + CHAR_ATTR_STYLE, + CHAR_ATTR_INDEX, + CHAR_ATTR_RGB +} char_attr_type_t; + +typedef enum { + CHAR_FLAG_NONE = 0, + CHAR_FLAG_DIRTY = 1 +} char_flags_t; + +typedef struct { + console_color_t bgcolor; + console_color_t fgcolor; + console_color_attr_t attr; +} char_attr_index_t; + +typedef struct { + pixel_t bgcolor; /**< Background color */ + pixel_t fgcolor; /**< Foreground color */ +} char_attr_rgb_t; + +typedef union { + console_style_t style; + char_attr_index_t index; + char_attr_rgb_t rgb; +} char_attr_val_t; + +typedef struct { + char_attr_type_t type; + char_attr_val_t val; +} char_attrs_t; + +/** One field on screen. It contain one character and its attributes. */ +typedef struct { + wchar_t ch; /**< Character itself */ + char_attrs_t attrs; /**< Character attributes */ + char_flags_t flags; /**< Character flags */ +} charfield_t; + +/** Compare two sets of attributes. + * + * @param a1 First attribute. + * @param a2 Second attribute. + * + * @return True on equality + * + */ +static inline bool attrs_same(char_attrs_t a1, char_attrs_t a2) +{ + if (a1.type != a2.type) + return false; + + switch (a1.type) { + case CHAR_ATTR_STYLE: + return (a1.val.style == a2.val.style); + case CHAR_ATTR_INDEX: + return (a1.val.index.bgcolor == a2.val.index.bgcolor) + && (a1.val.index.fgcolor == a2.val.index.fgcolor) + && (a1.val.index.attr == a2.val.index.attr); + case CHAR_ATTR_RGB: + return (a1.val.rgb.bgcolor == a2.val.rgb.bgcolor) + && (a1.val.rgb.fgcolor == a2.val.rgb.fgcolor); + } + + return false; +} + +extern screenbuffer_t *screenbuffer_create(sysarg_t, sysarg_t, + screenbuffer_flag_t); + +extern charfield_t *screenbuffer_field_at(screenbuffer_t *, sysarg_t, sysarg_t); +extern bool screenbuffer_cursor_at(screenbuffer_t *, sysarg_t, sysarg_t); + +extern sysarg_t screenbuffer_get_top_row(screenbuffer_t *); + +extern sysarg_t screenbuffer_putchar(screenbuffer_t *, wchar_t, bool); +extern sysarg_t screenbuffer_newline(screenbuffer_t *); +extern sysarg_t screenbuffer_tabstop(screenbuffer_t *, sysarg_t); +extern sysarg_t screenbuffer_backspace(screenbuffer_t *); + +extern void screenbuffer_clear(screenbuffer_t *); +extern void screenbuffer_clear_row(screenbuffer_t *, sysarg_t); + +extern void screenbuffer_set_cursor(screenbuffer_t *, sysarg_t, sysarg_t); +extern void screenbuffer_set_cursor_visibility(screenbuffer_t *, bool); +extern bool screenbuffer_get_cursor_visibility(screenbuffer_t *); + +extern void screenbuffer_get_cursor(screenbuffer_t *, sysarg_t *, sysarg_t *); + +extern void screenbuffer_set_style(screenbuffer_t *, console_style_t); +extern void screenbuffer_set_color(screenbuffer_t *, console_color_t, + console_color_t, console_color_attr_t); +extern void screenbuffer_set_rgb_color(screenbuffer_t *, pixel_t, pixel_t); + +#endif + +/** @} + */