pad.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include "conf.h"
   6 #include "draw.h"
   7 #include "fbpad.h"
   8
   9 static int fbroff, fbcoff, fbrows, fbcols;
  10 static int rows, cols;
  11 static int fnrows, fncols;
  12 static int bpp;
  13 static struct font *fonts[3];
  14
  15 int pad_init(void)
  16 {
  17         if (pad_font(FR, FI, FB))
  18                 return 1;
  19         rows = fb_rows() / fnrows;
  20         cols = fb_cols() / fncols;
  21         bpp = FBM_BPP(fb_mode());
  22         pad_conf(0, 0, fb_rows(), fb_cols());
  23         return 0;
  24 }
  25
  26 void pad_conf(int roff, int coff, int _rows, int _cols)
  27 {
  28         fbroff = roff;
  29         fbcoff = coff;
  30         fbrows = _rows;
  31         fbcols = _cols;
  32         rows = fbrows / fnrows;
  33         cols = fbcols / fncols;
  34 }
  35
  36 void pad_free(void)
  37 {
  38         int i;
  39         for (i = 0; i < 3; i++)
  40                 if (fonts[i])
  41                         font_free(fonts[i]);
  42 }
  43
  44 #define CR(a)           (((a) >> 16) & 0x0000ff)
  45 #define CG(a)           (((a) >> 8) & 0x0000ff)
  46 #define CB(a)           ((a) & 0x0000ff)
  47 #define COLORMERGE(f, b, c)             ((b) + (((f) - (b)) * (c) >> 8u))
  48
  49 static unsigned mixed_color(int fg, int bg, unsigned val)
  50 {
  51         unsigned char r = COLORMERGE(CR(fg), CR(bg), val);
  52         unsigned char g = COLORMERGE(CG(fg), CG(bg), val);
  53         unsigned char b = COLORMERGE(CB(fg), CB(bg), val);
  54         return FB_VAL(r, g, b);
  55 }
  56
  57 static unsigned color2fb(int c)
  58 {
  59         return FB_VAL(CR(c), CG(c), CB(c));
  60 }
  61
  62 /* glyph bitmap cache */
  63 #define GCLCNT          (1 << 7)        /* glyph cache list count */
  64 #define GCLLEN          (1 << 4)        /* glyph cache list length */
  65 #define GCIDX(c)        ((c) & (GCLCNT - 1))
  66
  67 static char gc_mem[GCLCNT][GCLLEN][NDOTS * 4];
  68 static int gc_next[GCLCNT];
  69 static struct glyph {
  70         int c;
  71         int fg, bg;
  72 } gc_info[GCLCNT][GCLLEN];
  73
  74 static char *gc_get(int c, int fg, int bg)
  75 {
  76         struct glyph *g = gc_info[GCIDX(c)];
  77         int i;
  78         for (i = 0; i < GCLLEN; i++)
  79                 if (g[i].c == c && g[i].fg == fg && g[i].bg == bg)
  80                         return gc_mem[GCIDX(c)][i];
  81         return NULL;
  82 }
  83
  84 static char *gc_put(int c, int fg, int bg)
  85 {
  86         int idx = GCIDX(c);
  87         int pos = gc_next[idx]++;
  88         struct glyph *g = &gc_info[idx][pos];
  89         if (gc_next[idx] >= GCLLEN)
  90                 gc_next[idx] = 0;
  91         g->c = c;
  92         g->fg = fg;
  93         g->bg = bg;
  94         return gc_mem[idx][pos];
  95 }
  96
  97 static void bmp2fb(char *d, char *s, int fg, int bg, int nr, int nc)
  98 {
  99         int i, j, k;
 100         for (i = 0; i < fnrows; i++) {
 101                 for (j = 0; j < fncols; j++) {
 102                         unsigned v = i < nr && j < nc ?
 103                                 (unsigned char) s[i * nc + j] : 0;
 104                         unsigned c = mixed_color(fg, bg, v);
 105                         for (k = 0; k < bpp; k++)
 106                                 d[i * fncols * bpp + j * bpp + k] = (c >> (k * 8)) & 0xff;
 107                 }
 108         }
 109 }
 110
 111 static char *ch2fb(int fn, int c, int fg, int bg)
 112 {
 113         char bits[NDOTS * 4];
 114         char *fbbits;
 115         if (c < 0 || (c < 128 && (!isprint(c) || isspace(c))))
 116                 return NULL;
 117         if ((fbbits = gc_get(c, fg, bg)))
 118                 return fbbits;
 119         if (font_bitmap(fonts[fn], bits, c))
 120                 return NULL;
 121         fbbits = gc_put(c, fg, bg);
 122         bmp2fb(fbbits, bits, fg & FN_C, bg & FN_C,
 123                 font_rows(fonts[fn]), font_cols(fonts[fn]));
 124         return fbbits;
 125 }
 126
 127 static void fb_set(int r, int c, void *mem, int len)
 128 {
 129         memcpy(fb_mem(fbroff + r) + (fbcoff + c) * bpp, mem, len * bpp);
 130 }
 131
 132 static char *rowbuf(unsigned c, int len)
 133 {
 134         static char row[32 * NCOLS];
 135         int i, k;
 136         for (i = 0; i < len; i++)
 137                 for (k = 0; k < bpp; k++)
 138                         row[i * bpp + k] = (c >> (k * 8)) & 0xff;
 139         return row;
 140 }
 141
 142 static void fb_box(int sr, int er, int sc, int ec, unsigned val)
 143 {
 144         char *row = rowbuf(val, ec - sc);
 145         int i;
 146         for (i = sr; i < er; i++)
 147                 fb_set(i, sc, row, ec - sc);
 148 }
 149
 150 void pad_border(unsigned c)
 151 {
 152         char *row = rowbuf(c, fbcols);
 153         int i;
 154         if (fbroff == 0 || fbcoff == 0)
 155                 return;
 156         fb_set(-1, -1, row, fbcols + 2);
 157         fb_set(fbrows, -1, row, fbcols + 2);
 158         for (i = 0; i < fbrows; i++)
 159                 fb_set(i, -1, row, 1);
 160         for (i = 0; i < fbrows; i++)
 161                 fb_set(i, fbcols, row, 1);
 162 }
 163
 164 static int fnsel(int fg, int bg)
 165 {
 166         if ((fg | bg) & FN_B)
 167                 return fonts[2] ? 2 : 0;
 168         if ((fg | bg) & FN_I)
 169                 return fonts[1] ? 1 : 0;
 170         return 0;
 171 }
 172
 173 void pad_put(int ch, int r, int c, int fg, int bg)
 174 {
 175         int sr = fnrows * r;
 176         int sc = fncols * c;
 177         char *bits;
 178         int i;
 179         bits = ch2fb(fnsel(fg, bg), ch, fg, bg);
 180         if (!bits)
 181                 bits = ch2fb(0, ch, fg, bg);
 182         if (!bits)
 183                 fb_box(sr, sr + fnrows, sc, sc + fncols, color2fb(bg & FN_C));
 184         else
 185                 for (i = 0; i < fnrows; i++)
 186                         fb_set(sr + i, sc, bits + (i * fncols * bpp), fncols);
 187 }
 188
 189 void pad_fill(int sr, int er, int sc, int ec, int c)
 190 {
 191         int fber = er >= 0 ? er * fnrows : fbrows;
 192         int fbec = ec >= 0 ? ec * fncols : fbcols;
 193         fb_box(sr * fnrows, fber, sc * fncols, fbec, color2fb(c & FN_C));
 194 }
 195
 196 int pad_rows(void)
 197 {
 198         return rows;
 199 }
 200
 201 int pad_cols(void)
 202 {
 203         return cols;
 204 }
 205
 206 int pad_font(char *fr, char *fi, char *fb)
 207 {
 208         struct font *r = fr ? font_open(fr) : NULL;
 209         if (!r)
 210                 return 1;
 211         fonts[0] = r;
 212         fonts[1] = fi ? font_open(fi) : NULL;
 213         fonts[2] = fb ? font_open(fb) : NULL;
 214         memset(gc_info, 0, sizeof(gc_info));
 215         fnrows = font_rows(fonts[0]);
 216         fncols = font_cols(fonts[0]);
 217         return 0;
 218 }
 219
 220 char *pad_fbdev(void)
 221 {
 222         static char fbdev[1024];
 223         snprintf(fbdev, sizeof(fbdev), "FBDEV=%s:%dx%d%+d%+d",
 224                 fb_dev(), fbcols, fbrows, fbcoff, fbroff);
 225         return fbdev;
 226 }