Changeset f13f1495 in mainline

Timestamp:

2020-09-29T14:58:57Z (4 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

efe0881

Parents:

a81d480

git-author:

Jiri Svoboda <jiri@…> (2020-09-28 19:58:39)

git-committer:

Jiri Svoboda <jiri@…> (2020-09-29 14:58:57)

Message:

Bit pack font bitmap to 1 bit per pixel when saving to TPF file

Location:

uspace/lib/gfxfont

Files:

• private/font.h (modified) (2 diffs)
• src/font.c (modified) (7 diffs)
• test/font.c (modified) (1 diff)

uspace/lib/gfxfont/private/font.h

@@ -40 +40 @@
 #include <adt/list.h>
 #include <errno.h>
+#include <stdint.h>
 #include <types/gfx/bitmap.h>
 #include <types/gfx/context.h>
@@ -91 +92 @@
     gfx_rect_t *);
 extern errno_t gfx_font_info_load(gfx_typeface_t *, riff_rchunk_t *);
+extern errno_t gfx_font_bitmap_pack(gfx_coord_t, gfx_coord_t, uint32_t *,
+    void **, size_t *);
+extern errno_t gfx_font_bitmap_unpack(gfx_coord_t, gfx_coord_t, void *, size_t,
+    uint32_t *);
 extern errno_t gfx_font_load(gfx_font_info_t *);
 extern errno_t gfx_font_save(gfx_font_info_t *, riffw_t *);

uspace/lib/gfxfont/src/font.c

@@ -519 +519 @@
 }
 
+/** Bit pack font bitmap into 1 bits/pixel format.
+ *
+ * @param width Bitmap width
+ * @param height Bitmap height
+ * @param pixels Bitmap pixels
+ * @param rdata Place to store pointer to packed data
+ * @param rsize Place to store size of packed data
+ * @return EOK on sucess, ENOMEM if out of memory
+ */
+errno_t gfx_font_bitmap_pack(gfx_coord_t width, gfx_coord_t height,
+    uint32_t *pixels, void **rdata, size_t *rsize)
+{
+        void *data;
+        size_t size;
+        size_t bytes_line;
+        gfx_coord_t x, y;
+        uint8_t b;
+        uint8_t *dp;
+        uint32_t *sp;
+        uint32_t pix;
+
+        bytes_line = (width + 7) / 8;
+        size = height * bytes_line;
+
+        data = malloc(size);
+        if (data == NULL)
+                return ENOMEM;
+
+        sp = pixels;
+        dp = data;
+        for (y = 0; y < height; y++) {
+                b = 0;
+                for (x = 0; x < width; x++) {
+                        pix = *sp++;
+                        b = (b << 1) | (pix & 1);
+                        /* Write eight bits */
+                        if ((x & 7) == 7) {
+                                *dp++ = b;
+                                b = 0;
+                        }
+                }
+
+                /* Write remaining bits */
+                if ((x & 7) != 0) {
+                        b = b << (8 - (x & 7));
+                        *dp++ = b;
+                }
+        }
+
+        *rdata = data;
+        *rsize = size;
+        return EOK;
+}
+
+/** Unpack font bitmap from 1 bits/pixel format.
+ *
+ * @param width Bitmap width
+ * @param height Bitmap height
+ * @param data Packed data
+ * @param dsize Size of packed data
+ * @param pixels Bitmap pixels
+ * @return EOK on success, EINVAL if data size is invalid
+ */
+errno_t gfx_font_bitmap_unpack(gfx_coord_t width, gfx_coord_t height,
+    void *data, size_t dsize, uint32_t *pixels)
+{
+        size_t size;
+        size_t bytes_line;
+        gfx_coord_t x, y;
+        uint8_t b;
+        uint8_t *sp;
+        uint32_t *dp;
+
+        bytes_line = (width + 7) / 8;
+        size = height * bytes_line;
+
+        if (dsize != size)
+                return EINVAL;
+
+        sp = data;
+        dp = pixels;
+        for (y = 0; y < height; y++) {
+                b = 0;
+                for (x = 0; x < width; x++) {
+                        if ((x & 7) == 0)
+                                b = *sp++;
+                        *dp++ = (b >> 7) ? PIXEL(255, 255, 255, 255) :
+                            PIXEL(0, 0, 0, 0);
+                        b = b << 1;
+                }
+        }
+
+        return EOK;
+}
+
 /** Load font bitmap from RIFF TPF file.
  *
@@ -537 +632 @@
         uint16_t fmt;
         uint16_t depth;
+        size_t bytes_line;
+        void *data = NULL;
+        size_t size;
         size_t nread;
 
@@ -552 +650 @@
         depth = uint16_t_le2host(thdr.depth);
 
-        if (fmt != 0 || depth != 8 * sizeof(uint32_t)) {
+        if (fmt != 0 || depth != 1) {
                 rc = ENOTSUP;
+                goto error;
+        }
+
+        bytes_line = (width + 7) / 8;
+        size = height * bytes_line;
+
+        data = malloc(size);
+        if (data == NULL) {
+                rc = ENOMEM;
                 goto error;
         }
@@ -571 +678 @@
                 goto error;
 
-        rc = riff_read(&bmpck, (void *) alloc.pixels,
-            width * height * sizeof(uint32_t), &nread);
-        if (rc != EOK)
-                goto error;
-
-        if (nread != width * height * sizeof(uint32_t)) {
+        rc = riff_read(&bmpck, data, size, &nread);
+        if (rc != EOK)
+                goto error;
+
+        if (nread != size) {
                 rc = EIO;
                 goto error;
@@ -585 +691 @@
                 goto error;
 
+        rc = gfx_font_bitmap_unpack(width, height, data, size, alloc.pixels);
+        if (rc != EOK)
+                goto error;
+
+        free(data);
         gfx_bitmap_destroy(font->bitmap);
         font->bitmap = bitmap;
@@ -590 +701 @@
         return EOK;
 error:
+        if (data != NULL)
+                free(data);
         if (bitmap != NULL)
                 gfx_bitmap_destroy(bitmap);
@@ -607 +720 @@
         riff_wchunk_t bmpck;
         gfx_bitmap_alloc_t alloc;
+        void *data = NULL;
+        size_t dsize;
+
+        rc = gfx_bitmap_get_alloc(font->bitmap, &alloc);
+        if (rc != EOK)
+                return rc;
+
+        rc = gfx_font_bitmap_pack(font->rect.p1.x, font->rect.p1.y,
+            alloc.pixels, &data, &dsize);
+        if (rc != EOK)
+                return rc;
 
         thdr.width = host2uint32_t_le(font->rect.p1.x);
         thdr.height = host2uint32_t_le(font->rect.p1.y);
         thdr.fmt = 0;
-        thdr.depth = host2uint16_t_le(8 * sizeof(uint32_t));
-
-        rc = gfx_bitmap_get_alloc(font->bitmap, &alloc);
-        if (rc != EOK)
-                return rc;
+        thdr.depth = host2uint16_t_le(1);
 
         rc = riff_wchunk_start(riffw, CKID_fbmp, &bmpck);
         if (rc != EOK)
-                return rc;
+                goto error;
 
         rc = riff_write(riffw, &thdr, sizeof(thdr));
         if (rc != EOK)
-                return rc;
-
-        rc = riff_write(riffw, (void *) alloc.pixels,
-            font->rect.p1.x * font->rect.p1.y * sizeof(uint32_t));
-        if (rc != EOK)
-                return rc;
+                goto error;
+
+        rc = riff_write(riffw, data, dsize);
+        if (rc != EOK)
+                goto error;
 
         rc = riff_wchunk_end(riffw, &bmpck);
         if (rc != EOK)
-                return rc;
-
-        return EOK;
+                goto error;
+
+        free(data);
+        return EOK;
+error:
+        if (data != NULL)
+                free(data);
+        return rc;
 }
 

uspace/lib/gfxfont/test/font.c

@@ -366 +366 @@
 }
 
+/** Test gfx_font_bitmap_pack() properly packs bitmap */
+PCUT_TEST(bitmap_pack)
+{
+        errno_t rc;
+        gfx_coord_t width, height;
+        gfx_coord_t i;
+        uint32_t *pixels;
+        void *data;
+        size_t size;
+        uint8_t *dp;
+
+        width = 10;
+        height = 10;
+
+        pixels = calloc(sizeof(uint32_t), width * height);
+        PCUT_ASSERT_NOT_NULL(pixels);
+
+        for (i = 0; i < 10; i++)
+                pixels[i * width + i] = PIXEL(255, 255, 255, 255);
+
+        rc = gfx_font_bitmap_pack(width, height, pixels, &data, &size);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+        PCUT_ASSERT_NOT_NULL(data);
+        PCUT_ASSERT_INT_EQUALS(20, size);
+
+        dp = data;
+
+        for (i = 0; i < 8; i++) {
+                PCUT_ASSERT_INT_EQUALS(0x80 >> i, dp[2 * i]);
+                PCUT_ASSERT_INT_EQUALS(0, dp[2 * i + 1]);
+        }
+
+        for (i = 8; i < 10; i++) {
+                PCUT_ASSERT_INT_EQUALS(0, dp[2 * i]);
+                PCUT_ASSERT_INT_EQUALS(0x80 >> (i - 8), dp[2 * i + 1]);
+        }
+}
+
+/** Test gfx_font_bitmap_unpack() properly unpacks bitmap */
+PCUT_TEST(bitmap_unpack)
+{
+        errno_t rc;
+        gfx_coord_t width, height;
+        gfx_coord_t i, j;
+        uint32_t epix;
+        uint32_t *pixels;
+        uint8_t data[20];
+
+        width = 10;
+        height = 10;
+
+        for (i = 0; i < 8; i++) {
+                data[2 * i] = 0x80 >> i;
+                data[2 * i + 1] = 0;
+        }
+
+        for (i = 8; i < 10; i++) {
+                data[2 * i] = 0;
+                data[2 * i + 1] = 0x80 >> (i - 8);
+        }
+
+        pixels = calloc(sizeof(uint32_t), width * height);
+        PCUT_ASSERT_NOT_NULL(pixels);
+
+        rc = gfx_font_bitmap_unpack(width, height, data, sizeof(data),
+            pixels);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        for (j = 0; j < 10; j++) {
+                for (i = 0; i < 10; i++) {
+                        epix = (i == j) ? PIXEL(255, 255, 255, 255) :
+                            PIXEL(0, 0, 0, 0);
+                        PCUT_ASSERT_INT_EQUALS(epix, pixels[j * width + i]);
+                }
+        }
+}
+
 static errno_t testgc_set_color(void *arg, gfx_color_t *color)
 {