Changeset 724


Ignore:
Timestamp:
Apr 6, 2006, 3:41:56 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Store colour information on 32 bits, for future 12-bit colour support.
Location:
libcaca/trunk
Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed

  • libcaca/trunk/caca/driver_conio.c

    r689 r724  
    9999{
    100100    char *screen = kk->drv.p->screen;
    101     uint8_t *attr = kk->qq->attr;
     101    uint32_t *attr = kk->qq->attr;
    102102    uint32_t *chars = kk->qq->chars;
    103103    int n;
    … …  
    106106    {
    107107        *screen++ = _cucul_utf32_to_cp437(*chars++);
    108         *screen++ = *attr++;
     108        *screen++ = _cucul_rgba32_to_ansi8(*attr++);
    109109    }
    110110#   if defined(SCREENUPDATE_IN_PC_H)

  • libcaca/trunk/caca/driver_gl.c

    r700 r724  
    246246    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
    247247    {
    248         uint8_t *attr = kk->qq->attr + line * kk->qq->width;
     248        uint32_t *attr = kk->qq->attr + line * kk->qq->width;
    249249
    250250        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
    251251        {
    252252            glDisable(GL_TEXTURE_2D);
    253             glColor4bv(gl_bgpal[attr[0] >> 4]);
     253            glColor4bv(gl_bgpal[_cucul_rgba32_to_ansi4bg(*attr++)]);
    254254            glBegin(GL_QUADS);
    255255                glVertex2f(x, y);
    … …  
    259259                glVertex2f(x, y + kk->drv.p->font_height);
    260260            glEnd();
    261 
    262             attr++;
    263261        }
    264262
    … …  
    274272    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
    275273    {
    276         uint8_t *attr = kk->qq->attr + line * kk->qq->width;
     274        uint32_t *attr = kk->qq->attr + line * kk->qq->width;
    277275        uint32_t *chars = kk->qq->chars + line * kk->qq->width;
    278276
    … …  
    284282            {
    285283                glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[c - 32]);
    286                 glColor4bv(gl_bgpal[attr[0] & 0xf]);
     284                glColor4bv(gl_bgpal[_cucul_rgba32_to_ansi4fg(*attr)]);
    287285                glBegin(GL_QUADS);
    288286                    glTexCoord2f(0, kk->drv.p->sh);

  • libcaca/trunk/caca/driver_ncurses.c

    r689 r724  
    191191{
    192192    int x, y;
    193     uint8_t *attr = kk->qq->attr;
     193    uint32_t *attr = kk->qq->attr;
    194194    uint32_t *chars = kk->qq->chars;
    195195    for(y = 0; y < (int)kk->qq->height; y++)
    … …  
    198198        for(x = kk->qq->width; x--; )
    199199        {
    200             attrset(kk->drv.p->attr[*attr++]);
     200            attrset(kk->drv.p->attr[_cucul_rgba32_to_ansi8(*attr++)]);
    201201            ncurses_write_utf32(*chars++);
    202202        }

  • libcaca/trunk/caca/driver_raw.c

    r702 r724  
    5656static void raw_display(caca_t *kk)
    5757{
    58     uint8_t *attr = kk->qq->attr;
     58    uint32_t *attr = kk->qq->attr;
    5959    uint32_t *chars = kk->qq->chars;
    6060    uint32_t w, h;
    … …  
    7171    {
    7272        uint32_t c = *chars++;
    73         uint8_t a = *attr++;
     73        uint32_t a = *attr++;
    7474
    75         fprintf(stdout, "%c%c%c%c%c", (c >> 24), (c >> 16) & 0xff,
    76                                       (c >> 8) & 0xff, c & 0xff, a);
     75        fprintf(stdout, "%c%c%c%c%c%c%c%c",
     76                (c >> 24), (c >> 16) & 0xff, (c >> 8) & 0xff, c & 0xff,
     77                (a >> 24), (a >> 16) & 0xff, (a >> 8) & 0xff, a & 0xff);
    7778    }
    7879

  • libcaca/trunk/caca/driver_slang.c

    r689 r724  
    203203{
    204204    int x, y;
    205     uint8_t *attr = kk->qq->attr;
     205    uint32_t *attr = kk->qq->attr;
    206206    uint32_t *chars = kk->qq->chars;
    207207    for(y = 0; y < (int)kk->qq->height; y++)
    … …  
    213213
    214214#if defined(OPTIMISE_SLANG_PALETTE)
    215             uint8_t fgcolor = *attr & 0xf;
    216             uint8_t bgcolor = *attr >> 4;
     215            uint8_t fgcolor = _cucul_rgba32_to_ansi4fg(*attr);
     216            uint8_t bgcolor = _cucul_rgba32_to_ansi4bg(*attr);
    217217
    218218            /* If foreground == background, just don't use this colour
    … …  
    220220            if(fgcolor != bgcolor)
    221221            {
    222                 SLsmg_set_color(slang_assoc[*attr++]);
     222                SLsmg_set_color(slang_assoc[_cucul_rgba32_to_ansi8(*attr++)]);
    223223                slang_write_utf32(c);
    224224            }
    … …  
    237237            }
    238238#else
    239             SLsmg_set_color(*attr++);
     239            SLsmg_set_color(_cucul_rgba32_to_ansi8(*attr++));
    240240            slang_write_utf32(c);
    241241#endif

  • libcaca/trunk/caca/driver_vga.c

    r689 r724  
    117117{
    118118    char *screen = (char *)(intptr_t)0x000b8000;
    119     uint8_t *attr = kk->qq->attr;
     119    uint32_t *attr = kk->qq->attr;
    120120    uint32_t *chars = kk->qq->chars;
    121121    int n;
    … …  
    124124    {
    125125        *screen++ = _cucul_utf32_to_cp437(*chars++);
    126         *screen++ = *attr++;
     126        *screen++ = _cucul_rgba32_to_ansi8(*attr++);
    127127    }
    128128}

  • libcaca/trunk/caca/driver_win32.c

    r689 r724  
    211211
    212212        kk->drv.p->buffer[i].Attributes =
    213                 win32_fg_palette[kk->qq->attr[i] & 0xf]
    214                  | win32_bg_palette[kk->qq->attr[i] >> 4];
     213                win32_fg_palette[_cucul_rgba32_to_ansi4fg(kk->qq->attr[i])]
     214                 | win32_bg_palette[_cucul_rgba32_to_ansi4bg(kk->qq->attr[i])];
    215215    }
    216216

  • libcaca/trunk/caca/driver_x11.c

    r689 r724  
    260260        for(x = 0; x < kk->qq->width; x += len)
    261261        {
    262             uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;
     262            uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;
     263            uint8_t bg = _cucul_rgba32_to_ansi4bg(*attr);
    263264
    264265            len = 1;
    265266            while(x + len < kk->qq->width
    266                    && (attr[len] >> 4) == (attr[0] >> 4))
     267                   && _cucul_rgba32_to_ansi4bg(attr[len]) == bg)
    267268                len++;
    268269
    269270            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
    270                            kk->drv.p->colors[attr[0] >> 4]);
     271                           kk->drv.p->colors[_cucul_rgba32_to_ansi4bg(*attr)]);
    271272            XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
    272273                           x * kk->drv.p->font_width, y * kk->drv.p->font_height,
    … …  
    284285        for(x = 0; x < kk->qq->width; x++, chars++)
    285286        {
    286             uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;
     287            uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;
    287288
    288289            /* Skip spaces */
    … …  
    291292
    292293            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
    293                            kk->drv.p->colors[*attr & 0xf]);
     294                           kk->drv.p->colors[_cucul_rgba32_to_ansi4fg(*attr)]);
    294295
    295296            /* Plain ASCII, no problem. */

  • libcaca/trunk/cucul/Makefile.am

    r673 r724  
    1212        transform.c \
    1313        charset.c \
     14        colour.c \
    1415        math.c \
    1516        line.c \

  • libcaca/trunk/cucul/canvas.c

    r723 r724  
    8282
    8383    qq->chars[x + y * qq->width] = c;
    84     qq->attr[x + y * qq->width] = (qq->bgcolor << 4) | qq->fgcolor;
     84    qq->attr[x + y * qq->width] = (qq->bgcolor << 16) | qq->fgcolor;
    8585}
    8686
    … …  
    9898void cucul_putstr(cucul_t *qq, int x, int y, char const *s)
    9999{
    100     uint32_t *chars;
    101     uint8_t *attr;
     100    uint32_t *chars, *attr;
    102101    unsigned int len;
    103102
    … …  
    125124    {
    126125        *chars++ = _cucul_utf8_to_utf32(s);
    127         *attr++ = (qq->bgcolor << 4) | qq->fgcolor;
     126        *attr++ = (qq->bgcolor << 16) | qq->fgcolor;
    128127
    129128        s = _cucul_skip_utf8(s, 1);
    … …  
    240239            memcpy(dst->attr + (j + y) * dst->width + starti + x,
    241240                   src->attr + j * src->width + starti,
    242                    (endi - starti) * 1);
     241                   (endi - starti) * 4);
    243242        }
    244243    }
    … …  
    256255
    257256    qq->chars[x + y * qq->width] = c;
    258     qq->attr[x + y * qq->width] = (qq->bgcolor << 4) | qq->fgcolor;
    259 }
    260 
     257    qq->attr[x + y * qq->width] = (qq->bgcolor << 16) | qq->fgcolor;
     258}
     259

  • libcaca/trunk/cucul/cucul.c

    r722 r724  
    2222
    2323#if !defined(__KERNEL__)
     24#   include <stdio.h>
    2425#   include <stdlib.h>
    2526#   include <string.h>
    … …  
    9495        return NULL;
    9596
    96     if(size != 12 + width * height * 5 + 4)
     97    if(size != 12 + width * height * 8 + 4)
    9798        return NULL;
    9899
    … …  
    108109    for(n = height * width; n--; )
    109110    {
    110         qq->chars[n] = ((uint32_t)buf[12 + 5 * n] << 24)
    111                      | ((uint32_t)buf[13 + 5 * n] << 16)
    112                      | ((uint32_t)buf[14 + 5 * n] << 8)
    113                      | (uint32_t)buf[15 + 5 * n];
    114         qq->attr[n] = buf[16 + 5 * n];
     111        qq->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
     112                     | ((uint32_t)buf[13 + 8 * n] << 16)
     113                     | ((uint32_t)buf[14 + 8 * n] << 8)
     114                     | (uint32_t)buf[15 + 8 * n];
     115        qq->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
     116                    | ((uint32_t)buf[17 + 8 * n] << 16)
     117                    | ((uint32_t)buf[18 + 8 * n] << 8)
     118                    | (uint32_t)buf[19 + 8 * n];
    115119    }
    116120
    … …  
    300304    {
    301305        qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    302         qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
     306        qq->attr = realloc(qq->attr, new_size * sizeof(uint32_t));
    303307    }
    304308
    … …  
    326330                qq->chars[y * width + old_width + x] = (uint32_t)' ';
    327331            memset(qq->attr + y * width + old_width, 0,
    328                    width - old_width);
     332                   (width - old_width) * 4);
    329333        }
    330334    }
    … …  
    352356            qq->chars[old_height * width + x] = (uint32_t)' ';
    353357        memset(qq->attr + old_height * width, 0,
    354                (height - old_height) * width);
     358               (height - old_height) * width * 4);
    355359    }
    356360
    … …  
    359363    {
    360364        qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    361         qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
     365        qq->attr = realloc(qq->attr, new_size * sizeof(uint32_t));
    362366    }
    363367

  • libcaca/trunk/cucul/cucul_internals.h

    r711 r724  
    3838
    3939    uint32_t *chars;
    40     uint8_t *attr;
     40    uint32_t *attr;
    4141    char *empty_line, *scratch_line;
    4242
    … …  
    6262extern uint32_t _cucul_cp437_to_utf32(uint8_t);
    6363
     64/* Colour functions */
     65uint8_t _cucul_rgba32_to_ansi8(uint32_t);
     66uint8_t _cucul_rgba32_to_ansi4fg(uint32_t);
     67uint8_t _cucul_rgba32_to_ansi4bg(uint32_t);
     68
    6469/* Export functions */
    6570extern void _cucul_get_ansi(cucul_t *, struct cucul_export *);

  • libcaca/trunk/cucul/export_ansi.c

    r672 r724  
    5959    for(y = 0; y < qq->height; y++)
    6060    {
    61         uint8_t *lineattr = qq->attr + y * qq->width;
     61        uint32_t *lineattr = qq->attr + y * qq->width;
    6262        uint32_t *linechar = qq->chars + y * qq->width;
    6363
    … …  
    6767        for(x = 0; x < qq->width; x++)
    6868        {
    69             uint8_t fg = palette[lineattr[x] & 0x0f];
    70             uint8_t bg = palette[lineattr[x] >> 4];
     69            uint8_t fg = _cucul_rgba32_to_ansi4fg(lineattr[x]);
     70            uint8_t bg = _cucul_rgba32_to_ansi4bg(lineattr[x]);
    7171            uint32_t c = linechar[x];
    7272

  • libcaca/trunk/cucul/export_html.c

    r672 r724  
    7373    for(y = 0; y < qq->height; y++)
    7474    {
    75         uint8_t *lineattr = qq->attr + y * qq->width;
     75        uint32_t *lineattr = qq->attr + y * qq->width;
    7676        uint32_t *linechar = qq->chars + y * qq->width;
    7777
    7878        for(x = 0; x < qq->width; x += len)
    7979        {
    80             cur += sprintf(cur, "<span class='b%02x'>", lineattr[x]);
     80            cur += sprintf(cur, "<span class='b%02x'>",
     81                           _cucul_rgba32_to_ansi8(lineattr[x]));
    8182
    8283            for(len = 0;
    … …  
    142143    for(y = 0; y < qq->height; y++)
    143144    {
    144         uint8_t *lineattr = qq->attr + y * qq->width;
     145        uint32_t *lineattr = qq->attr + y * qq->width;
    145146        uint32_t *linechar = qq->chars + y * qq->width;
    146147
    … …  
    157158                len++;
    158159
    159             cur += sprintf(cur, "<td bgcolor=#%06x", palette[lineattr[x] >> 4]);
     160            cur += sprintf(cur, "<td bgcolor=#%06x",
     161                           _cucul_rgba32_to_ansi4bg(lineattr[x]));
    160162
    161163            if(len > 1)
    … …  
    163165
    164166            cur += sprintf(cur, "><font color=#%06x>",
    165                                 palette[lineattr[x] & 0x0f]);
     167                           _cucul_rgba32_to_ansi4fg(lineattr[x]));
    166168
    167169            for(i = 0; i < len; i++)

  • libcaca/trunk/cucul/export_irc.c

    r672 r724  
    6363    for(y = 0; y < qq->height; y++)
    6464    {
    65         uint8_t *lineattr = qq->attr + y * qq->width;
     65        uint32_t *lineattr = qq->attr + y * qq->width;
    6666        uint32_t *linechar = qq->chars + y * qq->width;
    6767
    … …  
    7171        for(x = 0; x < qq->width; x++)
    7272        {
    73             uint8_t fg = palette[lineattr[x] & 0x0f];
    74             uint8_t bg = palette[lineattr[x] >> 4];
     73            uint8_t fg = palette[_cucul_rgba32_to_ansi4fg(lineattr[x])];
     74            uint8_t bg = palette[_cucul_rgba32_to_ansi4bg(lineattr[x])];
    7575            uint32_t c = linechar[x];
    7676

  • libcaca/trunk/cucul/export_ps.c

    r672 r724  
    8686    for(y = qq->height; y--; )
    8787    {
    88         uint8_t *lineattr = qq->attr + y * qq->width;
     88        uint32_t *lineattr = qq->attr + y * qq->width;
    8989
    9090        for(x = 0; x < qq->width; x++)
    9191        {
    9292            cur += sprintf(cur, "1 0 translate\n %s csquare\n",
    93                                 palette[*lineattr++ >> 4]);
     93                           _cucul_rgba32_to_ansi4bg(*lineattr++));
    9494        }
    9595
    … …  
    102102    for(y = qq->height; y--; )
    103103    {
    104         uint8_t *lineattr = qq->attr + (qq->height - y - 1) * qq->width;
     104        uint32_t *lineattr = qq->attr + (qq->height - y - 1) * qq->width;
    105105        uint32_t *linechar = qq->chars + (qq->height - y - 1) * qq->width;
    106106
    … …  
    112112            cur += sprintf(cur, "%d %d moveto\n", (x + 1) * 6, y * 10);
    113113            cur += sprintf(cur, "%s setrgbcolor\n",
    114                                 palette[*lineattr++ & 0x0f]);
     114                                _cucul_rgba32_to_ansi4fg(*lineattr++));
    115115
    116116            if(c < 0x00000020)

  • libcaca/trunk/cucul/export_svg.c

    r672 r724  
    8383    for(y = 0; y < qq->height; y++)
    8484    {
    85         uint8_t *lineattr = qq->attr + y * qq->width;
     85        uint32_t *lineattr = qq->attr + y * qq->width;
    8686
    8787        for(x = 0; x < qq->width; x++)
    … …  
    8989            cur += sprintf(cur, "<rect class=\"b%02x\" x=\"%d\" y=\"%d\""
    9090                                " width=\"6\" height=\"10\"/>\n",
    91                                 *lineattr++, x * 6, y * 10);
     91                                _cucul_rgba32_to_ansi8(*lineattr++),
     92                                x * 6, y * 10);
    9293        }
    9394    }
    … …  
    9697    for(y = 0; y < qq->height; y++)
    9798    {
    98         uint8_t *lineattr = qq->attr + y * qq->width;
     99        uint32_t *lineattr = qq->attr + y * qq->width;
    99100        uint32_t *linechar = qq->chars + y * qq->width;
    100101
    … …  
    104105
    105106            cur += sprintf(cur, "<text class=\"f%02x\" x=\"%d\" y=\"%d\">",
    106                                 *lineattr++, x * 6, (y * 10) + 10);
     107                                _cucul_rgba32_to_ansi8(*lineattr++),
     108                                x * 6, (y * 10) + 10);
    107109            if(c < 0x00000020)
    108110                cur += sprintf(cur, "?");

  • libcaca/trunk/cucul/transform.c

    r696 r724  
    3939void cucul_invert(cucul_t *qq)
    4040{
    41     uint8_t *attr = qq->attr;
     41    uint32_t *attr = qq->attr;
    4242    unsigned int i;
    4343
    4444    for(i = qq->height * qq->width; i--; )
    4545    {
    46         *attr = ~*attr;
     46        *attr = *attr ^ 0x000f000f;
    4747        attr++;
    4848    }
    … …  
    6464        uint32_t *cleft = qq->chars + y * qq->width;
    6565        uint32_t *cright = cleft + qq->width - 1;
    66         uint8_t *aleft = qq->attr + y * qq->width;
    67         uint8_t *aright = aleft + qq->width - 1;
     66        uint32_t *aleft = qq->attr + y * qq->width;
     67        uint32_t *aright = aleft + qq->width - 1;
    6868
    6969        while(cleft < cright)
    7070        {
    7171            uint32_t ch;
    72             uint8_t attr;
     72            uint32_t attr;
    7373
    7474            /* Swap attributes */
    … …  
    101101        uint32_t *ctop = qq->chars + x;
    102102        uint32_t *cbottom = ctop + qq->width * (qq->height - 1);
    103         uint8_t *atop = qq->attr + x;
    104         uint8_t *abottom = atop + qq->width * (qq->height - 1);
     103        uint32_t *atop = qq->attr + x;
     104        uint32_t *abottom = atop + qq->width * (qq->height - 1);
    105105
    106106        while(ctop < cbottom)
    107107        {
    108108            uint32_t ch;
    109             uint8_t attr;
     109            uint32_t attr;
    110110
    111111            /* Swap attributes */
    … …  
    136136    uint32_t *cbegin = qq->chars;
    137137    uint32_t *cend = cbegin + qq->width * qq->height - 1;
    138     uint8_t *abegin = qq->attr;
    139     uint8_t *aend = abegin + qq->width * qq->height - 1;
     138    uint32_t *abegin = qq->attr;
     139    uint32_t *aend = abegin + qq->width * qq->height - 1;
    140140
    141141    while(cbegin < cend)
    142142    {
    143143        uint32_t ch;
    144         uint8_t attr;
     144        uint32_t attr;
    145145
    146146        /* Swap attributes */

  • libcaca/trunk/src/cacaserver.c

    r721 r724  
    215215               | ((uint32_t)buf[10] << 8) | (uint32_t)buf[11];
    216216
    217         size = 12 + width * height * 5 + 4;
     217        size = 12 + width * height * 8 + 4;
    218218        buf = server->input = realloc(server->input, size);
    219219        read(0, buf + 12, size - 12);
Note: See TracChangeset for help on using the changeset viewer.