Changeset 238Tweet

Timestamp:

Nov 30, 2003, 4:01:55 PM (19 years ago)

Author:

Sam Hocevar

Message:

• src/bitmap.c: + Fixed an endianness issue in the byte reader. + Decreased precision in RGB and HSV values to avoid overflows. + New dithering method: 2x2 ordered. + New renderer, with background colour awareness.
• configure.ac: + Check for <endian.h>.
• examples/demo.c examples/view.c: + Fixed an endianness issue in cacaview. + Adapted code to the additional dithering method.

Location:

libcaca/trunk

Files:

• configure.ac (modified) (2 diffs)
• examples/demo.c (modified) (1 diff)
• examples/view.c (modified) (6 diffs)
• src/bitmap.c (modified) (11 diffs)
• src/caca.c (modified) (2 diffs)
• src/caca.h (modified) (1 diff)

libcaca/trunk/configure.ac

@@ -7 +7 @@
 AC_CANONICAL_SYSTEM
 
-AM_INIT_AUTOMAKE(libcaca, 0.1)
+AM_INIT_AUTOMAKE(libcaca, 0.2)
 AM_CONFIG_HEADER(config.h)
 
@@ -25 +25 @@
   [  --enable-conio          DOS conio.h graphics support (default disabled)])
 
-AC_CHECK_HEADERS(inttypes.h)
+AC_CHECK_HEADERS(inttypes.h endian.h)
 AC_CHECK_FUNCS(vsnprintf getenv putenv)
 

libcaca/trunk/examples/demo.c

@@ -101 +101 @@
             case 'd':
             case 'D':
-                dithering = (dithering + 1) % 4;
+                dithering = (dithering + 1) % 5;
                 caca_set_dithering(dithering);
                 display_menu();

libcaca/trunk/examples/view.c

@@ -29 +29 @@
 #include <unistd.h>
 
+#ifdef HAVE_ENDIAN_H
+#   include <endian.h>
+#endif
+
 #include <Imlib2.h>
 
@@ -37 +41 @@
 struct caca_bitmap *bitmap = NULL;
 int x, y, w, h;
+unsigned int rmask, gmask, bmask;
 
 int dithering = CACA_DITHERING_ORDERED4;
@@ -49 +54 @@
     char **list = NULL;
     int current = 0, items = 0, opts = 1;
+
+#ifdef HAVE_ENDIAN_H
+    if(__BYTE_ORDER == __BIG_ENDIAN)
+#else
+    rmask = 0x12345678;
+    if(*(char *)&rmask == 0x12)
+#endif
+    {
+        rmask = 0x00ff0000; gmask = 0x0000ff00; bmask = 0x000000ff;
+    }
+    else
+    {
+        rmask = 0x0000ff00; gmask = 0x00ff0000; bmask = 0xff000000;
+    }
 
     /* Initialise libcaca */
@@ -102 +121 @@
                 break;
             case CACA_EVENT_KEY_PRESS | 'd':
-                dithering = (dithering + 1) % 4;
+                dithering = (dithering + 1) % 5;
                 update = 1;
                 break;
             case CACA_EVENT_KEY_PRESS | 'D':
-                dithering = (dithering - 1) % 4;
+                dithering = (dithering + 4) % 5;
                 update = 1;
                 break;
@@ -216 +235 @@
             if(yn + y > h) y = h - yn;
             newbitmap = caca_create_bitmap(32, 2 * xn, 2 * yn, 4 * w,
-                                       0x0000ff00, 0x00ff0000, 0xff000000);
+                                           rmask, gmask, bmask);
             caca_draw_bitmap(0, 0, ww - 1, wh - 1, newbitmap,
                              pixels + 4 * (x - xn) + 4 * w * (y - yn));
@@ -298 +317 @@
 
     /* Create the libcaca bitmap */
-    bitmap = caca_create_bitmap(32, w, h, 4 * w,
-                                0x0000ff00, 0x00ff0000, 0xff000000);
+    bitmap = caca_create_bitmap(32, w, h, 4 * w, rmask, gmask, bmask);
     if(!bitmap)
     {

libcaca/trunk/src/bitmap.c

@@ -54 +54 @@
 static void increment_no_dither(void);
 
+static void init_ordered2_dither(int);
+static unsigned int get_ordered2_dither(void);
+static void increment_ordered2_dither(void);
+
 static void init_ordered4_dither(int);
 static unsigned int get_ordered4_dither(void);
@@ -81 +85 @@
         _get_dither = get_no_dither;
         _increment_dither = increment_no_dither;
+        break;
+
+    case CACA_DITHERING_ORDERED2:
+        _init_dither = init_ordered2_dither;
+        _get_dither = get_ordered2_dither;
+        _increment_dither = increment_ordered2_dither;
         break;
 
@@ -141 +151 @@
         lshift++;
     }
-    *left = 16 - lshift;
-}
-
-#include <stdio.h>
+    *left = 12 - lshift;
+}
+
 struct caca_bitmap *caca_create_bitmap(int bpp, int w, int h, int pitch,
                                        int rmask, int gmask, int bmask)
@@ -176 +185 @@
         mask2shift(bmask, &bitmap->bright, &bitmap->bleft);
     }
-fprintf(stderr, "shifts: %i %i %i %i %i %i\n", bitmap->rright, bitmap->rleft, bitmap->gright, bitmap->gleft, bitmap->bright, bitmap->bleft);
 
     /* In 8 bpp mode, default to a grayscale palette */
@@ -185 +193 @@
         for(i = 0; i < 256; i++)
         {
-            bitmap->red[i] = i * 0x100;
-            bitmap->green[i] = i * 0x100;
-            bitmap->blue[i] = i * 0x100;
+            bitmap->red[i] = i * 0x10;
+            bitmap->green[i] = i * 0x10;
+            bitmap->blue[i] = i * 0x10;
         }
     }
@@ -204 +212 @@
     for(i = 0; i < 256; i++)
     {
-        if(red[i] >= 0 && red[i] < 65536 &&
-           green[i] >= 0 && green[i] < 65536 &&
-           blue[i] >= 0 && blue[i] < 65536)
+        if(red[i] >= 0 && red[i] < 0x1000 &&
+           green[i] >= 0 && green[i] < 0x1000 &&
+           blue[i] >= 0 && blue[i] < 0x1000)
         {
             bitmap->red[i] = red[i];
@@ -281 +289 @@
     if(delta)
     {
-        *sat = 0x1000 * delta / max * 0x10; /* 0 - 0xffff */
-
-        /* Generate *hue between 0 and 0x5ffff */
+        *sat = 0x1000 * delta / max; /* 0 - 0xfff */
+
+        /* Generate *hue between 0 and 0x5fff */
         if( r == max )
-            *hue = 0x10000 + 0x100 * (g - b) / delta * 0x100;
+            *hue = 0x1000 + 0x1000 * (g - b) / delta;
         else if( g == max )
-            *hue = 0x30000 + 0x100 * (b - r) / delta * 0x100;
+            *hue = 0x3000 + 0x1000 * (b - r) / delta;
         else
-            *hue = 0x50000 + 0x100 * (r - g) / delta * 0x100;
+            *hue = 0x5000 + 0x1000 * (r - g) / delta;
     }
     else
@@ -304 +312 @@
     static int white_colors[] =
     {
+        CACA_COLOR_BLACK,
         CACA_COLOR_DARKGRAY,
         CACA_COLOR_LIGHTGRAY,
@@ -331 +340 @@
     };
 
-    static char foo[] =
+    /* FIXME: choose better characters! */
+#   define DENSITY_CHARS 13
+    static char density_chars[] =
         "    "
-        " ,' "
+        "    "
+        ".`  "
         ",`.'"
-        "i-:^"
-        "|/;\\"
-        "=+ox"
-        "<x%>"
-        "&z$w"
+        "i:-^"
+        "|=+;"
+        "ox/\\"
+        "<>x%"
+        "&$zw"
         "WXKM"
         "#8##"
         "8@8#"
-        "@8@8";
+        "@8@8"
+        "????";
 
     int x, y, w, h, pitch;
@@ -365 +378 @@
 
     for(y = y1 > 0 ? y1 : 0; y <= y2 && y <= (int)caca_get_height(); y++)
-    {
-        /* Initialize dither tables for the current line */
-        _init_dither(y);
-
-        /* Dither the current line */
-        for(x = x1 > 0 ? x1 : 0; x <= x2 && x <= (int)caca_get_width(); x++)
-        {
-            int ch;
-            unsigned int hue, sat, val, r, g, b, R, G, B;
-            int fromx = w * (x - x1) / (x2 - x1 + 1);
-            int fromy = h * (y - y1) / (y2 - y1 + 1);
-
-            /* Clip values (yuck) */
-            if(fromx == 0) fromx = 1;
-            if(fromy == 0) fromy = 1;
-
-            /* First get RGB */
-            R = 0, G = 0, B = 0;
-            get_rgb_default(bitmap, pixels, fromx, fromy, &r, &g, &b);
-            R += r; G += g; B += b;
-            get_rgb_default(bitmap, pixels, fromx - 1, fromy, &r, &g, &b);
-            R += r; G += g; B += b;
-            get_rgb_default(bitmap, pixels, fromx, fromy - 1, &r, &g, &b);
-            R += r; G += g; B += b;
-            get_rgb_default(bitmap, pixels, fromx + 1, fromy, &r, &g, &b);
-            R += r; G += g; B += b;
-            get_rgb_default(bitmap, pixels, fromx, fromy + 1, &r, &g, &b);
-            R += r; G += g; B += b;
-            R /= 5; G /= 5; B /= 5;
-
-            /* Now get HSV from RGB */
-            rgb2hsv_default(R, G, B, &hue, &sat, &val);
-
-            if(sat < 0x2000 + _get_dither() * 0x80)
-                caca_set_color(white_colors[val * 3 / 0x10000], CACA_COLOR_BLACK);
-            else if(val > 0x8000 + _get_dither() * 0x40)
-                caca_set_color(light_colors[(hue + _get_dither() * 0x100) / 0x10000], CACA_COLOR_BLACK);
-            else
-                caca_set_color(dark_colors[(hue + _get_dither() * 0x100) / 0x10000], CACA_COLOR_BLACK);
-
-            /* FIXME: choose better characters! */
-            ch = (val + 0x20 * _get_dither() - 0x1000 /*???*/) * 10 / 0x10000;
-            ch = 4 * ch + (_get_dither() + 8) / 0x40;
-            caca_putchar(x, y, foo[ch]);
-
-            _increment_dither();
-        }
+        for(x = x1 > 0 ? x1 : 0, _init_dither(y);
+            x <= x2 && x <= (int)caca_get_width();
+            x++)
+    {
+        int ch;
+        unsigned int r, g, b, R, G, B;
+        int hue, sat, val;
+        int fromx = w * (x - x1) / (x2 - x1 + 1);
+        int fromy = h * (y - y1) / (y2 - y1 + 1);
+        enum caca_color outfg, outbg;
+        char outch;
+#define NEW_DITHERER 1
+#ifdef NEW_DITHERER
+        int distbg, distfg, dist;
+#endif
+
+        /* Clip values (yuck) */
+        if(fromx == 0) fromx = 1;
+        if(fromy == 0) fromy = 1;
+
+        /* First get RGB */
+        R = 0, G = 0, B = 0;
+        get_rgb_default(bitmap, pixels, fromx, fromy, &r, &g, &b);
+#if 0
+        R += r; G += g; B += b;
+        get_rgb_default(bitmap, pixels, fromx - 1, fromy, &r, &g, &b);
+        R += r; G += g; B += b;
+        get_rgb_default(bitmap, pixels, fromx, fromy - 1, &r, &g, &b);
+        R += r; G += g; B += b;
+        get_rgb_default(bitmap, pixels, fromx + 1, fromy, &r, &g, &b);
+        R += r; G += g; B += b;
+        get_rgb_default(bitmap, pixels, fromx, fromy + 1, &r, &g, &b);
+        R += r; G += g; B += b;
+        R /= 5; G /= 5; B /= 5;
+#else
+        R += r; G += g; B += b;
+#endif
+
+        /* Now get HSV from RGB */
+        rgb2hsv_default(R, G, B, &hue, &sat, &val);
+
+        /* The hard work: calculate foreground and background colours,
+         * as well as the most appropriate character to output. */
+#if NEW_DITHERER
+#define XRATIO 5*5
+#define YRATIO 3*3
+        /* distance to black */
+        distbg = XRATIO * val * val;
+        distbg += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        outbg = CACA_COLOR_BLACK;
+
+        /* distance to 30% */
+        dist = XRATIO * (val - 0x600) * (val - 0x600)
+             + YRATIO * sat * sat;
+        dist += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        if(dist <= distbg)
+        {
+            outfg = outbg;
+            distfg = distbg;
+            outbg = CACA_COLOR_DARKGRAY;
+            distbg = dist;
+        }
+        else
+        {
+            outfg = CACA_COLOR_DARKGRAY;
+            distfg = dist;
+        }
+
+        /* check dist to 70% */
+        dist = XRATIO * (val - 0xa00) * (val - 0xa00)
+             + YRATIO * sat * sat;
+        dist += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        if(dist <= distbg)
+        {
+            outfg = outbg;
+            distfg = distbg;
+            outbg = CACA_COLOR_LIGHTGRAY;
+            distbg = dist;
+        }
+        else if(dist <= distfg)
+        {
+            outfg = CACA_COLOR_LIGHTGRAY;
+            distfg = dist;
+        }
+
+        /* check dist to white */
+        dist = XRATIO * (val - 0x1000) * (val - 0x1000)
+             + YRATIO * sat * sat;
+        dist += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        if(dist <= distbg)
+        {
+            outfg = outbg;
+            distfg = distbg;
+            outbg = CACA_COLOR_WHITE;
+            distbg = dist;
+        }
+        else if(dist <= distfg)
+        {
+            outfg = CACA_COLOR_WHITE;
+            distfg = dist;
+        }
+
+        /* check dist to dark */
+        dist = XRATIO * (val - 0x600) * (val - 0x600)
+             + YRATIO * (sat - 0x1000) * (sat - 0x1000);
+        dist += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        dist = dist * 3 / 4;
+        if(dist <= distbg)
+        {
+            outfg = outbg;
+            distfg = distbg;
+            outbg = dark_colors[(hue + _get_dither() * 0x10) / 0x1000];
+            distbg = dist;
+        }
+        else if(dist <= distfg)
+        {
+            outfg = dark_colors[(hue + _get_dither() * 0x10) / 0x1000];
+            distfg = dist;
+        }
+
+        /* check dist to light */
+        dist = XRATIO * (val - 0x1000) * (val - 0x1000)
+             + YRATIO * (sat - 0x1000) * (sat - 0x1000);
+        dist += XRATIO * 0x1000 * _get_dither() - XRATIO * 0x8000;
+        dist = dist / 2;
+        if(dist <= distbg)
+        {
+            outfg = outbg;
+            distfg = distbg;
+            outbg = light_colors[(hue + _get_dither() * 0x10) / 0x1000];
+            distbg = dist;
+        }
+        else if(dist <= distfg)
+        {
+            outfg = light_colors[(hue + _get_dither() * 0x10) / 0x1000];
+            distfg = dist;
+        }
+
+        if(distbg <= 0) distbg = 1;
+        if(distfg <= 0) distfg = 1;
+
+        /* distbg can be > distfg because of dithering fuzziness */
+        ch = distbg * 2 * (DENSITY_CHARS - 1) / (distbg + distfg);
+        ch = 4 * ch /*+ _get_dither() / 0x40*/;
+        outch = density_chars[ch];
+
+#else
+        outbg = CACA_COLOR_BLACK;
+        if(sat < 0x200 + _get_dither() * 0x8)
+            outfg = white_colors[1 + (val * 2 + _get_dither() * 0x10) / 0x1000];
+        else if(val > 0x800 + _get_dither() * 0x4)
+            outfg = light_colors[(hue + _get_dither() * 0x10) / 0x1000];
+        else
+            outfg = dark_colors[(hue + _get_dither() * 0x10) / 0x1000];
+
+        ch = (val + 0x2 * _get_dither()) * 10 / 0x1000;
+        ch = 4 * ch + _get_dither() / 0x40;
+        outch = density_chars[ch];
+
+#endif
+
+        /* Now output the character */
+        caca_set_color(outfg, outbg);
+        caca_putchar(x, y, outch);
+
+        _increment_dither();
     }
 }
@@ -435 +567 @@
 {
     return;
+}
+
+/*
+ * Ordered 2 dithering
+ */
+static unsigned int *ordered2_table;
+static unsigned int ordered2_index;
+
+static void init_ordered2_dither(int line)
+{
+    static unsigned int dither2x2[] =
+    {
+        0x00, 0x80,
+        0xc0, 0x40,
+    };
+
+    ordered2_table = dither2x2 + (line % 2) * 2;
+    ordered2_index = 0;
+}
+
+static unsigned int get_ordered2_dither(void)
+{
+    return ordered2_table[ordered2_index];
+}
+
+static void increment_ordered2_dither(void)
+{
+    ordered2_index = (ordered2_index + 1) % 2;
 }
 

libcaca/trunk/src/caca.c

@@ -186 +186 @@
     {
         "no",
+        "2x2 ordered",
         "4x4 ordered",
         "8x8 ordered",
@@ -191 +192 @@
     };
 
-    if(dithering < 0 || dithering > 3)
+    if(dithering < 0 || dithering > 4)
         return "unknown";
 

libcaca/trunk/src/caca.h

@@ -90 +90 @@
 {
     CACA_DITHERING_NONE = 0,
-    CACA_DITHERING_ORDERED4 = 1,
-    CACA_DITHERING_ORDERED8 = 2,
-    CACA_DITHERING_RANDOM = 3
+    CACA_DITHERING_ORDERED2 = 1,
+    CACA_DITHERING_ORDERED4 = 2,
+    CACA_DITHERING_ORDERED8 = 3,
+    CACA_DITHERING_RANDOM = 4
 };