Return to gfxutil.c CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/gfxutil.c, revision 1.1.1.1

1.1       root        1:  /* 
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   * 
                      4:   * Common code needed by all the various graphics systems.
                      5:   * 
                      6:   * (c) 1996 Bernd Schmidt, Ed Hanway
                      7:   */
                      8: 
                      9: #include "sysconfig.h"
                     10: #include "sysdeps.h"
                     11: 
                     12: #include "config.h"
                     13: #include "options.h"
                     14: #include "memory.h"
                     15: #include "custom.h"
                     16: #include "newcpu.h"
                     17: #include "keyboard.h"
                     18: #include "xwin.h"
                     19: #include "keybuf.h"
                     20: 
                     21: unsigned long doMask(int p, int bits, int shift)
                     22: {
                     23:     /* p is a value from 0 to 15 (Amiga color value)
                     24:      * scale to 0..255, shift to align msb with mask, and apply mask */
                     25: 
                     26:     unsigned long val = p * 0x11111111UL;
                     27:     val >>= (32 - bits);
                     28:     val <<= shift;
                     29: 
                     30:     return val;
                     31: }
                     32: 
                     33: void alloc_colors64k(int rw, int gw, int bw, int rs, int gs, int bs)
                     34: {
                     35:     int i;
                     36:     for(i=0; i<4096; i++) {
                     37:        int r = i >> 8;
                     38:        int g = (i >> 4) & 0xF;
                     39:        int b = i & 0xF;
                     40:        xcolors[i] = doMask(r, rw, rs) | doMask(g, gw, gs) | doMask(b, bw, bs);
                     41:     }
                     42: }
                     43: 
                     44: static int allocated[4096];
                     45: 
                     46: void alloc_colors256(int (* allocfunc)(int, int, int, xcolnr *))
                     47: {
                     48:     /* This is kind of kludgy...
                     49:      * Try to allocate as many different colors as possible. */
                     50:     int step = 5, mode = 0, count = 0, col;
                     51:     int no_allocated = 0;
                     52: 
                     53:     memset(allocated, 0, sizeof allocated);
                     54:     fprintf(stderr, "Allocating lots of colors...\n");
                     55:     
                     56:     do {
                     57:        int r, g, b, rs, bs, gs;
                     58:        bs = step;
                     59:        rs = step;
                     60:        gs = step;
                     61:        for(b = 0; b < 16; b += bs) {
                     62:            for(r = 0; r < 16; r += rs) {
                     63:                for(g = 0; g < 16; g += gs) {
                     64:                    int cnr = (r << 8) + (g << 4) + b;
                     65:                    if (!allocated[cnr]) {
                     66:                        int result = allocfunc(r, g, b, xcolors + cnr);
                     67:                        if (result < 0 || no_allocated == 256)
                     68:                            goto finished;
                     69:                        if (result > 0) {
                     70:                            allocated[cnr] = 1;
                     71:                            no_allocated++;
                     72:                        }
                     73:                    }
                     74:                }
                     75:            }
                     76:        }
                     77:        if (step > 1)
                     78:            step++;
                     79:        step /= 2;
                     80:     } while (step);
                     81:     
                     82:     finished:
                     83: #if 0
                     84:     for(col = 0; col < 4096; col++) {
                     85:        int cnr = col;
                     86:        if (!allocated[cnr]) {
                     87:            int r = cnr >> 8;
                     88:            int g = (cnr >> 4) & 0xF;
                     89:            int b = cnr & 0xF;
                     90:            int maxd = 4096,best = 0;
                     91:            int c2;
                     92:            for(c2 = 0; c2 < 4096; c2++)
                     93:                if (allocated[c2]) {
                     94:                    int r2 = c2 >> 8;
                     95:                    int g2 = (c2 >> 4) & 0xF;
                     96:                    int b2 = c2 & 0xF;
                     97:                    int rd = (r2-r)*r*2;
                     98:                    int bd = (b2-b)*b*2;
                     99:                    int gd = (g2-g)*g*2;
                    100:                    int dist = abs(rd) + abs(gd) + abs(bd) + abs(rd-gd)/3 + abs(rd-bd)/3 + abs(gd-bd)/3;
                    101:                    if (dist < maxd) {
                    102:                        maxd = dist;
                    103:                        best = c2;
                    104:                    }
                    105:                }
                    106:            cnr = best;
                    107:        }
                    108:        xcolors[col] = xcolors[cnr];
                    109:     }
                    110: #else
                    111:     for(col = 0; col < 4096; col++) {
                    112:        int cnr;
                    113:        int dist;
                    114:        int r = col >> 8;
                    115:        int g = (col >> 4) & 0xF;
                    116:        int b = col & 0xF;
                    117:        
                    118:        if (allocated[col])
                    119:            continue;
                    120:        
                    121:        for (dist = 2;; dist++) {
                    122:            int r2, g2, b2;
                    123:            int rd, gd, bd;
                    124:            int best = 0, maxd = 32767;
                    125:            for (gd = 0; gd < dist; gd = gd < 0 ? -gd : -gd-1) {
                    126:                g2 = g + gd;
                    127:                if (g2 < 0 || g2 > 15)
                    128:                    continue;
                    129:                for (rd = 0; rd < dist; rd = rd < 0 ? -rd : -rd-1) {
                    130:                    r2 = r + rd;
                    131:                    if (r2 < 0 || r2 > 15)
                    132:                        continue;
                    133:                    for (bd = 0; bd < dist; bd = bd < 0 ? -bd : -bd-1) {
                    134:                        b2 = b + bd;
                    135:                        if (b2 < 0 || b2 > 15)
                    136:                            continue;
                    137:                        cnr = (r2 << 8) + (g2 << 4) + b2;
                    138:                        if (allocated[cnr]) {
                    139:                            int rd2 = rd == 0 ? 0 : rd*32/r;
                    140:                            int gd2 = gd == 0 ? 0 : gd*32/g;
                    141:                            int bd2 = bd == 0 ? 0 : bd*32/b;
                    142:                            int dist = abs(rd) + abs(gd) + abs(bd) + abs(rd2-gd2) + abs(rd2-bd2) + abs(gd2-bd2);
                    143:                            if (dist < maxd) {
                    144:                                maxd = dist;
                    145:                                xcolors[col] = xcolors[cnr];
                    146:                            }
                    147:                        }
                    148:                    }
                    149:                }
                    150:            }
                    151:            if (maxd != 32767)
                    152:                break;
                    153:        }
                    154:     }
                    155: #endif
                    156: }
                    157: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.