fb_include.cc Source File

Back to the index.

fb_include.cc
Go to the documentation of this file.
1 /*
2  * Included from dev_fb.c.
3  *
4  * FB_SCALEDOWN should be defined if d->vfb_scaledown > 1.
5  * FB_BO for d->fb_window->fb_ximage->byte_order non-zero
6  * FB_24 for 24-bit X11 color.
7  * FB_16 for 16-bit X11 color.
8  * FB_15 for 15-bit X11 color.
9  * (Default is to fallback to grayscale.)
10  */
11 
12 
13 #ifdef macro_put_pixel1
14 #undef macro_put_pixel1
15 #endif
16 
17 /* Combine the color into an X11 long and display it: */ \
18 /* TODO: construct color in a more portable way: */ \
19 
20 #ifdef FB_24
21 #ifdef FB_BO
22 #define macro_put_pixel1 color = (b << 16) + (g << 8) + r
23 #else
24 #define macro_put_pixel1 color = (r << 16) + (g << 8) + b
25 #endif
26 
27 #else /* !24 */
28 #ifdef FB_16
29 #ifdef FB_BO
30 #define macro_put_pixel1 color = ((b >> 3) << 11) + ((g >> 2) << 5) + (r >> 3)
31 #else
32 #define macro_put_pixel1 color = ((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3)
33 #endif
34 
35 #else /* !16 */
36 #ifdef FB_15
37 #ifdef FB_BO
38 #define macro_put_pixel1 color = ((b >> 3) << 10) + ((g >> 3) << 5) + (r >> 3)
39 #else
40 #define macro_put_pixel1 color = ((r >> 3) << 10) + ((g >> 3) << 5) + (b >> 3)
41 #endif
42 
43 #else /* !15 */
44 #define macro_put_pixel1 color = d->fb_window->x11_graycolor[15 * \
45  (r + g + b) / (255 * 3)].pixel
46 
47 #endif /* !15 */
48 
49 #endif /* !16 */
50 
51 #endif /* !24 */
52 
53 
54 #ifdef macro_put_pixel
55 #undef macro_put_pixel
56 #endif
57 
58 #define macro_put_pixel macro_put_pixel1; \
59  if (x>=0 && x<d->x11_xsize && y>=0 && y<d->x11_ysize) \
60  XPutPixel(d->fb_window->fb_ximage, x, y, color); \
61 
62 
63 void REDRAW(struct vfb_data *d, int addr, int len)
64 {
65  int x, y, pixel, npixels;
66  long color_r, color_g, color_b;
67  long color;
68 
69 #ifndef FB_SCALEDOWN
70 
71  /* Which framebuffer pixel does addr correspond to? */
72  pixel = addr * 8 / d->bit_depth;
73  y = pixel / d->xsize;
74  x = pixel % d->xsize;
75 
76  /* How many framebuffer pixels? */
77  npixels = len * 8 / d->bit_depth;
78  if (npixels == 0)
79  npixels = 1;
80 
81  if (d->bit_depth < 8) {
82  for (pixel=0; pixel<npixels; pixel++) {
83  int fb_addr, c, r, g, b;
84  color_r = color_g = color_b = 0;
85 
86  fb_addr = (y * d->xsize + x) * d->bit_depth;
87  /* fb_addr is now which _bit_ in
88  the framebuffer */
89 
90  c = d->framebuffer[fb_addr >> 3];
91  fb_addr &= 7;
92 
93  /* HPC is reverse: */
94  if (d->vfb_type == VFB_HPC)
95  fb_addr = 8 - d->bit_depth - fb_addr;
96 
97  c = (c >> fb_addr) & ((1<<d->bit_depth) - 1);
98  /* c <<= (8 - d->bit_depth); */
99 
100  r = d->rgb_palette[c*3 + 0];
101  g = d->rgb_palette[c*3 + 1];
102  b = d->rgb_palette[c*3 + 2];
103 
105  x++;
106  }
107  } else if (d->bit_depth == 8) {
108  for (pixel=0; pixel<npixels; pixel++) {
109  int fb_addr, c, r, g, b;
110  color_r = color_g = color_b = 0;
111 
112  fb_addr = y * d->xsize + x;
113  /* fb_addr is now which byte in framebuffer */
114  c = d->framebuffer[fb_addr];
115  r = d->rgb_palette[c*3 + 0];
116  g = d->rgb_palette[c*3 + 1];
117  b = d->rgb_palette[c*3 + 2];
118 
120  x++;
121  }
122  } else { /* d->bit_depth > 8 */
123  for (pixel=0; pixel<npixels; pixel++) {
124  int fb_addr, r, g, b;
125  color_r = color_g = color_b = 0;
126 
127  fb_addr = (y * d->xsize + x) * d->bit_depth;
128  /* fb_addr is now which byte in framebuffer */
129 
130  /* > 8 bits color. */
131  fb_addr >>= 3;
132  switch (d->bit_depth) {
133  case 24:
134  case 32:
135  r = d->framebuffer[fb_addr];
136  g = d->framebuffer[fb_addr + 1];
137  b = d->framebuffer[fb_addr + 2];
138  break;
139  case 16:
140  if (d->vfb_type == VFB_HPC) {
141  b = d->framebuffer[fb_addr] +
142  (d->framebuffer[fb_addr+1] << 8);
143 
144  if (d->color32k) {
145  r = b >> 11;
146  g = b >> 5;
147  r = r & 31;
148  g = (g & 31) * 2;
149  b = b & 31;
150  } else if (d->psp_15bit) {
151  int tmp;
152  r = (b >> 10) & 0x1f;
153  g = (b >> 5) & 0x1f;
154  b = b & 0x1f;
155  g <<= 1;
156  tmp = r; r = b; b = tmp;
157  } else {
158  r = (b >> 11) & 0x1f;
159  g = (b >> 5) & 0x3f;
160  b = b & 0x1f;
161  }
162  } else {
163  r = d->framebuffer[fb_addr] >> 3;
164 /* HUH? TODO: */
165  g = (d->framebuffer[fb_addr] << 5) +
166  (d->framebuffer[fb_addr + 1] >>5);
167  b = d->framebuffer[fb_addr + 1]&31;
168  }
169 
170  r *= 8;
171  g *= 4;
172  b *= 8;
173  break;
174  default:
175  r = g = b = random() & 255;
176  }
177 
179  x++;
180  }
181  }
182 
183 #else /* FB_SCALEDOWN */
184 
185  /* scaledown > 1: */
186  int scaledown = d->vfb_scaledown;
187  int scaledownXscaledown = scaledown * scaledown;
188 
189  /* Which framebuffer pixel does addr correspond to? */
190  pixel = addr * 8 / d->bit_depth;
191  y = pixel / d->xsize;
192  x = pixel % d->xsize;
193 
194  /* How many framebuffer pixels? */
195  npixels = len * 8 / d->bit_depth;
196 
197  /* Which x11 pixel? */
198  x /= scaledown;
199  y /= scaledown;
200 
201  /* How many x11 pixels: */
202  npixels /= scaledown;
203  if (npixels == 0)
204  npixels = 1;
205 
206  if (d->bit_depth < 8) {
207  for (pixel=0; pixel<npixels; pixel++) {
208  int subx, suby, r, g, b;
209  color_r = color_g = color_b = 0;
210  for (suby=0; suby<scaledown; suby++)
211  for (subx=0; subx<scaledown; subx++) {
212  int fb_x, fb_y, fb_addr, c;
213 
214  fb_x = x * scaledown + subx;
215  fb_y = y * scaledown + suby;
216  fb_addr = fb_y * d->xsize + fb_x;
217  fb_addr = fb_addr * d->bit_depth;
218  /* fb_addr is now which _bit_ in
219  the framebuffer */
220 
221  c = d->framebuffer[fb_addr >> 3];
222  fb_addr &= 7;
223 
224  /* HPC is reverse: */
225  if (d->vfb_type == VFB_HPC)
226  fb_addr = 8 - d->bit_depth - fb_addr;
227 
228  c = (c >> fb_addr) & ((1<<d->bit_depth) - 1);
229  /* c <<= (8 - d->bit_depth); */
230 
231  r = d->rgb_palette[c*3 + 0];
232  g = d->rgb_palette[c*3 + 1];
233  b = d->rgb_palette[c*3 + 2];
234 
235  color_r += r;
236  color_g += g;
237  color_b += b;
238  }
239 
240  r = color_r / scaledownXscaledown;
241  g = color_g / scaledownXscaledown;
242  b = color_b / scaledownXscaledown;
244  x++;
245  }
246  } else if (d->bit_depth == 8) {
247  for (pixel=0; pixel<npixels; pixel++) {
248  int subx, suby, r, g, b;
249  color_r = color_g = color_b = 0;
250  for (suby=0; suby<scaledown; suby++)
251  for (subx=0; subx<scaledown; subx++) {
252  int fb_x, fb_y, fb_addr, c;
253 
254  fb_x = x * scaledown + subx;
255  fb_y = y * scaledown + suby;
256  fb_addr = fb_y * d->xsize + fb_x;
257  /* fb_addr is which _byte_ in framebuffer */
258  c = d->framebuffer[fb_addr] * 3;
259  r = d->rgb_palette[c + 0];
260  g = d->rgb_palette[c + 1];
261  b = d->rgb_palette[c + 2];
262  color_r += r;
263  color_g += g;
264  color_b += b;
265  }
266 
267  r = color_r / scaledownXscaledown;
268  g = color_g / scaledownXscaledown;
269  b = color_b / scaledownXscaledown;
271  x++;
272  }
273  } else {
274  /* Generic > 8 bit bit-depth: */
275  for (pixel=0; pixel<npixels; pixel++) {
276  int subx, suby, r, g, b;
277  color_r = color_g = color_b = 0;
278  for (suby=0; suby<scaledown; suby++)
279  for (subx=0; subx<scaledown; subx++) {
280  int fb_x, fb_y, fb_addr;
281 
282  fb_x = x * scaledown + subx;
283  fb_y = y * scaledown + suby;
284  fb_addr = fb_y * d->xsize + fb_x;
285  fb_addr = (fb_addr * d->bit_depth) >> 3;
286  /* fb_addr is which _byte_ in framebuffer */
287 
288  /* > 8 bits color. */
289  switch (d->bit_depth) {
290  case 24:
291  case 32:
292  r = d->framebuffer[fb_addr];
293  g = d->framebuffer[fb_addr + 1];
294  b = d->framebuffer[fb_addr + 2];
295  break;
296  case 16:
297  if (d->vfb_type == VFB_HPC) {
298  b = d->framebuffer[fb_addr] +
299  (d->framebuffer[fb_addr+1] << 8);
300 
301  if (d->color32k) {
302  r = b >> 11;
303  g = b >> 5;
304  r = r & 31;
305  g = (g & 31) * 2;
306  b = b & 31;
307  } else if (d->psp_15bit) {
308  int tmp;
309  r = (b >> 10) & 0x1f;
310  g = (b >> 5) & 0x1f;
311  b = b & 0x1f;
312  g <<= 1;
313  tmp = r; r = b; b = tmp;
314  } else {
315  r = (b >> 11) & 0x1f;
316  g = (b >> 5) & 0x3f;
317  b = b & 0x1f;
318  }
319  } else {
320  r = d->framebuffer[fb_addr] >> 3;
321 /* HUH? TODO: */
322  g = (d->framebuffer[fb_addr] << 5) +
323  (d->framebuffer[fb_addr + 1] >>5);
324  b = d->framebuffer[fb_addr + 1]&31;
325  }
326 
327  r *= 8;
328  g *= 4;
329  b *= 8;
330  break;
331  default:
332  r = g = b = random() & 255;
333  }
334  color_r += r;
335  color_g += g;
336  color_b += b;
337  }
338  r = color_r / scaledownXscaledown;
339  g = color_g / scaledownXscaledown;
340  b = color_b / scaledownXscaledown;
342  x++;
343  }
344  }
345 #endif /* FB_SCALEDOWN */
346 }
347 
void REDRAW(struct vfb_data *d, int addr, int len)
Definition: fb_include.cc:63
int bit_depth
Definition: devices.h:206
int xsize
Definition: devices.h:204
int vfb_scaledown
Definition: devices.h:202
int vfb_type
Definition: devices.h:200
uint32_t addr
int color32k
Definition: devices.h:207
int psp_15bit
Definition: devices.h:208
unsigned char * framebuffer
Definition: devices.h:231
addr & if(addr >=0x24 &&page !=NULL)
#define macro_put_pixel
Definition: fb_include.cc:58
unsigned char rgb_palette[256 *3]
Definition: devices.h:223
#define VFB_HPC
Definition: devices.h:191

Generated on Sun Sep 30 2018 16:05:18 for GXemul by doxygen 1.8.13