![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to drawing.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to drawing.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Screen drawing functions
5: *
6: * Copyright 1995-1998 Bernd Schmidt
7: * Copyright 1995 Alessandro Bissacco
8: */
9:
10: #include "sysconfig.h"
11: #include "sysdeps.h"
12:
13: #include <ctype.h>
14: #include <assert.h>
15:
16: #include "config.h"
17: #include "options.h"
18: #include "threaddep/penguin.h"
19: #include "uae.h"
20: #include "memory.h"
21: #include "custom.h"
22: #include "readcpu.h"
23: #include "newcpu.h"
24: #include "xwin.h"
25: #include "autoconf.h"
26: #include "gui.h"
27: #include "picasso96.h"
28: #include "drawing.h"
29: #include "p2c.h"
30:
31: #if defined X86_ASSEMBLY
32: #define LORES_HACK
33: #endif
34:
35: int lores_factor, lores_shift, sprite_width;
36:
37: static int interlace_seen = 0;
38:
39: static int dblpf_ind1[256], dblpf_ind2[256], dblpf_2nd1[256], dblpf_2nd2[256];
40: static int dblpf_aga1[256], dblpf_aga2[256], linear_map_256[256], lots_of_twos[256];
41:
42: static int dblpfofs[] = { 0, 2, 4, 8, 16, 32, 64, 128 };
43:
44: /* Big lookup tables for planar to chunky conversion. */
45:
46: uae_u32 hirestab_h[256][2];
47: uae_u32 lorestab_h[256][4];
48:
49: uae_u32 hirestab_l[256][1];
50: uae_u32 lorestab_l[256][2];
51:
52: static uae_u32 clxtab[256];
53:
54: /* Video buffer description structure. Filled in by the graphics system
55: * dependent code. */
56:
57: struct vidbuf_description gfxvidinfo;
58:
59: /* The color lookup table. */
60:
61: xcolnr xcolors[4096];
62:
63: struct color_entry colors_for_drawing;
64:
65: /* 880 isn't a magic number, it's a safe number with some padding at the end.
66: * This used to be 1000, but that's excessive. (840 is too low). I'm too lazy
67: * to figure out the exact space needed. */
68: union {
69: /* Let's try to align this thing. */
70: double uupzuq;
71: long int cruxmedo;
72: unsigned char apixels[880];
73: } pixdata;
74:
75: uae_u32 ham_linebuf[880];
76: uae_u32 aga_linebuf[880], *aga_lbufptr;
77:
78: char *xlinebuffer;
79:
80: static int *amiga2aspect_line_map, *native2amiga_line_map;
81: static char *row_map[2049];
82: static int max_drawn_amiga_line;
83:
84: /* line_draw_funcs: pfield_do_linetoscr, pfield_do_fill_line, decode_ham6 */
85: typedef void (*line_draw_func)(int, int);
86:
87: #define LINE_UNDECIDED 1
88: #define LINE_DECIDED 2
89: #define LINE_DECIDED_DOUBLE 3
90: #define LINE_AS_PREVIOUS 4
91: #define LINE_BORDER_NEXT 5
92: #define LINE_BORDER_PREV 6
93: #define LINE_DONE 7
94: #define LINE_DONE_AS_PREVIOUS 8
95: #define LINE_REMEMBERED_AS_PREVIOUS 9
96:
97: static char *line_drawn;
98: static char linestate[(maxvpos + 1)*2 + 1];
99:
100: uae_u8 line_data[(maxvpos+1) * 2][MAX_PLANES * MAX_WORDS_PER_LINE * 2];
101:
102: static int min_diwstart, max_diwstop, prev_x_adjust, linetoscr_x_adjust, linetoscr_right_x;
103: static int linetoscr_x_adjust_bytes;
104: static int thisframe_y_adjust, prev_y_adjust;
105: static int thisframe_y_adjust_real, max_ypos_thisframe, min_ypos_for_screen;
106: static int extra_y_adjust;
107: int thisframe_first_drawn_line, thisframe_last_drawn_line;
108:
109: static int last_redraw_point;
110:
111: static int first_drawn_line, last_drawn_line;
112: static int first_block_line, last_block_line;
113:
114: /* These are generated by the drawing code from the line_decisions array for
115: * each line that needs to be drawn. */
116: static int bplehb, bplham, bpldualpf, bpldualpfpri, bplplanecnt, bplhires;
117: static int bpldelay1, bpldelay2;
118: static int plfpri[3];
119:
120: int picasso_requested_on;
121: int picasso_on;
122:
123: uae_sem_t gui_sem;
124: int inhibit_frame;
125:
126: int framecnt = 0;
127: static int frame_redraw_necessary;
128: static int picasso_redraw_necessary;
129:
130: static __inline__ void count_frame (void)
131: {
132: framecnt++;
133: if (framecnt >= currprefs.framerate)
134: framecnt = 0;
135: }
136:
137: int coord_native_to_amiga_x (int x)
138: {
139: x += linetoscr_x_adjust;
140: x <<= (1 - lores_shift);
141: return x + 2*DISPLAY_LEFT_SHIFT;
142: }
143:
144: int coord_native_to_amiga_y (int y)
145: {
146: return native2amiga_line_map[y] + thisframe_y_adjust - minfirstline;
147: }
148:
149: void notice_screen_contents_lost (void)
150: {
151: picasso_redraw_necessary = 1;
152: frame_redraw_necessary = 2;
153: }
154:
155: static struct decision *dp_for_drawing;
156: static struct draw_info *dip_for_drawing;
157:
158: void record_diw_line (int first, int last)
159: {
160: if (last > max_diwstop)
161: max_diwstop = last;
162: if (first < min_diwstart)
163: min_diwstart = first;
164: }
165:
166: /*
167: * Screen update macros/functions
168: */
169:
170: static unsigned int ham_lastcolor;
171:
172: static void init_ham_decoding(int first)
173: {
174: int pix = dp_for_drawing->diwfirstword;
175: ham_lastcolor = colors_for_drawing.color_regs[0];
176: while (pix < first) {
177: int pv = pixdata.apixels[pix];
178: switch(pv & 0x30) {
179: case 0x00: ham_lastcolor = colors_for_drawing.color_regs[pv]; break;
180: case 0x10: ham_lastcolor &= 0xFF0; ham_lastcolor |= (pv & 0xF); break;
181: case 0x20: ham_lastcolor &= 0x0FF; ham_lastcolor |= (pv & 0xF) << 8; break;
182: case 0x30: ham_lastcolor &= 0xF0F; ham_lastcolor |= (pv & 0xF) << 4; break;
183: }
184: pix++;
185: }
186: }
187:
188: static void decode_ham6 (int pix, int stoppos)
189: {
190: uae_u32 *buf = ham_linebuf;
191:
192: if (!bplham || bplplanecnt != 6)
193: return;
194:
195: if (stoppos > dp_for_drawing->diwlastword)
196: stoppos = dp_for_drawing->diwlastword;
197: if (pix < dp_for_drawing->diwfirstword) {
198: ham_lastcolor = colors_for_drawing.color_regs[0];
199: pix = dp_for_drawing->diwfirstword;
200: }
201: #ifdef LORES_HACK
202: if (currprefs.gfx_lores == 2)
203: pix <<= 1, stoppos <<= 1;
204: #endif
205: while (pix < stoppos) {
206: int pv = pixdata.apixels[pix];
207: switch(pv & 0x30) {
208: case 0x00: ham_lastcolor = colors_for_drawing.color_regs[pv]; break;
209: case 0x10: ham_lastcolor &= 0xFF0; ham_lastcolor |= (pv & 0xF); break;
210: case 0x20: ham_lastcolor &= 0x0FF; ham_lastcolor |= (pv & 0xF) << 8; break;
211: case 0x30: ham_lastcolor &= 0xF0F; ham_lastcolor |= (pv & 0xF) << 4; break;
212: }
213:
214: buf[pix++] = ham_lastcolor;
215: }
216: }
217: #if 0
218: static void decode_ham_aga (int pix, int stoppos)
219: {
220: static uae_u32 lastcolor;
221: uae_u32 *buf = ham_linebuf;
222:
223: if (!bplham || (bplplanecnt != 6 && bplplanecnt != 8))
224: return;
225:
226: if (pix <= dp_for_drawing->diwfirstword) {
227: pix = dp_for_drawing->diwfirstword;
228: lastcolor = colors_for_drawing.color_regs[0];
229: }
230:
231: if (dp_for_drawing->bplplanecnt == 6) {
232: /* HAM 6 */
233: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
234: int pv = pixdata.apixels[pix];
235: switch(pv & 0x30) {
236: case 0x00: lastcolor = colors_for_drawing.color_regs[pv]; break;
237: case 0x10: lastcolor &= 0xFFFF00; lastcolor |= (pv & 0xF)*0x11; break;
238: case 0x20: lastcolor &= 0x00FFFF; lastcolor |= (pv & 0xF)*0x11 << 16; break;
239: case 0x30: lastcolor &= 0xFF00FF; lastcolor |= (pv & 0xF)*0x11 << 8; break;
240: }
241: buf[pix++] = lastcolor;
242: }
243: } else if (dp_for_drawing->bplplanecnt == 8) {
244: /* HAM 8 */
245: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
246: int pv = pixdata.apixels[pix];
247: switch(pv & 0x3) {
248: case 0x0: lastcolor = colors_for_drawing.color_regs[pv >> 2]; break;
249: case 0x1: lastcolor &= 0xFFFF03; lastcolor |= (pv & 0xFC); break;
250: case 0x2: lastcolor &= 0x03FFFF; lastcolor |= (pv & 0xFC) << 16; break;
251: case 0x3: lastcolor &= 0xFF03FF; lastcolor |= (pv & 0xFC) << 8; break;
252: }
253: buf[pix++] = lastcolor;
254: }
255: }
256: }
257: #endif
258:
259: #if AGA_CHIPSET != 0
260: /* WARNING: Not too much of this will work correctly yet. */
261:
262: static void pfield_linetoscr_aga(int pix, int stoppos)
263: {
264: uae_u32 *buf = aga_lbufptr;
265: int i;
266: int xor = (uae_u8)(bplcon4 >> 8);
267: int oldpix = pix; \
268:
269: buf -= pix; \
270:
271: for (i = 0; i < stoppos; i++)
272: pixdata.apixels[i] ^= xor;
273:
274: while (pix < dp_for_drawing->diwfirstword && pix < stoppos) {
275: buf[pix++] = colors_for_drawing.color_regs[0];
276: }
277: if (bplham) {
278: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
279: uae_u32 d = ham_linebuf[pix];
280: buf[pix] = d;
281: pix++;
282: }
283: } else if (bpldualpf) {
284: /* Dual playfield */
285: int *lookup = bpldualpfpri ? dblpf_aga2 : dblpf_aga1;
286: int *lookup_no = bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1;
287: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
288: int pixcol = pixdata.apixels[pix];
289: int pfno = lookup_no[pixcol];
290:
291: if (spixstate[pix]) {
292: buf[pix] = colors_for_drawing.color_regs[pixcol];
293: } else {
294: int val = lookup[pixdata.apixels[pix]];
295: if (pfno == 2)
296: val += dblpfofs[(bplcon2 >> 10) & 7];
297: buf[pix] = colors_for_drawing.color_regs[val];
298: }
299: pix++;
300: }
301: } else if (bplehb) {
302: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
303: int pixcol = pixdata.apixels[pix];
304: uae_u32 d = colors_for_drawing.color_regs[pixcol];
305: /* What about sprites? */
306: if (pixcol & 0x20)
307: d = (d & 0x777777) >> 1;
308: buf[pix] = d;
309: pix++;
310: }
311: } else {
312: while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
313: int pixcol = pixdata.apixels[pix];
314: buf[pix] = colors_for_drawing.color_regs[pixcol];
315: pix++;
316: }
317: }
318: while (pix < stoppos) {
319: buf[pix++] = colors_for_drawing.color_regs[0];
320: }
321: aga_lbufptr += pix - oldpix;
322: }
323:
324: static void aga_translate32(int start, int stop)
325: {
326: memcpy (((uae_u32 *)xlinebuffer) + start, aga_linebuf + start, 4*(stop-start));
327: }
328:
329: static void aga_translate16(int start, int stop)
330: {
331: int i;
332: for (i = start; i < stop; i++) {
333: uae_u32 d = aga_linebuf[i];
334: uae_u16 v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
335: ((uae_u16 *)xlinebuffer)[i] = xcolors[v];
336: }
337: }
338:
339: static void aga_translate8(int start, int stop)
340: {
341: int i;
342: for (i = start; i < stop; i++) {
343: uae_u32 d = aga_linebuf[i];
344: uae_u16 v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
345: ((uae_u8 *)xlinebuffer)[i] = xcolors[v];
346: }
347: }
348: #endif
349:
350: static int linetoscr_double_offset;
351:
352: #define LINE_TO_SCR(NAME, TYPE, DO_DOUBLE, CONVERT) \
353: static void NAME(int pix, int lframe_end, int diw_end, int stoppos) \
354: { \
355: TYPE *buf = ((TYPE *)xlinebuffer); \
356: /* int oldpix = pix;*/ \
357: /* These are different for register-allocation purposes. */ \
358: TYPE d1, d2; \
359: int offset; \
360: \
361: if (DO_DOUBLE) offset = linetoscr_double_offset / sizeof(TYPE); \
362: \
363: d1 = CONVERT(colors_for_drawing.acolors[0]); \
364: while (pix < lframe_end) { \
365: buf[pix] = d1; if (DO_DOUBLE) buf[pix+offset] = d1; \
366: pix++; \
367: } \
368: if (bplham && bplplanecnt == 6) { \
369: /* HAM 6 */ \
370: while (pix < diw_end) { \
371: TYPE d = CONVERT(xcolors[ham_linebuf[pix]]); \
372: buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
373: pix++; \
374: } \
375: } else if (bpldualpf) { \
376: /* Dual playfield */ \
377: int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1; \
378: while (pix < diw_end) { \
379: int pixcol = pixdata.apixels[pix]; \
380: TYPE d; \
381: d = CONVERT(colors_for_drawing.acolors[lookup[pixcol]]); \
382: buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
383: pix++; \
384: } \
385: } else if (bplehb) { \
386: while (pix < diw_end) { \
387: int p = pixdata.apixels[pix]; \
388: TYPE d = CONVERT (colors_for_drawing.acolors[p]); \
389: if (p >= 32) d = CONVERT(xcolors[(colors_for_drawing.color_regs[p-32] >> 1) & 0x777]); \
390: buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
391: pix++; \
392: } \
393: } else { \
394: while (pix < diw_end) { \
395: TYPE d = CONVERT (colors_for_drawing.acolors[pixdata.apixels[pix]]); \
396: buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
397: pix++; \
398: } \
399: } \
400: d2 = CONVERT (colors_for_drawing.acolors[0]); \
401: while (pix < stoppos) { \
402: buf[pix] = d2; if (DO_DOUBLE) buf[pix+offset] = d2; \
403: pix++; \
404: } \
405: }
406:
407: #define FILL_LINE(NAME, TYPE, CONVERT) \
408: static void NAME(char *buf, int start, int stop) \
409: { \
410: TYPE *b = (TYPE *)buf; \
411: int i;\
412: xcolnr col = colors_for_drawing.acolors[0]; \
413: for (i = start; i < stop; i++) \
414: b[i] = CONVERT (col); \
415: }
416:
417: LINE_TO_SCR(pfield_linetoscr_8, uae_u8, 0,)
418: LINE_TO_SCR(pfield_linetoscr_16, uae_u16, 0,)
419: LINE_TO_SCR(pfield_linetoscr_32, uae_u32, 0,)
420: LINE_TO_SCR(pfield_linetoscr_8_double_slow, uae_u8, 1,)
421: LINE_TO_SCR(pfield_linetoscr_16_double_slow, uae_u16, 1,)
422: LINE_TO_SCR(pfield_linetoscr_32_double_slow, uae_u32, 1,)
423:
424: FILL_LINE(fill_line_8, uae_u8,)
425: FILL_LINE(fill_line_16, uae_u16,)
426: FILL_LINE(fill_line_32, uae_u32,)
427:
428: #ifdef HAVE_UAE_U24
429: LINE_TO_SCR(pfield_linetoscr_24, uae_u24, 0, uae24_convert)
430: LINE_TO_SCR(pfield_linetoscr_24_double_slow, uae_u24, 1, uae24_convert)
431: FILL_LINE(fill_line_24, uae_u24, uae24_convert)
432: #else
433: /* Dummy versions */
434: static void pfield_linetoscr_24 (int pix, int lframe_end, int diw_end, int stoppos)
435: {
436: }
437: static void pfield_linetoscr_24_double_slow (int pix, int lframe_end, int diw_end, int stoppos)
438: {
439: }
440: static void fill_line_24 (char *buf, int start, int stop)
441: {
442: }
443: #endif
444:
445: static __inline__ void fill_line_full (void)
446: {
447: switch (gfxvidinfo.pixbytes) {
448: case 1: fill_line_8(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.width); break;
449: case 2: fill_line_16(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.width); break;
450: case 3: fill_line_24(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.width); break;
451: case 4: fill_line_32(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.width); break;
452: }
453: }
454:
455: #define fill_line fill_line_full
456:
457: #define pfield_linetoscr_full8 pfield_linetoscr_8
458: #define pfield_linetoscr_full16 pfield_linetoscr_16
459: #define pfield_linetoscr_full24 pfield_linetoscr_24
460: #define pfield_linetoscr_full32 pfield_linetoscr_32
461:
462: #define pfield_linetoscr_full8_double pfield_linetoscr_8_double_slow
463: #define pfield_linetoscr_full16_double pfield_linetoscr_16_double_slow
464: #define pfield_linetoscr_full24_double pfield_linetoscr_24_double_slow
465: #define pfield_linetoscr_full32_double pfield_linetoscr_32_double_slow
466:
467: #if 1
468: #undef fill_line
469: static __inline__ void fill_line (void)
470: {
471: int shift;
472: int nints, nrem;
473: int *start;
474: xcolnr val;
475:
476: #ifdef HAVE_UAE_U24
477: if (gfxvidinfo.pixbytes == 3) {
478: fill_line_24 (xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.width);
479: return;
480: }
481: #endif
482:
483: shift = 0;
484: if (gfxvidinfo.pixbytes == 2)
485: shift = 1;
486: if (gfxvidinfo.pixbytes == 4)
487: shift = 2;
488:
489: nints = gfxvidinfo.width >> (2-shift);
490: nrem = nints & 7;
491: nints &= ~7;
492: start = (int *)(((char *)xlinebuffer) + (linetoscr_x_adjust << shift));
493: val = colors_for_drawing.acolors[0];
494: for (; nints > 0; nints -= 8, start += 8) {
495: *start = val;
496: *(start+1) = val;
497: *(start+2) = val;
498: *(start+3) = val;
499: *(start+4) = val;
500: *(start+5) = val;
501: *(start+6) = val;
502: *(start+7) = val;
503: }
504:
505: switch (nrem) {
506: case 7:
507: *start++ = val;
508: case 6:
509: *start++ = val;
510: case 5:
511: *start++ = val;
512: case 4:
513: *start++ = val;
514: case 3:
515: *start++ = val;
516: case 2:
517: *start++ = val;
518: case 1:
519: *start = val;
520: }
521: }
522:
523: #ifdef X86_ASSEMBLY
524:
525: #undef pfield_linetoscr_full8
526: /* The types are lies, of course. */
527: extern void pfield_linetoscr_normal_asm8(void) __asm__("pfield_linetoscr_normal_asm8");
528: extern void pfield_linetoscr_ehb_asm8(void) __asm__("pfield_linetoscr_ehb_asm8");
529: extern void pfield_linetoscr_ham6_asm8(void) __asm__("pfield_linetoscr_ham6_asm8");
530: extern void pfield_linetoscr_dualpf_asm8(void) __asm__("pfield_linetoscr_dualpf_asm8");
531: extern void pfield_linetoscr_hdouble_asm8(void) __asm__("pfield_linetoscr_hdouble_asm8");
532: extern void pfield_linetoscr_hdouble_dpf_asm8(void) __asm__("pfield_linetoscr_hdouble_dpf_asm8");
533: extern void pfield_linetoscr_hdouble_ehb_asm8(void) __asm__("pfield_linetoscr_hdouble_ehb_asm8");
534: extern void pfield_linetoscr_asm8(void (*)(void), int, int, int, int, ...) __asm__("pfield_linetoscr_asm8");
535:
536: static void pfield_linetoscr_full8(int pix, int lframe_end, int diw_end, int stoppos)
537: {
538: int lframe_end_1, diw_end_1;
539:
540: lframe_end_1 = pix + ((lframe_end - pix) & ~3);
541: diw_end_1 = stoppos - ((stoppos - diw_end) & ~3);
542:
543: if (bplham && bplplanecnt == 6) {
544: pfield_linetoscr_asm8(pfield_linetoscr_ham6_asm8, pix, lframe_end_1, diw_end_1, stoppos);
545: } else if (bpldualpf) {
546: #ifdef LORES_HACK
547: if (currprefs.gfx_lores == 2)
548: pfield_linetoscr_asm8(pfield_linetoscr_hdouble_dpf_asm8, pix, lframe_end_1, diw_end_1, stoppos,
549: bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
550: else
551: #endif
552: pfield_linetoscr_asm8(pfield_linetoscr_dualpf_asm8, pix, lframe_end_1, diw_end_1, stoppos,
553: bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
554: } else if (bplehb) {
555: #ifdef LORES_HACK
556: if (currprefs.gfx_lores == 2)
557: pfield_linetoscr_asm8(pfield_linetoscr_hdouble_ehb_asm8, pix, lframe_end_1, diw_end_1, stoppos);
558: else
559: #endif
560: pfield_linetoscr_asm8(pfield_linetoscr_ehb_asm8, pix, lframe_end_1, diw_end_1, stoppos);
561: } else {
562: #ifdef LORES_HACK
563: if (currprefs.gfx_lores == 2)
564: pfield_linetoscr_asm8(pfield_linetoscr_hdouble_asm8, pix, lframe_end_1, diw_end_1, stoppos);
565: else
566: #endif
567: pfield_linetoscr_asm8(pfield_linetoscr_normal_asm8, pix, lframe_end_1, diw_end_1, stoppos);
568: }
569:
570: /* The assembly functions work on aligned data, so we may have to do some
571: * additional work at the edges. */
572: if (lframe_end != lframe_end_1) {
573: int i, c = colors_for_drawing.acolors[0];
574: for (i = lframe_end_1; i < lframe_end; i++)
575: xlinebuffer[i] = c;
576: }
577: if (diw_end != diw_end_1) {
578: int i, c = colors_for_drawing.acolors[0];
579: for (i = diw_end; i < diw_end_1; i++)
580: xlinebuffer[i] = c;
581: }
582: }
583:
584: #undef pfield_linetoscr_full16
585: extern void pfield_linetoscr_normal_asm16(void) __asm__("pfield_linetoscr_normal_asm16");
586: extern void pfield_linetoscr_ehb_asm16(void) __asm__("pfield_linetoscr_ehb_asm16");
587: extern void pfield_linetoscr_ham6_asm16(void) __asm__("pfield_linetoscr_ham6_asm16");
588: extern void pfield_linetoscr_dualpf_asm16(void) __asm__("pfield_linetoscr_dualpf_asm16");
589: extern void pfield_linetoscr_hdouble_asm16(void) __asm__("pfield_linetoscr_hdouble_asm16");
590: extern void pfield_linetoscr_hdouble_dpf_asm16(void) __asm__("pfield_linetoscr_hdouble_dpf_asm16");
591: extern void pfield_linetoscr_hdouble_ehb_asm16(void) __asm__("pfield_linetoscr_hdouble_ehb_asm16");
592: extern void pfield_linetoscr_asm16(void (*)(void), int, int, int, int, ...) __asm__("pfield_linetoscr_asm16");
593:
594: static void pfield_linetoscr_full16(int pix, int lframe_end, int diw_end, int stoppos)
595: {
596: int lframe_end_1, diw_end_1;
597:
598: lframe_end_1 = pix + ((lframe_end - pix) & ~3);
599: diw_end_1 = stoppos - ((stoppos - diw_end) & ~3);
600:
601: if (bplham && bplplanecnt == 6) {
602: pfield_linetoscr_asm16(pfield_linetoscr_ham6_asm16, pix, lframe_end_1, diw_end_1, stoppos);
603: } else if (bpldualpf) {
604: #ifdef LORES_HACK
605: if (currprefs.gfx_lores == 2)
606: pfield_linetoscr_asm16(pfield_linetoscr_hdouble_dpf_asm16, pix, lframe_end_1, diw_end_1, stoppos,
607: bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
608: else
609: #endif
610: pfield_linetoscr_asm16(pfield_linetoscr_dualpf_asm16, pix, lframe_end_1, diw_end_1, stoppos,
611: bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
612: } else if (bplehb) {
613: #ifdef LORES_HACK
614: if (currprefs.gfx_lores == 2)
615: pfield_linetoscr_asm16(pfield_linetoscr_hdouble_ehb_asm16, pix, lframe_end_1, diw_end_1, stoppos);
616: else
617: #endif
618: pfield_linetoscr_asm16(pfield_linetoscr_ehb_asm16, pix, lframe_end_1, diw_end_1, stoppos);
619: } else {
620: #ifdef LORES_HACK
621: if (currprefs.gfx_lores == 2)
622: pfield_linetoscr_asm16(pfield_linetoscr_hdouble_asm16, pix, lframe_end_1, diw_end_1, stoppos);
623: else
624: #endif
625: pfield_linetoscr_asm16(pfield_linetoscr_normal_asm16, pix, lframe_end_1, diw_end_1, stoppos);
626: }
627:
628: /* The assembly functions work on aligned data, so we may have to do some
629: * additional work at the edges. */
630: if (lframe_end != lframe_end_1) {
631: int i, c = colors_for_drawing.acolors[0];
632: for (i = lframe_end_1; i < lframe_end; i++)
633: ((uae_u16 *)xlinebuffer)[i] = c;
634: }
635: if (diw_end != diw_end_1) {
636: int i, c = colors_for_drawing.acolors[0];
637: for (i = diw_end; i < diw_end_1; i++)
638: ((uae_u16 *)xlinebuffer)[i] = c;
639: }
640: }
641: #endif
642:
643: #ifndef NO_DOUBLING_LINETOSCR
644: #define NO_DOUBLING_LINETOSCR
645: #endif
646:
647: #endif
648:
649: #ifdef NO_DOUBLING_LINETOSCR
650: #undef pfield_linetoscr_full8_double
651: #undef pfield_linetoscr_full16_double
652: static void pfield_linetoscr_full8_double(int start, int lframe_end, int diw_end, int stop)
653: {
654: char *oldxlb = (char *)xlinebuffer;
655: pfield_linetoscr_full8(start, lframe_end, diw_end, stop);
656: xlinebuffer = oldxlb + linetoscr_double_offset;
657: pfield_linetoscr_full8(start, lframe_end, diw_end, stop);
658: }
659: static void pfield_linetoscr_full16_double(int start, int lframe_end, int diw_end, int stop)
660: {
661: char *oldxlb = (char *)xlinebuffer;
662: pfield_linetoscr_full16(start, lframe_end, diw_end, stop);
663: xlinebuffer = oldxlb + linetoscr_double_offset;
664: pfield_linetoscr_full16(start, lframe_end, diw_end, stop);
665: }
666: #endif
667:
668: static int linetoscr_diw_end, linetoscr_diw_start;
669:
670: /* Initialize the variables necessary for drawing a line.
671: * This involves setting up start/stop positions and display window
672: * borders. Also, since the drawing code may not fully overwrite all
673: * releveant areas in the pixdata.apixels array for speed reasons, parts of
674: * it must possibly be cleared here. */
675: static void pfield_init_linetoscr (void)
676: {
677: int ddf_left, ddf_right;
678: int mindelay = bpldelay1, maxdelay = bpldelay2;
679: if (bpldelay1 > bpldelay2)
680: maxdelay = bpldelay1, mindelay = bpldelay2;
681:
682: linetoscr_diw_start = dp_for_drawing->diwfirstword;
683: linetoscr_diw_end = dp_for_drawing->diwlastword;
684:
685: /* We should really look at DDF also when calculating max_diwstop/min_diwstrt,
686: * so that centering works better, but I'm afraid that might cost too many
687: * cycles. Plus it's dangerous, see the code below that handles the case
688: * with sprites. */
689: if (dip_for_drawing->nr_sprites == 0) {
690: int hiresadjust = bplhires ? 4 : 8;
691: ddf_left = ((dp_for_drawing->plfstrt + hiresadjust)*2 + mindelay - DISPLAY_LEFT_SHIFT) << lores_shift;
692: ddf_right = ((dp_for_drawing->plfstrt + dp_for_drawing->plflinelen + hiresadjust)*2 + maxdelay - DISPLAY_LEFT_SHIFT) << lores_shift;
693:
694: if (linetoscr_diw_start < ddf_left)
695: linetoscr_diw_start = ddf_left;
696: if (linetoscr_diw_end > ddf_right)
697: linetoscr_diw_end = ddf_right;
698:
699: if (mindelay != maxdelay) {
700: /* Raahh...
701: * We just clear the maximum amount of space that may need to be
702: * cleared. We could do this exactly, but it would come out slower
703: * because of the overhead. */
704: if (currprefs.gfx_lores == 2) {
705: fuzzy_memset_le32 (pixdata.apixels, 0, (ddf_left>>1), 15);
706: fuzzy_memset_le32 (pixdata.apixels, 0, (ddf_right>>1) - 15, 15);
707: } else if (currprefs.gfx_lores) {
708: fuzzy_memset_le32 (pixdata.apixels, 0, ddf_left, 15);
709: fuzzy_memset_le32 (pixdata.apixels, 0, ddf_right - 15, 15);
710: } else {
711: fuzzy_memset_le32 (pixdata.apixels, 0, ddf_left, 30);
712: fuzzy_memset_le32 (pixdata.apixels, 0, ddf_right - 30, 30);
713: }
714: }
715: } else {
716: int hiresadjust = bplhires ? 4 : 8;
717: /* We swap mindelay and maxdelay here to get rid of the mindelay != maxdelay check.
718: * Since we have to do a memset anyway (because there may be sprites),
719: * we might as well clear all at once. */
720: ddf_left = ((dp_for_drawing->plfstrt + hiresadjust)*2 + maxdelay - DISPLAY_LEFT_SHIFT) << lores_shift;
721: ddf_right = ((dp_for_drawing->plfstrt + dp_for_drawing->plflinelen + hiresadjust)*2 + mindelay - DISPLAY_LEFT_SHIFT) << lores_shift;
722: if (linetoscr_diw_start < ddf_left) {
723: int strt = linetoscr_diw_start;
724: int stop = ddf_left;
725: #ifdef LORES_HACK
726: if (currprefs.gfx_lores == 2)
727: strt >>= 1, stop >>= 1;
728: #endif
729: if (strt < stop)
730: fuzzy_memset (pixdata.apixels, 0, strt, stop - strt);
731: }
732:
733: if (linetoscr_diw_end > ddf_right) {
734: int strt = ddf_right;
735: int stop = linetoscr_diw_end;
736: #ifdef LORES_HACK
737: if (currprefs.gfx_lores == 2)
738: strt >>= 1, stop >>= 1;
739: #endif
740: if (strt < stop)
741: fuzzy_memset (pixdata.apixels, 0, strt, stop - strt);
742: }
743: }
744: /* Perverse cases happen. */
745: if (linetoscr_diw_end < linetoscr_diw_start)
746: linetoscr_diw_end = linetoscr_diw_start;
747: }
748:
749: static void pfield_do_linetoscr(int start, int stop)
750: {
751: int lframe_end = linetoscr_diw_start, diw_end = linetoscr_diw_end;
752:
753: if (stop > linetoscr_right_x)
754: stop = linetoscr_right_x;
755: if (start < linetoscr_x_adjust)
756: start = linetoscr_x_adjust;
757:
758: if (lframe_end < start)
759: lframe_end = start;
760: if (diw_end > stop)
761: diw_end = stop;
762:
763: if (start >= stop)
764: return;
765:
766: #if AGA_CHIPSET == 0
767: if (start == linetoscr_x_adjust && stop == linetoscr_right_x) {
768: switch (gfxvidinfo.pixbytes) {
769: case 1: pfield_linetoscr_full8 (start, lframe_end, diw_end, stop); break;
770: case 2: pfield_linetoscr_full16 (start, lframe_end, diw_end, stop); break;
771: case 3: pfield_linetoscr_full24 (start, lframe_end, diw_end, stop); break;
772: case 4: pfield_linetoscr_full32 (start, lframe_end, diw_end, stop); break;
773: }
774: } else {
775: switch (gfxvidinfo.pixbytes) {
776: case 1: pfield_linetoscr_8 (start, lframe_end, diw_end, stop); break;
777: case 2: pfield_linetoscr_16 (start, lframe_end, diw_end, stop); break;
778: case 3: pfield_linetoscr_24 (start, lframe_end, diw_end, stop); break;
779: case 4: pfield_linetoscr_32 (start, lframe_end, diw_end, stop); break;
780: }
781: }
782: #else
783: pfield_linetoscr_aga(start, lframe_end, diw_end, stop);
784: #endif
785: }
786:
787: static void pfield_do_fill_line(int start, int stop)
788: {
789: if (stop > linetoscr_right_x)
790: stop = linetoscr_right_x;
791: if (start < linetoscr_x_adjust)
792: start = linetoscr_x_adjust;
793:
794: if (start >= stop)
795: return;
796:
797: switch (gfxvidinfo.pixbytes) {
798: case 1: fill_line_8 (xlinebuffer, start, stop); break;
799: case 2: fill_line_16 (xlinebuffer, start, stop); break;
800: case 3: fill_line_24 (xlinebuffer, start, stop); break;
801: case 4: fill_line_32 (xlinebuffer, start, stop); break;
802: }
803: }
804:
805: static void pfield_do_linetoscr_full(int double_line)
806: {
807: int start = linetoscr_x_adjust, stop = start + gfxvidinfo.width;
808: int lframe_end = linetoscr_diw_start, diw_end = linetoscr_diw_end;
809: if (lframe_end < start)
810: lframe_end = start;
811: if (diw_end > stop)
812: diw_end = stop;
813:
814: #if AGA_CHIPSET == 0
815: if (double_line) {
816: switch (gfxvidinfo.pixbytes) {
817: case 1: pfield_linetoscr_full8_double (start, lframe_end, diw_end, stop); break;
818: case 2: pfield_linetoscr_full16_double (start, lframe_end, diw_end, stop); break;
819: case 3: pfield_linetoscr_full24_double (start, lframe_end, diw_end, stop); break;
820: case 4: pfield_linetoscr_full32_double (start, lframe_end, diw_end, stop); break;
821: }
822: } else
823: switch (gfxvidinfo.pixbytes) {
824: case 1: pfield_linetoscr_full8 (start, lframe_end, diw_end, stop); break;
825: case 2: pfield_linetoscr_full16 (start, lframe_end, diw_end, stop); break;
826: case 3: pfield_linetoscr_full24 (start, lframe_end, diw_end, stop); break;
827: case 4: pfield_linetoscr_full32 (start, lframe_end, diw_end, stop); break;
828: }
829: #else
830: pfield_linetoscr_aga(start, lframe_end, diw_end, stop);
831: #endif
832: }
833:
834: static void gen_pfield_tables(void)
835: {
836: int i;
837: union {
838: struct {
839: uae_u8 a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
840: } foo;
841: struct {
842: uae_u32 a, b, c, d;
843: } bar;
844: } baz;
845:
846: /* For now, the AGA stuff is broken in the dual playfield case. We encode
847: * sprites in dpf mode by ORing the pixel value with 0x80. To make dual
848: * playfield rendering easy, the lookup tables contain are made linear for
849: * values >= 128. That only works for OCS/ECS, though. */
850:
851: for (i = 0; i < 256; i++) {
852: int plane1 = (i & 1) | ((i >> 1) & 2) | ((i >> 2) & 4) | ((i >> 3) & 8);
853: int plane2 = ((i >> 1) & 1) | ((i >> 2) & 2) | ((i >> 3) & 4) | ((i >> 4) & 8);
854: dblpf_2nd1[i] = plane1 == 0 ? (plane2 == 0 ? 0 : 2) : 1;
855: dblpf_2nd2[i] = plane2 == 0 ? (plane1 == 0 ? 0 : 1) : 2;
856: if (plane2 > 0)
857: plane2 += 8;
858: dblpf_ind1[i] = i >= 128 ? i & 0x7F : (plane1 == 0 ? plane2 : plane1);
859: dblpf_ind2[i] = i >= 128 ? i & 0x7F : (plane2 == 0 ? plane1 : plane2);
860:
861: lots_of_twos[i] = i == 0 ? 0 : 2;
862: linear_map_256[i] = i;
863: }
864:
865: for (i = 0; i < 256; i++) {
866: /* We lose every second pixel in HiRes if UAE runs in a 320x200 screen. */
867: baz.foo.a = i & 64 ? 1 : 0;
868: baz.foo.b = i & 16 ? 1 : 0;
869: baz.foo.c = i & 4 ? 1 : 0;
870: baz.foo.d = i & 1 ? 1 : 0;
871: hirestab_l[i][0] = baz.bar.a;
872:
873: baz.foo.a = i & 128 ? 1 : 0;
874: baz.foo.b = i & 64 ? 1 : 0;
875: baz.foo.c = i & 32 ? 1 : 0;
876: baz.foo.d = i & 16 ? 1 : 0;
877: baz.foo.e = i & 8 ? 1 : 0;
878: baz.foo.f = i & 4 ? 1 : 0;
879: baz.foo.g = i & 2 ? 1 : 0;
880: baz.foo.h = i & 1 ? 1 : 0;
881: lorestab_l[i][0] = baz.bar.a;
882: lorestab_l[i][1] = baz.bar.b;
883: clxtab[i] = ((((i & 3) && (i & 12)) << 9)
884: | (((i & 3) && (i & 48)) << 10)
885: | (((i & 3) && (i & 192)) << 11)
886: | (((i & 12) && (i & 48)) << 12)
887: | (((i & 12) && (i & 192)) << 13)
888: | (((i & 48) && (i & 192)) << 14));
889: }
890:
891: for (i = 0; i < 256; i++) {
892: baz.foo.a = i & 128 ? 1 : 0;
893: baz.foo.b = i & 64 ? 1 : 0;
894: baz.foo.c = i & 32 ? 1 : 0;
895: baz.foo.d = i & 16 ? 1 : 0;
896: baz.foo.e = i & 8 ? 1 : 0;
897: baz.foo.f = i & 4 ? 1 : 0;
898: baz.foo.g = i & 2 ? 1 : 0;
899: baz.foo.h = i & 1 ? 1 : 0;
900: hirestab_h[i][0] = baz.bar.a;
901: hirestab_h[i][1] = baz.bar.b;
902:
903: baz.foo.a = i & 128 ? 1 : 0;
904: baz.foo.b = i & 128 ? 1 : 0;
905: baz.foo.c = i & 64 ? 1 : 0;
906: baz.foo.d = i & 64 ? 1 : 0;
907: baz.foo.e = i & 32 ? 1 : 0;
908: baz.foo.f = i & 32 ? 1 : 0;
909: baz.foo.g = i & 16 ? 1 : 0;
910: baz.foo.h = i & 16 ? 1 : 0;
911: baz.foo.i = i & 8 ? 1 : 0;
912: baz.foo.j = i & 8 ? 1 : 0;
913: baz.foo.k = i & 4 ? 1 : 0;
914: baz.foo.l = i & 4 ? 1 : 0;
915: baz.foo.m = i & 2 ? 1 : 0;
916: baz.foo.n = i & 2 ? 1 : 0;
917: baz.foo.o = i & 1 ? 1 : 0;
918: baz.foo.p = i & 1 ? 1 : 0;
919: lorestab_h[i][0] = baz.bar.a;
920: lorestab_h[i][1] = baz.bar.b;
921: lorestab_h[i][2] = baz.bar.c;
922: lorestab_h[i][3] = baz.bar.d;
923: }
924: }
925:
926: static uae_u32 attach_2nd;
927:
928: static uae_u32 do_sprite_collisions (struct sprite_draw *spd, int prev_overlap, int i, int nr_spr)
929: {
930: int j;
931: int sprxp = spd[i].linepos;
932: uae_u32 datab = spd[i].datab;
933: uae_u32 mask2 = 0;
934: int sbit = 1 << spd[i].num;
935: int sprx_shift = 1;
936: int attach_compare = -1;
937: if (currprefs.gfx_lores != 1)
938: sprx_shift = 0;
939:
940: attach_2nd = 0;
941: if ((spd[i].num & 1) == 1 && (spd[i].ctl & 0x80) == 0x80)
942: attach_compare = spd[i].num - 1;
943:
944: for (j = prev_overlap; j < i; j++) {
945: uae_u32 mask1;
946: int off;
947:
948: if (spd[i].num < spd[j].num)
949: continue;
950:
951: off = sprxp - spd[j].linepos;
952: off <<= sprx_shift;
953: mask1 = spd[j].datab >> off;
954:
955: /* If j is an attachment for i, then j doesn't block i */
956: if (spd[j].num == attach_compare) {
957: attach_2nd |= mask1;
958: } else {
959: mask1 |= (mask1 & 0xAAAAAAAA) >> 1;
960: mask1 |= (mask1 & 0x55555555) << 1;
961: if (datab & mask1)
962: clxdat |= clxtab[(sbit | (1 << spd[j].num)) & clx_sprmask];
963: mask2 |= mask1;
964: }
965: }
966: for (j = i+1; j < nr_spr; j++) {
967: uae_u32 mask1;
968: int off = spd[j].linepos - sprxp;
969:
970: if (off >= sprite_width || spd[i].num < spd[j].num)
971: break;
972:
973: off <<= sprx_shift;
974: mask1 = spd[j].datab << off;
975:
976: /* If j is an attachment for i, then j doesn't block i */
977: if (spd[j].num == attach_compare) {
978: attach_2nd |= mask1;
979: } else {
980: mask1 |= (mask1 & 0xAAAAAAAA) >> 1;
981: mask1 |= (mask1 & 0x55555555) << 1;
982: if (datab & mask1)
983: clxdat |= clxtab[(sbit | (1 << spd[j].num)) & clx_sprmask];
984: mask2 |= mask1;
985: }
986: }
987: datab &= ~mask2;
988: return datab;
989: }
990:
991: static __inline__ void render_sprite (int spr, int sprxp, uae_u32 datab, int ham, int attch, int sprx_inc)
992: {
993: uae_u32 datcd;
994: int basecol = 16;
995: if (!attch)
996: basecol += (spr & ~1)*2;
997: if (bpldualpf)
998: basecol |= 128;
999: if (attch)
1000: datcd = attach_2nd;
1001:
1002: for(; attch ? datab | datcd : datab; sprxp += sprx_inc) {
1003: int col;
1004:
1005: if (attch) {
1006: col = ((datab & 3) << 2) | (datcd & 3);
1007: datcd >>= 2;
1008: } else
1009: col = datab & 3;
1010: datab >>= 2;
1011: if (col) {
1012: col |= basecol;
1013: if (ham) {
1014: col = colors_for_drawing.color_regs[col];
1015: ham_linebuf[sprxp] = col;
1016: if (sprx_inc == 2) {
1017: ham_linebuf[sprxp+1] = col;
1018: }
1019: } else {
1020: pixdata.apixels[sprxp] = col;
1021: if (sprx_inc == 2) {
1022: pixdata.apixels[sprxp+1] = col;
1023: }
1024: }
1025: }
1026: }
1027: }
1028:
1029: static void walk_sprites (struct sprite_draw *spd, int nr_spr)
1030: {
1031: int i, prev_overlap;
1032: int last_sprite_pos = -64;
1033: uae_u32 plane1 = 0, plane2 = 0;
1034: int sprx_inc = 1, sprx_shift = 1;
1035:
1036: if (currprefs.gfx_lores == 0)
1037: sprx_inc = 2, sprx_shift = 0;
1038:
1039: prev_overlap = 0;
1040: for (i = 0; i < nr_spr; i++) {
1041: int sprxp = spd[i].linepos;
1042: int m = 1 << spd[i].num;
1043: uae_u32 datab;
1044: while (prev_overlap < i && spd[prev_overlap].linepos + sprite_width <= sprxp)
1045: prev_overlap++;
1046:
1047: datab = do_sprite_collisions (spd, prev_overlap, i, nr_spr);
1048: #ifdef LORES_HACK
1049: if (currprefs.gfx_lores == 2)
1050: sprxp >>= 1;
1051: #endif
1052: if ((bpldualpf && plfpri[1] < 256) || (plfpri[2] < 256)) {
1053: if (sprxp != last_sprite_pos) {
1054: int ok = last_sprite_pos-sprxp+16;
1055: int ok2;
1056: if (ok <= 0) {
1057: ok = ok2 = 0;
1058: plane1 = 0;
1059: plane2 = 0;
1060: } else {
1061: ok2 = ok << sprx_shift;
1062: plane1 >>= 32 - ok2;
1063: plane2 >>= 32 - ok2;
1064: }
1065: last_sprite_pos = sprxp;
1066:
1067: if (bpldualpf) {
1068: uae_u32 mask = 3 << ok2;
1069: int p = sprxp+ok;
1070:
1071: for (; mask; mask <<= 2, p += sprx_inc) {
1072: int data = pixdata.apixels[p];
1073: if (dblpf_2nd2[data] == 2)
1074: plane2 |= mask;
1075: if (dblpf_2nd1[data] == 1)
1076: plane1 |= mask;
1077: }
1078: } else {
1079: uae_u32 mask = 3 << ok2;
1080: int p = sprxp+ok;
1081:
1082: for (; mask; mask <<= 2, p += sprx_inc) {
1083: if (pixdata.apixels[p])
1084: plane2 |= mask;
1085: }
1086: }
1087: }
1088: if (bpldualpf && m >= plfpri[1]) {
1089: datab &= ~plane1;
1090: attach_2nd &= ~plane1;
1091: }
1092: if (m >= plfpri[2]) {
1093: datab &= ~plane2;
1094: attach_2nd &= ~plane2;
1095: }
1096: }
1097: if ((spd[i].num & 1) == 1 && (spd[i].ctl & 0x80) == 0x80) {
1098: /* Attached sprite */
1099: if (bplham) {
1100: if (sprx_inc == 1) {
1101: render_sprite (spd[i].num, sprxp, datab, 1, 1, 1);
1102: } else {
1103: render_sprite (spd[i].num, sprxp, datab, 1, 1, 2);
1104: }
1105: } else {
1106: if (sprx_inc == 1) {
1107: render_sprite (spd[i].num, sprxp, datab, 0, 1, 1);
1108: } else {
1109: render_sprite (spd[i].num, sprxp, datab, 0, 1, 2);
1110: }
1111: }
1112: /* This still leaves one attached sprite bug, but at the moment I'm too lazy */
1113: if (i + 1 < nr_spr && spd[i+1].num == spd[i].num - 1 && spd[i+1].linepos == spd[i].linepos)
1114: i++;
1115: } else {
1116: if (bplham) {
1117: if (sprx_inc == 1) {
1118: render_sprite (spd[i].num, sprxp, datab, 1, 0, 1);
1119: } else {
1120: render_sprite (spd[i].num, sprxp, datab, 1, 0, 2);
1121: }
1122: } else {
1123: if (sprx_inc == 1) {
1124: render_sprite (spd[i].num, sprxp, datab, 0, 0, 1);
1125: } else {
1126: render_sprite (spd[i].num, sprxp, datab, 0, 0, 2);
1127: }
1128: }
1129: }
1130: }
1131: }
1132:
1133: #ifndef SMART_UPDATE
1134: #undef UNALIGNED_PROFITABLE
1135: #endif
1136:
1137: #ifdef UNALIGNED_PROFITABLE
1138:
1139: static void pfield_doline_unaligned_h (int lineno)
1140: {
1141: int xpos = dp_for_drawing->plfstrt * 4 - DISPLAY_LEFT_SHIFT * 2;
1142:
1143: if (bplhires) {
1144: int xpos1 = xpos + 16 + bpldelay1*2;
1145: int xpos2;
1146: uae_u8 *dataptr = line_data[lineno];
1147: int len = dp_for_drawing->plflinelen >> 1;
1148:
1149: if (len <= 0)
1150: return;
1151:
1152: if (bpldelay1 == bpldelay2) {
1153: switch (bplplanecnt) {
1154: case 1: set_hires_h_0_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1155: case 2: set_hires_h_1_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1156: case 3: set_hires_h_2_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1157: case 4: set_hires_h_3_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1158: case 5: set_hires_h_4_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1159: case 6: set_hires_h_5_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1160: case 7: set_hires_h_6_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1161: case 8: set_hires_h_7_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1162: }
1163: } else {
1164: switch (bplplanecnt) {
1165: case 1: case 2: set_hires_h_0_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1166: case 3: case 4: set_hires_h_1_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1167: case 5: case 6: set_hires_h_2_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1168: case 7: case 8: set_hires_h_3_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1169: }
1170:
1171: xpos2 = xpos + 16 + bpldelay2*2;
1172: switch (bplplanecnt) {
1173: case 2: case 3: set_hires_h_0_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1174: case 4: case 5: set_hires_h_1_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1175: case 6: case 7: set_hires_h_2_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1176: case 8: set_hires_h_3_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1177: }
1178: }
1179: } else {
1180: int xpos1 = xpos + 32 + bpldelay1*2;
1181: int xpos2;
1182: uae_u8 *dataptr = line_data[lineno];
1183: int len = dp_for_drawing->plflinelen >> 2;
1184:
1185: if (len <= 0)
1186: return;
1187:
1188: if (bpldelay1 == bpldelay2) {
1189: switch (bplplanecnt) {
1190: case 1: set_lores_h_0_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1191: case 2: set_lores_h_1_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1192: case 3: set_lores_h_2_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1193: case 4: set_lores_h_3_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1194: case 5: set_lores_h_4_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1195: case 6: set_lores_h_5_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1196: case 7: set_lores_h_6_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1197: case 8: set_lores_h_7_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1198: }
1199: } else {
1200: switch (bplplanecnt) {
1201: case 1: case 2: set_lores_h_0_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1202: case 3: case 4: set_lores_h_1_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1203: case 5: case 6: set_lores_h_2_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1204: case 7: case 8: set_lores_h_3_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1205: }
1206:
1207: xpos2 = xpos + 32 + bpldelay2*2;
1208: switch (bplplanecnt) {
1209: case 2: case 3: set_lores_h_0_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1210: case 4: case 5: set_lores_h_1_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1211: case 6: case 7: set_lores_h_2_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1212: case 8: set_lores_h_3_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1213: }
1214: }
1215: }
1216: }
1217:
1218: static void pfield_doline_unaligned_l (int lineno)
1219: {
1220: int xpos = dp_for_drawing->plfstrt * 2 - DISPLAY_LEFT_SHIFT;
1221:
1222: if (bplhires) {
1223: int xpos1 = xpos + 8 + bpldelay1;
1224: int xpos2;
1225: uae_u8 *dataptr = line_data[lineno];
1226: int len = dp_for_drawing->plflinelen >> 1;
1227:
1228: if (len <= 0)
1229: return;
1230:
1231: if (bpldelay1 == bpldelay2) {
1232: switch (bplplanecnt) {
1233: case 1: set_hires_l_0_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1234: case 2: set_hires_l_1_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1235: case 3: set_hires_l_2_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1236: case 4: set_hires_l_3_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1237: case 5: set_hires_l_4_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1238: case 6: set_hires_l_5_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1239: case 7: set_hires_l_6_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1240: case 8: set_hires_l_7_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1241: }
1242: } else {
1243: switch (bplplanecnt) {
1244: case 1: case 2: set_hires_l_0_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1245: case 3: case 4: set_hires_l_1_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1246: case 5: case 6: set_hires_l_2_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1247: case 7: case 8: set_hires_l_3_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1248: }
1249:
1250: xpos2 = xpos + 8 + bpldelay2;
1251: switch (bplplanecnt) {
1252: case 2: case 3: set_hires_l_0_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1253: case 4: case 5: set_hires_l_1_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1254: case 6: case 7: set_hires_l_2_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1255: case 8: set_hires_l_3_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1256: }
1257: }
1258: } else {
1259: int xpos1 = xpos + 16 + bpldelay1;
1260: int xpos2;
1261: uae_u8 *dataptr = line_data[lineno];
1262: int len = dp_for_drawing->plflinelen >> 2;
1263:
1264: if (len <= 0)
1265: return;
1266:
1267: if (bpldelay1 == bpldelay2) {
1268: switch (bplplanecnt) {
1269: case 1: set_hires_h_0_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1270: case 2: set_hires_h_1_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1271: case 3: set_hires_h_2_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1272: case 4: set_hires_h_3_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1273: case 5: set_hires_h_4_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1274: case 6: set_hires_h_5_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1275: case 7: set_hires_h_6_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1276: case 8: set_hires_h_7_0 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1277: }
1278: } else {
1279: switch (bplplanecnt) {
1280: case 1: case 2: set_hires_h_0_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1281: case 3: case 4: set_hires_h_1_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1282: case 5: case 6: set_hires_h_2_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1283: case 7: case 8: set_hires_h_3_1 ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, len); break;
1284: }
1285:
1286: xpos2 = xpos + 16 + bpldelay2;
1287: switch (bplplanecnt) {
1288: case 2: case 3: set_hires_h_0_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1289: case 4: case 5: set_hires_h_1_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1290: case 6: case 7: set_hires_h_2_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1291: case 8: set_hires_h_3_2 ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, len); break;
1292: }
1293: }
1294: }
1295: }
1296:
1297: #define pfield_doline_h pfield_doline_unaligned_h
1298: #define pfield_doline_l pfield_doline_unaligned_l
1299:
1300: #else /* not UNALIGNED_PROFITABLE */
1301:
1302:
1303: static __inline__ void pfield_orword_hires_h(int data, unsigned char *dp, int bit)
1304: {
1305: uae_u32 *pixptr = (uae_u32 *)dp;
1306:
1307: *pixptr |= hirestab_h[data >> 8][0] << bit;
1308: *(pixptr+1) |= hirestab_h[data >> 8][1] << bit;
1309: *(pixptr+2) |= hirestab_h[data & 255][0] << bit;
1310: *(pixptr+3) |= hirestab_h[data & 255][1] << bit;
1311: }
1312:
1313: static __inline__ void pfield_orword_lores_h(int data, unsigned char *dp, int bit)
1314: {
1315: uae_u32 *pixptr = (uae_u32 *)dp;
1316:
1317: *pixptr |= lorestab_h[data >> 8][0] << bit;
1318: *(pixptr+1) |= lorestab_h[data >> 8][1] << bit;
1319: *(pixptr+2) |= lorestab_h[data >> 8][2] << bit;
1320: *(pixptr+3) |= lorestab_h[data >> 8][3] << bit;
1321: *(pixptr+4) |= lorestab_h[data & 255][0] << bit;
1322: *(pixptr+5) |= lorestab_h[data & 255][1] << bit;
1323: *(pixptr+6) |= lorestab_h[data & 255][2] << bit;
1324: *(pixptr+7) |= lorestab_h[data & 255][3] << bit;
1325: }
1326:
1327: static __inline__ void pfield_setword_hires_h(int data, unsigned char *dp, int bit)
1328: {
1329: uae_u32 *pixptr = (uae_u32 *)dp;
1330:
1331: *pixptr = hirestab_h[data >> 8][0] << bit;
1332: *(pixptr+1) = hirestab_h[data >> 8][1] << bit;
1333: *(pixptr+2) = hirestab_h[data & 255][0] << bit;
1334: *(pixptr+3) = hirestab_h[data & 255][1] << bit;
1335: }
1336:
1337: static __inline__ void pfield_setword_lores_h(int data, unsigned char *dp, int bit)
1338: {
1339: uae_u32 *pixptr = (uae_u32 *)dp;
1340:
1341: *pixptr = lorestab_h[data >> 8][0] << bit;
1342: *(pixptr+1) = lorestab_h[data >> 8][1] << bit;
1343: *(pixptr+2) = lorestab_h[data >> 8][2] << bit;
1344: *(pixptr+3) = lorestab_h[data >> 8][3] << bit;
1345: *(pixptr+4) = lorestab_h[data & 255][0] << bit;
1346: *(pixptr+5) = lorestab_h[data & 255][1] << bit;
1347: *(pixptr+6) = lorestab_h[data & 255][2] << bit;
1348: *(pixptr+7) = lorestab_h[data & 255][3] << bit;
1349: }
1350:
1351: static __inline__ void pfield_orword_hires_l(int data, unsigned char *dp, int bit)
1352: {
1353: uae_u32 *pixptr = (uae_u32 *)dp;
1354:
1355: *pixptr |= hirestab_l[data >> 8][0] << bit;
1356: *(pixptr+1) |= hirestab_l[data & 255][0] << bit;
1357: }
1358:
1359: static __inline__ void pfield_orword_lores_l(int data, unsigned char *dp, int bit)
1360: {
1361: uae_u32 *pixptr = (uae_u32 *)dp;
1362:
1363: *pixptr |= lorestab_l[data >> 8][0] << bit;
1364: *(pixptr+1) |= lorestab_l[data >> 8][1] << bit;
1365: *(pixptr+2) |= lorestab_l[data & 255][0] << bit;
1366: *(pixptr+3) |= lorestab_l[data & 255][1] << bit;
1367: }
1368:
1369: static __inline__ void pfield_setword_hires_l(int data, unsigned char *dp, int bit)
1370: {
1371: uae_u32 *pixptr = (uae_u32 *)dp;
1372:
1373: *pixptr = hirestab_l[data >> 8][0] << bit;
1374: *(pixptr+1) = hirestab_l[data & 255][0] << bit;
1375: }
1376:
1377: static __inline__ void pfield_setword_lores_l(int data, unsigned char *dp, int bit)
1378: {
1379: uae_u32 *pixptr = (uae_u32 *)dp;
1380:
1381: *pixptr = lorestab_l[data >> 8][0] << bit;
1382: *(pixptr+1) = lorestab_l[data >> 8][1] << bit;
1383: *(pixptr+2) = lorestab_l[data & 255][0] << bit;
1384: *(pixptr+3) = lorestab_l[data & 255][1] << bit;
1385: }
1386:
1387: #define DO_ONE_PLANE(POINTER, MULT, FUNC, DELAY, LL_SUB, P_ADD) { \
1388: int i; \
1389: unsigned int bpldat1; \
1390: uae_u16 data; \
1391: unsigned int bpldat2 = 0; \
1392: uae_u8 *ptr = (POINTER); \
1393: for (i = dp_for_drawing->plflinelen; i > 0; i -= LL_SUB) { \
1394: bpldat1 = bpldat2; \
1395: bpldat2 = do_get_mem_word ((uae_u16 *)ptr); \
1396: ptr+=2; \
1397: data = (bpldat1 << (16 - DELAY)) | (bpldat2 >> DELAY); \
1398: FUNC(data, app, MULT); \
1399: app += P_ADD; \
1400: } \
1401: data = bpldat2 << (16 - DELAY); \
1402: FUNC(data, app, MULT); \
1403: }
1404:
1405: #ifdef SMART_UPDATE
1406: #define DATA_POINTER(n) (dataptr + (n)*MAX_WORDS_PER_LINE*2)
1407: #else
1408: #define DATA_POINTER(n) (real_bplpt[n])
1409: #endif
1410:
1411: static void pfield_doline_aligned_h (int lineno)
1412: {
1413: int xpos = dp_for_drawing->plfstrt * 4 - DISPLAY_LEFT_SHIFT * 2;
1414:
1415: if (bplhires) {
1416: if (bplplanecnt > 0) {
1417: int xpos1 = xpos + 16 + (bpldelay1 >= 8 ? 16 : 0);
1418: int xpos2 = xpos + 16 + (bpldelay2 >= 8 ? 16 : 0);
1419: int delay1 = 2*(bpldelay1 & 7);
1420: int delay2 = 2*(bpldelay2 & 7);
1421: unsigned char *app = pixdata.apixels + xpos1;
1422: uae_u8 *dataptr = line_data[lineno];
1423:
1424: DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_hires_h, delay1, 4, 16);
1425: if (bplplanecnt > 2) {
1426: app = pixdata.apixels + xpos1;
1427: DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_hires_h, delay1, 4, 16);
1428: }
1429: #if AGA_CHIPSET == 1
1430: if (bplplanecnt > 4) {
1431: app = pixdata.apixels + xpos1;
1432: DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_hires_h, delay1, 4, 16);
1433: }
1434: if (bplplanecnt > 6) {
1435: app = pixdata.apixels + xpos1;
1436: DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_hires_h, delay1, 4, 16);
1437: }
1438: #endif
1439: if (bplplanecnt > 1) {
1440: app = pixdata.apixels + xpos2;
1441: DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_hires_h, delay2, 4, 16);
1442: }
1443: if (bplplanecnt > 3) {
1444: app = pixdata.apixels + xpos2;
1445: DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_hires_h, delay2, 4, 16);
1446: }
1447: #if AGA_CHIPSET == 1
1448: if (bplplanecnt > 5) {
1449: app = pixdata.apixels + xpos2;
1450: DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_hires_h, delay2, 4, 16);
1451: }
1452: if (bplplanecnt > 7) {
1453: app = pixdata.apixels + xpos2;
1454: DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_hires_h, delay2, 4, 16);
1455: }
1456: #endif
1457: } else {
1458: memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
1459: }
1460: } else {
1461: if (bplplanecnt > 0) {
1462: int x = xpos + 32;
1463: unsigned char *app = pixdata.apixels + x;
1464: uae_u8 *dataptr = line_data[lineno];
1465:
1466: DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_lores_h, bpldelay1, 8, 32);
1467: if (bplplanecnt > 2) {
1468: app = pixdata.apixels + x;
1469: DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_lores_h, bpldelay1, 8, 32);
1470: }
1471: if (bplplanecnt > 4) {
1472: app = pixdata.apixels + x;
1473: DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_lores_h, bpldelay1, 8, 32);
1474: }
1475: #if AGA_CHIPSET == 1
1476: if (bplplanecnt > 6) {
1477: app = pixdata.apixels + x;
1478: DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_lores_h, bpldelay1, 8, 32);
1479: }
1480: #endif
1481: if (bplplanecnt > 1) {
1482: app = pixdata.apixels + x;
1483: DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_lores_h, bpldelay2, 8, 32);
1484: }
1485: if (bplplanecnt > 3) {
1486: app = pixdata.apixels + x;
1487: DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_lores_h, bpldelay2, 8, 32);
1488: }
1489: if (bplplanecnt > 5) {
1490: app = pixdata.apixels + x;
1491: DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_lores_h, bpldelay2, 8, 32);
1492: }
1493: #if AGA_CHIPSET == 1
1494: if (bplplanecnt > 7) {
1495: app = pixdata.apixels + x;
1496: DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_lores_h, bpldelay2, 8, 32);
1497: }
1498: #endif
1499: } else {
1500: memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
1501: }
1502: }
1503: }
1504:
1505: static void pfield_doline_aligned_l (int lineno)
1506: {
1507: int xpos = dp_for_drawing->plfstrt * 2 - DISPLAY_LEFT_SHIFT;
1508:
1509: if (bplhires) {
1510: if (bplplanecnt > 0) {
1511: int xpos1 = xpos + 8 + (bpldelay1 >= 8 ? 8 : 0);
1512: int xpos2 = xpos + 8 + (bpldelay2 >= 8 ? 8 : 0);
1513: int delay1 = (bpldelay1 & 7) * 2;
1514: int delay2 = (bpldelay2 & 7) * 2;
1515: unsigned char *app = pixdata.apixels + xpos1;
1516: uae_u8 *dataptr = line_data[lineno];
1517:
1518: DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_hires_l, delay1, 4, 8);
1519: if (bplplanecnt > 2) {
1520: app = pixdata.apixels + xpos1;
1521: DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_hires_l, delay1, 4, 8);
1522: }
1523: #if AGA_CHIPSET == 1
1524: if (bplplanecnt > 4) {
1525: app = pixdata.apixels + xpos1;
1526: DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_hires_l, delay1, 4, 8);
1527: }
1528: if (bplplanecnt > 6) {
1529: app = pixdata.apixels + xpos1;
1530: DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_hires_l, delay1, 4, 8);
1531: }
1532: #endif
1533: if (bplplanecnt > 1) {
1534: app = pixdata.apixels + xpos2;
1535: DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_hires_l, delay2, 4, 8);
1536: }
1537: if (bplplanecnt > 3) {
1538: app = pixdata.apixels + xpos2;
1539: DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_hires_l, delay2, 4, 8);
1540: }
1541: #if AGA_CHIPSET == 1
1542: if (bplplanecnt > 5) {
1543: app = pixdata.apixels + xpos2;
1544: DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_hires_l, delay2, 4, 8);
1545: }
1546: if (bplplanecnt > 7) {
1547: app = pixdata.apixels + xpos2;
1548: DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_hires_l, delay2, 4, 8);
1549: }
1550: #endif
1551: } else {
1552: memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
1553: }
1554: } else {
1555: if (bplplanecnt > 0) {
1556: int x = xpos + 16;
1557: int delay1 = bpldelay1;
1558: int delay2 = bpldelay2;
1559: unsigned char *app = pixdata.apixels + x;
1560: uae_u8 *dataptr = line_data[lineno];
1561:
1562: DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_lores_l, delay1, 8, 16);
1563: if (bplplanecnt > 2) {
1564: app = pixdata.apixels + x;
1565: DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_lores_l, delay1, 8, 16);
1566: }
1567: if (bplplanecnt > 4) {
1568: app = pixdata.apixels + x;
1569: DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_lores_l, delay1, 8, 16);
1570: }
1571: #if AGA_CHIPSET == 1
1572: if (bplplanecnt > 6) {
1573: app = pixdata.apixels + x;
1574: DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_lores_l, delay1, 8, 16);
1575: }
1576: #endif
1577: if (bplplanecnt > 1) {
1578: app = pixdata.apixels + x;
1579: DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_lores_l, delay2, 8, 16);
1580: }
1581: if (bplplanecnt > 3) {
1582: app = pixdata.apixels + x;
1583: DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_lores_l, delay2, 8, 16);
1584: }
1585: if (bplplanecnt > 5) {
1586: app = pixdata.apixels + x;
1587: DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_lores_l, delay2, 8, 16);
1588: }
1589: #if AGA_CHIPSET == 1
1590: if (bplplanecnt > 7) {
1591: app = pixdata.apixels + x;
1592: DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_lores_l, delay2, 8, 16);
1593: }
1594: #endif
1595: } else {
1596: memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
1597: }
1598: }
1599: }
1600:
1601: #define pfield_doline_h pfield_doline_aligned_h
1602: #define pfield_doline_l pfield_doline_aligned_l
1603:
1604: #endif /* UNALIGNED_PROFITABLE */
1605:
1606: static void pfield_adjust_delay (void)
1607: {
1608: int ddf_left = dp_for_drawing->plfstrt;
1609: int ddf_right = dp_for_drawing->plfstrt + dp_for_drawing->plflinelen;
1610: int i;
1611:
1612: for (i = dip_for_drawing->last_delay_change-1; i >= dip_for_drawing->first_delay_change-1; i--) {
1613: int delayreg = i < dip_for_drawing->first_delay_change ? dp_for_drawing->bplcon1 : delay_changes[i].value;
1614: int delay1 = delayreg & 0xF;
1615: int delay2 = (delayreg >> 4) & 0xF;
1616: int startpos = i == dip_for_drawing->last_delay_change - 1 ? ddf_right + 8 : delay_changes[i+1].linepos;
1617: int stoppos = i < dip_for_drawing->first_delay_change ? ddf_left : delay_changes[i].linepos;
1618: int j;
1619: startpos = PIXEL_XPOS (startpos + (bplhires ? 4 : 8));
1620: stoppos = PIXEL_XPOS (stoppos + (bplhires ? 4 : 8));
1621: if (currprefs.gfx_lores == 0)
1622: delay1 <<= 1, delay2 <<= 1;
1623: else if (currprefs.gfx_lores == 2)
1624: startpos >>= 1, stoppos >>= 1;
1625: for (j = startpos-1; j >= stoppos; j--) {
1626: pixdata.apixels [j] = (pixdata.apixels[j-delay1] & 0x55) | (pixdata.apixels[j-delay2] & 0xAA);
1627: }
1628: }
1629: }
1630:
1631: void init_row_map (void)
1632: {
1633: int i;
1634: if (gfxvidinfo.height > 2048) {
1635: write_log ("Resolution too high, aborting\n");
1636: abort ();
1637: }
1638: for (i = 0; i < gfxvidinfo.height + 1; i++)
1639: row_map[i] = gfxvidinfo.bufmem + gfxvidinfo.rowbytes * i;
1640: }
1641:
1642: static void init_aspect_maps (void)
1643: {
1644: int i, maxl;
1645: double native_lines_per_amiga_line;
1646:
1647: if (native2amiga_line_map)
1648: free (native2amiga_line_map);
1649: if (amiga2aspect_line_map)
1650: free (amiga2aspect_line_map);
1651:
1652: /* At least for this array the +1 is necessary. */
1653: amiga2aspect_line_map = (int *)malloc (sizeof (int) * (maxvpos+1)*2 + 1);
1654: native2amiga_line_map = (int *)malloc (sizeof (int) * gfxvidinfo.height);
1655:
1656: if (currprefs.gfx_correct_aspect)
1657: native_lines_per_amiga_line = ((double)gfxvidinfo.height
1658: * (currprefs.gfx_lores ? 320 : 640)
1659: / (currprefs.gfx_linedbl ? 512 : 256)
1660: / gfxvidinfo.width);
1661: else
1662: native_lines_per_amiga_line = 1;
1663:
1664: maxl = (maxvpos+1) * (currprefs.gfx_linedbl ? 2 : 1);
1665: min_ypos_for_screen = minfirstline << (currprefs.gfx_linedbl ? 1 : 0);
1666: max_drawn_amiga_line = -1;
1667: for (i = 0; i < maxl; i++) {
1668: int v = (i - min_ypos_for_screen) * native_lines_per_amiga_line;
1669: if (v >= gfxvidinfo.height && max_drawn_amiga_line == -1)
1670: max_drawn_amiga_line = i - min_ypos_for_screen;
1671: if (i < min_ypos_for_screen || v >= gfxvidinfo.height)
1672: v = -1;
1673: amiga2aspect_line_map[i] = v;
1674: }
1675: if (currprefs.gfx_linedbl)
1676: max_drawn_amiga_line >>= 1;
1677:
1678: if (currprefs.gfx_ycenter && !(currprefs.gfx_correct_aspect)) {
1679: extra_y_adjust = (gfxvidinfo.height - (maxvpos << (currprefs.gfx_linedbl ? 1 : 0))) >> 1;
1680: if (extra_y_adjust < 0)
1681: extra_y_adjust = 0;
1682: }
1683:
1684: for (i = 0; i < gfxvidinfo.height; i++)
1685: native2amiga_line_map[i] = -1;
1686:
1687: if (native_lines_per_amiga_line < 1) {
1688: /* Must omit drawing some lines. */
1689: for (i = maxl - 1; i > min_ypos_for_screen; i--) {
1690: if (amiga2aspect_line_map[i] == amiga2aspect_line_map[i-1]) {
1691: if (currprefs.gfx_linedbl && (i & 1) == 0 && amiga2aspect_line_map[i+1] != -1) {
1692: /* If only the first line of a line pair would be omitted,
1693: * omit the second one instead to avoid problems with line
1694: * doubling. */
1695: amiga2aspect_line_map[i] = amiga2aspect_line_map[i+1];
1696: amiga2aspect_line_map[i+1] = -1;
1697: } else
1698: amiga2aspect_line_map[i] = -1;
1699: }
1700: }
1701: }
1702:
1703: for (i = maxl-1; i >= min_ypos_for_screen; i--) {
1704: int j;
1705: if (amiga2aspect_line_map[i] == -1)
1706: continue;
1707: for (j = amiga2aspect_line_map[i]; j < gfxvidinfo.height && native2amiga_line_map[j] == -1; j++)
1708: native2amiga_line_map[j] = i >> (currprefs.gfx_linedbl ? 1 : 0);
1709: }
1710: }
1711:
1712: /*
1713: * A raster line has been built in the graphics buffer. Tell the graphics code
1714: * to do anything necessary to display it.
1715: */
1716: static void do_flush_line_1 (int lineno)
1717: {
1718: if (lineno < first_drawn_line)
1719: first_drawn_line = lineno;
1720: if (lineno > last_drawn_line)
1721: last_drawn_line = lineno;
1722:
1723: if (gfxvidinfo.maxblocklines == 0)
1724: flush_line(lineno);
1725: else {
1726: if ((last_block_line+1) != lineno) {
1727: if (first_block_line != -2)
1728: flush_block (first_block_line, last_block_line);
1729: first_block_line = lineno;
1730: }
1731: last_block_line = lineno;
1732: if (last_block_line - first_block_line >= gfxvidinfo.maxblocklines) {
1733: flush_block (first_block_line, last_block_line);
1734: first_block_line = last_block_line = -2;
1735: }
1736: }
1737: }
1738:
1739: static __inline__ void do_flush_line (int lineno)
1740: {
1741: /* We don't want to call X libraries from the second thread right now. */
1742: #ifndef SUPPORT_PENGUINS
1743: do_flush_line_1 (lineno);
1744: #else
1745: line_drawn[lineno] = 1;
1746: #endif
1747: }
1748:
1749: /*
1750: * One drawing frame has been finished. Tell the graphics code about it.
1751: * Note that the actual flush_screen() call is a no-op for all reasonable
1752: * systems.
1753: */
1754:
1755: static __inline__ void do_flush_screen (int start, int stop)
1756: {
1757: #ifdef SUPPORT_PENGUINS
1758: int i;
1759: for (i = 0; i < gfxvidinfo.height; i++) {
1760: if (line_drawn[i])
1761: do_flush_line_1 (i);
1762: }
1763: #endif
1764: if (gfxvidinfo.maxblocklines != 0 && first_block_line != -2) {
1765: flush_block (first_block_line, last_block_line);
1766: }
1767: if (start <= stop)
1768: flush_screen (start, stop);
1769: }
1770:
1771: static int drawing_color_matches;
1772: static enum { color_match_acolors, color_match_full } color_match_type;
1773:
1774: static void adjust_drawing_colors (int ctable, int bplham)
1775: {
1776: if (drawing_color_matches != ctable) {
1777: if (bplham) {
1778: memcpy (&colors_for_drawing, curr_color_tables + ctable,
1779: sizeof colors_for_drawing);
1780: color_match_type = color_match_full;
1781: } else {
1782: memcpy (colors_for_drawing.acolors, curr_color_tables[ctable].acolors,
1783: sizeof colors_for_drawing.acolors);
1784: color_match_type = color_match_acolors;
1785: }
1786: drawing_color_matches = ctable;
1787: } else if (bplham && color_match_type != color_match_full) {
1788: memcpy (colors_for_drawing.color_regs, curr_color_tables[ctable].color_regs,
1789: sizeof colors_for_drawing.color_regs);
1790: color_match_type = color_match_full;
1791: }
1792: }
1793:
1794: static __inline__ void adjust_color0_for_color_change (void)
1795: {
1796: drawing_color_matches = -1;
1797: if (dp_for_drawing->color0 != 0xFFFFFFFFul) {
1798: colors_for_drawing.color_regs[0] = dp_for_drawing->color0;
1799: colors_for_drawing.acolors[0] = xcolors[dp_for_drawing->color0];
1800: }
1801: }
1802:
1803: /* Fetched data spends 9 lores pixels somewhere in the chips before it appears
1804: * on-screen. We don't emulate this. Instead, we cheat with the copper to
1805: * compensate (much easier that way). */
1806: #define COPPER_MAGIC_FUDGE -9
1807:
1808: static __inline__ void do_color_changes (line_draw_func worker)
1809: {
1810: int lastpos = 0, nextpos, i;
1811: struct color_change *cc = curr_color_changes + dip_for_drawing->first_color_change;
1812:
1813: for (i = dip_for_drawing->first_color_change; i <= dip_for_drawing->last_color_change; i++, cc++) {
1814: if (i == dip_for_drawing->last_color_change)
1815: nextpos = max_diwlastword;
1816: else
1817: nextpos = PIXEL_XPOS (cc->linepos) + (COPPER_MAGIC_FUDGE << lores_shift);
1818: worker (lastpos, nextpos);
1819: if (i != dip_for_drawing->last_color_change) {
1820: colors_for_drawing.color_regs[cc->regno] = cc->value;
1821: colors_for_drawing.acolors[cc->regno] = xcolors[cc->value];
1822: }
1823: if (nextpos > lastpos) {
1824: lastpos = nextpos;
1825: if (lastpos >= linetoscr_right_x)
1826: break;
1827: }
1828: }
1829: }
1830:
1831: /* We only save hardware registers during the hardware frame. Now, when
1832: * drawing the frame, we expand the data into a slightly more useful
1833: * form. */
1834: static void pfield_expand_dp_bplcon (void)
1835: {
1836: bplhires = (dp_for_drawing->bplcon0 & 0x8000) == 0x8000;
1837: bplplanecnt = (dp_for_drawing->bplcon0 & 0x7000) >> 12;
1838: bplham = (dp_for_drawing->bplcon0 & 0x800) == 0x800;
1839: #if AGA_CHIPSET == 1 /* The KILLEHB bit exists in ECS, but is apparently meant for Genlock
1840: * stuff, and it's set by some demos (e.g. Andromeda Seven Seas) */
1841: bplehb = ((dp_for_drawing->bplcon0 & 0xFCC0) == 0x6000 && !(dp_for_drawing->bplcon2 & 0x200));
1842: #else
1843: bplehb = (dp_for_drawing->bplcon0 & 0xFC00) == 0x6000;
1844: #endif
1845: bpldelay1 = dp_for_drawing->bplcon1 & 0xF;
1846: bpldelay2 = (dp_for_drawing->bplcon1 >> 4) & 0xF;
1847: plfpri[1] = 1 << 2*(dp_for_drawing->bplcon2 & 7);
1848: plfpri[2] = 1 << 2*((dp_for_drawing->bplcon2 >> 3) & 7);
1849: bpldualpf = (dp_for_drawing->bplcon0 & 0x400) == 0x400;
1850: bpldualpfpri = (dp_for_drawing->bplcon2 & 0x40) == 0x40;
1851: }
1852:
1853: enum double_how {
1854: dh_buf,
1855: dh_line,
1856: dh_emerg
1857: };
1858:
1859: static __inline__ void pfield_draw_line (int lineno, int gfx_ypos, int follow_ypos)
1860: {
1861: int border = 0;
1862: int do_double = 0;
1863: enum double_how dh;
1864:
1865: dp_for_drawing = 0;
1866: dip_for_drawing = 0;
1867: switch (linestate[lineno]) {
1868: case LINE_AS_PREVIOUS:
1869: case LINE_REMEMBERED_AS_PREVIOUS:
1870: {
1871: static int warned = 0;
1872: if (!warned)
1873: write_log ("Shouldn't get here... this is a bug.\n"), warned++;
1874: }
1875: line_decisions[lineno].which = -2;
1876: return;
1877:
1878: case LINE_BORDER_PREV:
1879: border = 1;
1880: dp_for_drawing = line_decisions + lineno - 1;
1881: dip_for_drawing = curr_drawinfo + lineno - 1;
1882: break;
1883:
1884: case LINE_BORDER_NEXT:
1885: border = 1;
1886: dp_for_drawing = line_decisions + lineno + 1;
1887: dip_for_drawing = curr_drawinfo + lineno + 1;
1888: break;
1889:
1890: case LINE_DONE_AS_PREVIOUS:
1891: line_decisions[lineno].which = -2;
1892: /* fall through */
1893: case LINE_DONE:
1894: return;
1895:
1896: case LINE_DECIDED_DOUBLE:
1897: line_decisions[lineno+1].which = -2;
1898: if (follow_ypos != -1) {
1899: do_double = 1;
1900: linetoscr_double_offset = gfxvidinfo.rowbytes * (follow_ypos - gfx_ypos);
1901: }
1902:
1903: /* fall through */
1904: default:
1905: dip_for_drawing = curr_drawinfo + lineno;
1906: dp_for_drawing = line_decisions + lineno;
1907: if (dp_for_drawing->which != 1)
1908: border = 1;
1909: break;
1910: }
1911:
1912: if (!line_changed[lineno] && !frame_redraw_necessary) {
1913: /* The case where we can skip redrawing this line. If this line
1914: * is supposed to be doubled, and the next line is remembered as
1915: * having been doubled, then the next line is done as well. */
1916: if (do_double) {
1917: /* @@@ This is buggy. FIXME */
1918: if (linestate[lineno+1] != LINE_REMEMBERED_AS_PREVIOUS) {
1919: if (gfxvidinfo.linemem == 0)
1920: memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
1921: line_decisions[lineno + 1].which = -2;
1922: do_flush_line (follow_ypos);
1923: }
1924: linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
1925: }
1926: linestate[lineno] = LINE_DONE;
1927: return;
1928: }
1929:
1930: dh = dh_line;
1931: xlinebuffer = gfxvidinfo.linemem;
1932: if (xlinebuffer == 0 && do_double && dip_for_drawing->nr_color_changes != 0)
1933: xlinebuffer = gfxvidinfo.emergmem, dh = dh_emerg;
1934: if (xlinebuffer == 0)
1935: xlinebuffer = row_map[gfx_ypos], dh = dh_buf;
1936: xlinebuffer -= linetoscr_x_adjust_bytes;
1937: aga_lbufptr = aga_linebuf;
1938:
1939: if (!border) {
1940: pfield_expand_dp_bplcon ();
1941:
1942: #ifdef LORES_HACK
1943: if (gfxvidinfo.can_double && !bplhires && !currprefs.gfx_lores
1944: && dip_for_drawing->nr_color_changes == 0 && !bplham)
1945: currprefs.gfx_lores = 2;
1946: #endif
1947: pfield_init_linetoscr ();
1948: if (dip_for_drawing->first_delay_change != dip_for_drawing->last_delay_change) {
1949: bpldelay1 = bpldelay2 = 0;
1950: if (currprefs.gfx_lores)
1951: pfield_doline_l (lineno);
1952: else
1953: pfield_doline_h (lineno);
1954: pfield_adjust_delay ();
1955: } else {
1956: if (currprefs.gfx_lores)
1957: pfield_doline_l (lineno);
1958: else
1959: pfield_doline_h (lineno);
1960: }
1961:
1962: /* Check color0 adjust only if we have color changes - shouldn't happen
1963: * otherwise. */
1964: adjust_drawing_colors (dp_for_drawing->ctable, bplham || bplehb);
1965:
1966: /* The problem is that we must call decode_ham6() BEFORE we do the
1967: * sprites. */
1968: if (bplham) {
1969: init_ham_decoding(linetoscr_x_adjust);
1970: if (dip_for_drawing->nr_color_changes == 0) {
1971: /* The easy case: need to do HAM decoding only once for the
1972: * full line. */
1973: decode_ham6 (linetoscr_x_adjust, linetoscr_right_x);
1974: } else /* Argh. */ {
1975: adjust_color0_for_color_change ();
1976: do_color_changes (decode_ham6);
1977: adjust_drawing_colors (dp_for_drawing->ctable, bplham || bplehb);
1978: }
1979: }
1980:
1981: if (dip_for_drawing->nr_sprites != 0)
1982: walk_sprites (curr_sprite_positions + dip_for_drawing->first_sprite_draw, dip_for_drawing->nr_sprites);
1983:
1984: if (dip_for_drawing->nr_color_changes == 0) {
1985: pfield_do_linetoscr_full (dh == dh_buf ? do_double : 0);
1986: do_flush_line (gfx_ypos);
1987: linestate[lineno] = LINE_DONE;
1988: #if 0
1989: if (dh == dh_emerg)
1990: abort ();
1991: #endif
1992: if (do_double) {
1993: /* If dh == dh_line, do_flush_line will re-use the rendered line
1994: * from linemem. If dh == dh_buf, the line will have been doubled
1995: * by pfield_do_linetoscr_full. */
1996: linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
1997: do_flush_line (follow_ypos);
1998: }
1999: } else {
2000: adjust_color0_for_color_change ();
2001: do_color_changes (pfield_do_linetoscr);
2002:
2003: if (dh == dh_emerg)
2004: memcpy (row_map[gfx_ypos], xlinebuffer + linetoscr_x_adjust_bytes, gfxvidinfo.rowbytes);
2005:
2006: linestate[lineno] = LINE_DONE;
2007: do_flush_line (gfx_ypos);
2008: if (do_double) {
2009: if (dh == dh_emerg)
2010: memcpy (row_map[follow_ypos], xlinebuffer + linetoscr_x_adjust_bytes, gfxvidinfo.rowbytes);
2011: else if (dh == dh_buf)
2012: memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
2013: linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
2014: line_decisions[lineno + 1].which = -2;
2015: do_flush_line (follow_ypos);
2016: }
2017: }
2018: #ifdef LORES_HACK
2019: if (currprefs.gfx_lores == 2)
2020: currprefs.gfx_lores = 0;
2021: #endif
2022: } else { /* Border. */
2023: adjust_drawing_colors (dp_for_drawing->ctable, 0);
2024:
2025: /* Check color0 adjust only if we have color changes - shouldn't happen
2026: * otherwise. */
2027:
2028: if (dip_for_drawing->nr_color_changes == 0) {
2029: fill_line ();
2030: do_flush_line (gfx_ypos);
2031: linestate[lineno] = LINE_DONE;
2032: #if 0
2033: if (dh == dh_emerg)
2034: abort ();
2035: #endif
2036: if (do_double) {
2037: if (dh == dh_buf) {
2038: xlinebuffer = row_map[follow_ypos] - linetoscr_x_adjust_bytes;
2039: fill_line ();
2040: }
2041: /* If dh == dh_line, do_flush_line will re-use the rendered line
2042: * from linemem. */
2043: do_flush_line (follow_ypos);
2044: linestate[lineno+1] = LINE_DONE_AS_PREVIOUS;
2045: }
2046: return;
2047: }
2048:
2049: adjust_color0_for_color_change ();
2050: do_color_changes (pfield_do_fill_line);
2051:
2052: if (dh == dh_emerg)
2053: memcpy (row_map[gfx_ypos], xlinebuffer + linetoscr_x_adjust_bytes, gfxvidinfo.rowbytes);
2054:
2055: do_flush_line (gfx_ypos);
2056: linestate[lineno] = LINE_DONE;
2057: if (do_double) {
2058: if (dh == dh_emerg)
2059: memcpy (row_map[follow_ypos], xlinebuffer + linetoscr_x_adjust_bytes, gfxvidinfo.rowbytes);
2060: else if (dh == dh_buf)
2061: memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
2062: /* If dh == dh_line, do_flush_line will re-use the rendered line
2063: * from linemem. */
2064: do_flush_line (follow_ypos);
2065: linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
2066: line_decisions[lineno + 1].which = -2;
2067: }
2068: }
2069: }
2070:
2071: #ifdef SUPPORT_PENGUINS
2072: static smp_comm_pipe drawing_pipe;
2073: static uae_sem_t drawing_lock;
2074:
2075: static void *drawing_penguin (void *cruxmedo)
2076: {
2077: int l;
2078: fprintf (stderr, "Hello, world!\n");
2079:
2080: for (;;) {
2081: /* Start of a frame. */
2082: int k;
2083: new_frame:
2084: k = read_comm_pipe_int_blocking (&drawing_pipe);
2085:
2086: switch (k) {
2087: case -2:
2088: /* Hoopy */
2089: break;
2090:
2091: default:
2092: write_log ("Penguin got out of sync.\n");
2093: /* what can we do? Try to reduce the damage */
2094: for (;;) {
2095: k = read_comm_pipe_int_blocking (&drawing_pipe);
2096: if (k == -3)
2097: break;
2098: if (k == -1) {
2099: uae_sem_post (&drawing_lock);
2100: goto new_frame;
2101: }
2102: }
2103: case -3:
2104: UAE_PENGUIN_EXIT;
2105: /* Can't happen */
2106: return 0;
2107: }
2108:
2109: for (;;) {
2110: int i, where;
2111: int l = read_comm_pipe_int_blocking (&drawing_pipe);
2112: switch (l) {
2113: case -1:
2114: /* End-of-frame synchronization. */
2115: uae_sem_post (&drawing_lock);
2116: goto new_frame;
2117: case -2:
2118: /* customreset called a bit too often. That's harmless. */
2119: continue;
2120: case -3:
2121: write_log ("Penguin got out of sync.\n");
2122: UAE_PENGUIN_EXIT;
2123: return 0;
2124: }
2125:
2126: /* l is the line that has been finished for drawing. */
2127: i = l - thisframe_y_adjust_real;
2128: if (i < 0 || i >= max_ypos_thisframe)
2129: continue;
2130:
2131: if (linestate[l] == LINE_UNDECIDED) {
2132: fprintf (stderr, "Line scheduled for drawing, but undecided %d!?\n", l);
2133: continue;
2134: }
2135: if (inhibit_frame != 0)
2136: continue;
2137: where = amiga2aspect_line_map[i+min_ypos_for_screen];
2138: if (where >= gfxvidinfo.height || where == -1)
2139: continue;
2140:
2141: pfield_draw_line (l, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
2142: }
2143: }
2144: }
2145:
2146: static penguin_id our_penguin;
2147:
2148: static void kill_drawing_penguin (void)
2149: {
2150: /* ??? does libpthread do that for us? */
2151: }
2152:
2153: #endif
2154:
2155: static int penguins_enabled_thisframe;
2156:
2157: static void center_image (void)
2158: {
2159: prev_x_adjust = linetoscr_x_adjust;
2160: prev_y_adjust = thisframe_y_adjust;
2161:
2162: if (currprefs.gfx_xcenter) {
2163: if (max_diwstop - min_diwstart < gfxvidinfo.width && currprefs.gfx_xcenter == 2)
2164: /* Try to center. */
2165: linetoscr_x_adjust = ((max_diwstop - min_diwstart - gfxvidinfo.width) / 2 + min_diwstart) & ~1;
2166: else
2167: linetoscr_x_adjust = max_diwstop - gfxvidinfo.width;
2168:
2169: /* Would the old value be good enough? If so, leave it as it is if we want to
2170: * be clever. */
2171: if (currprefs.gfx_xcenter == 2) {
2172: if (linetoscr_x_adjust < prev_x_adjust && prev_x_adjust < min_diwstart)
2173: linetoscr_x_adjust = prev_x_adjust;
2174: }
2175: } else
2176: linetoscr_x_adjust = max_diwlastword - gfxvidinfo.width;
2177: if (linetoscr_x_adjust < 0)
2178: linetoscr_x_adjust = 0;
2179:
2180: linetoscr_x_adjust_bytes = linetoscr_x_adjust * gfxvidinfo.pixbytes;
2181:
2182: linetoscr_right_x = linetoscr_x_adjust + gfxvidinfo.width;
2183: if (linetoscr_right_x > max_diwlastword)
2184: linetoscr_right_x = max_diwlastword;
2185:
2186: thisframe_y_adjust = minfirstline;
2187: if (currprefs.gfx_ycenter && thisframe_first_drawn_line != -1) {
2188: if (thisframe_last_drawn_line - thisframe_first_drawn_line < max_drawn_amiga_line && currprefs.gfx_ycenter == 2)
2189: thisframe_y_adjust = (thisframe_last_drawn_line - thisframe_first_drawn_line - max_drawn_amiga_line) / 2 + thisframe_first_drawn_line;
2190: else
2191: thisframe_y_adjust = thisframe_first_drawn_line;
2192: /* Would the old value be good enough? If so, leave it as it is if we want to
2193: * be clever. */
2194: if (currprefs.gfx_ycenter == 2) {
2195: if (thisframe_y_adjust != prev_y_adjust
2196: && prev_y_adjust <= thisframe_first_drawn_line
2197: && prev_y_adjust + max_drawn_amiga_line > thisframe_last_drawn_line)
2198: thisframe_y_adjust = prev_y_adjust;
2199: }
2200: /* Make sure the value makes sense */
2201: if (thisframe_y_adjust + max_drawn_amiga_line > maxvpos)
2202: thisframe_y_adjust = maxvpos - max_drawn_amiga_line;
2203: if (thisframe_y_adjust < minfirstline)
2204: thisframe_y_adjust = minfirstline;
2205: }
2206: thisframe_y_adjust_real = thisframe_y_adjust << (currprefs.gfx_linedbl ? 1 : 0);
2207: max_ypos_thisframe = (maxvpos - thisframe_y_adjust) << (currprefs.gfx_linedbl ? 1 : 0);
2208:
2209: /* @@@ interlace_seen used to be (bplcon0 & 4), but this is probably
2210: * better. */
2211: if (prev_x_adjust != linetoscr_x_adjust || prev_y_adjust != thisframe_y_adjust)
2212: frame_redraw_necessary |= interlace_seen && currprefs.gfx_linedbl ? 2 : 1;
2213:
2214: max_diwstop = 0;
2215: min_diwstart = 10000;
2216: }
2217:
2218: static void init_drawing_frame (void)
2219: {
2220: int i, maxline;
2221:
2222: init_hardware_for_drawing_frame ();
2223:
2224: if (max_diwstop == 0)
2225: max_diwstop = diwlastword;
2226: if (min_diwstart > max_diwstop)
2227: min_diwstart = 0;
2228:
2229: if (thisframe_first_drawn_line == -1)
2230: thisframe_first_drawn_line = minfirstline;
2231: if (thisframe_first_drawn_line > thisframe_last_drawn_line)
2232: thisframe_last_drawn_line = thisframe_first_drawn_line;
2233:
2234: maxline = currprefs.gfx_linedbl ? (maxvpos+1) * 2 + 1 : (maxvpos+1) + 1;
2235: #ifdef SMART_UPDATE
2236: for (i = 0; i < maxline; i++)
2237: linestate[i] = linestate[i] == LINE_DONE_AS_PREVIOUS ? LINE_REMEMBERED_AS_PREVIOUS : LINE_UNDECIDED;
2238: #else
2239: memset (linestate, LINE_UNDECIDED, maxline);
2240: #endif
2241: last_drawn_line = 0;
2242: first_drawn_line = 32767;
2243:
2244: first_block_line = last_block_line = -2;
2245: if (currprefs.test_drawing_speed)
2246: frame_redraw_necessary = 1;
2247: else if (frame_redraw_necessary)
2248: frame_redraw_necessary--;
2249:
2250: center_image ();
2251:
2252: thisframe_first_drawn_line = -1;
2253: thisframe_last_drawn_line = -1;
2254: #ifdef SUPPORT_PENGUINS
2255: penguins_enabled_thisframe = 1;
2256: /* Tell the other thread that it can now expect data from us. */
2257: write_comm_pipe_int (&drawing_pipe, -2, 1);
2258: memset (line_drawn, 0, sizeof line_drawn);
2259: #endif
2260:
2261: drawing_color_matches = -1;
2262: }
2263:
2264: void finish_drawing_frame (void)
2265: {
2266: int i;
2267:
2268: #ifdef SUPPORT_PENGUINS
2269: /* Synchronize with other thread, then see whether there's something left for
2270: * us to draw. @@@ This is probably a big waste of cycles if the two threads
2271: * run at very different speeds - this one could draw stuff as well. */
2272: write_comm_pipe_int (&drawing_pipe, -1, 1);
2273: uae_sem_wait (&drawing_lock);
2274: #else
2275:
2276: #ifndef SMART_UPDATE
2277: /* @@@ This isn't exactly right yet. FIXME */
2278: if (!interlace_seen) {
2279: do_flush_screen (first_drawn_line, last_drawn_line);
2280: return;
2281: }
2282: #endif
2283: if (! lockscr ()) {
2284: notice_screen_contents_lost ();
2285: return;
2286: }
2287: for (i = 0; i < max_ypos_thisframe; i++) {
2288: int where;
2289: int line = i + thisframe_y_adjust_real;
2290:
2291: if (linestate[line] == LINE_UNDECIDED)
2292: break;
2293:
2294: where = amiga2aspect_line_map[i+min_ypos_for_screen];
2295: if (where >= gfxvidinfo.height)
2296: break;
2297: if (where == -1)
2298: continue;
2299:
2300: pfield_draw_line (line, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
2301: }
2302: unlockscr ();
2303: #endif
2304: do_flush_screen (first_drawn_line, last_drawn_line);
2305: }
2306:
2307: void hardware_line_completed (int lineno)
2308: {
2309: #ifdef SUPPORT_PENGUINS
2310: if (framecnt == 0 && penguins_enabled_thisframe) {
2311: write_comm_pipe_int (&drawing_pipe, lineno, 0);
2312: }
2313: #endif
2314: #ifndef SMART_UPDATE
2315: {
2316: int i, where;
2317: /* l is the line that has been finished for drawing. */
2318: i = lineno - thisframe_y_adjust_real;
2319: if (i >= 0 && i < max_ypos_thisframe) {
2320: where = amiga2aspect_line_map[i+min_ypos_for_screen];
2321: if (where < gfxvidinfo.height && where != -1)
2322: pfield_draw_line (lineno, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
2323: }
2324: }
2325: #endif
2326: }
2327:
2328: static __inline__ void check_picasso (void)
2329: {
2330: #ifdef PICASSO96
2331: if (picasso_on && picasso_redraw_necessary)
2332: picasso_refresh ();
2333: picasso_redraw_necessary = 0;
2334:
2335: if (picasso_requested_on == picasso_on)
2336: return;
2337:
2338: picasso_on = picasso_requested_on;
2339:
2340: if (!picasso_on)
2341: clear_inhibit_frame (2);
2342: else
2343: set_inhibit_frame (2);
2344:
2345: gfx_set_picasso_state (picasso_on);
2346: picasso_enablescreen (picasso_requested_on);
2347:
2348: notice_screen_contents_lost ();
2349: notice_new_xcolors ();
2350: #endif
2351: }
2352:
2353: void vsync_handle_redraw (int long_frame, int lof_changed)
2354: {
2355: last_redraw_point++;
2356: if (lof_changed || ! interlace_seen || last_redraw_point >= 2 || long_frame) {
2357: last_redraw_point = 0;
2358: interlace_seen = 0;
2359:
2360: if (framecnt == 0)
2361: finish_drawing_frame ();
2362:
2363: /* At this point, we have finished both the hardware and the
2364: * drawing frame. Essentially, we are outside of all loops and
2365: * can do some things which would cause confusion if they were
2366: * done at other times.
2367: */
2368:
2369: if (quit_program < 0) {
2370: quit_program = -quit_program;
2371: set_inhibit_frame (1);
2372: regs.spcflags |= SPCFLAG_BRK;
2373: filesys_prepare_reset ();
2374: #ifdef SUPPORT_PENGUINS
2375: if (quit_program == 1)
2376: /* Stop eating herring */
2377: write_comm_pipe_int (&drawing_pipe, -3, 1);
2378: #endif
2379: return;
2380: }
2381:
2382: count_frame ();
2383: check_picasso ();
2384:
2385: check_prefs_changed_custom ();
2386: check_prefs_changed_cpu ();
2387: if (check_prefs_changed_gfx ()) {
2388: init_row_map ();
2389: init_aspect_maps ();
2390: notice_screen_contents_lost ();
2391: notice_new_xcolors ();
2392: }
2393:
2394: if (inhibit_frame != 0)
2395: framecnt = 1;
2396:
2397: if (framecnt == 0)
2398: init_drawing_frame ();
2399: }
2400: }
2401:
2402: void hsync_record_line_state (int lineno, enum nln_how how)
2403: {
2404: if (framecnt != 0)
2405: return;
2406: switch (how) {
2407: case nln_normal:
2408: linestate[lineno] = LINE_DECIDED;
2409: break;
2410: case nln_doubled:
2411: linestate[lineno] = LINE_DECIDED_DOUBLE;
2412: if (linestate[lineno+1] != LINE_REMEMBERED_AS_PREVIOUS)
2413: linestate[lineno+1] = LINE_AS_PREVIOUS;
2414: break;
2415: case nln_lower:
2416: if (linestate[lineno-1] == LINE_UNDECIDED)
2417: linestate[lineno-1] = LINE_BORDER_NEXT;
2418: linestate[lineno] = LINE_DECIDED;
2419: break;
2420: case nln_upper:
2421: linestate[lineno] = LINE_DECIDED;
2422: if (linestate[lineno+1] == LINE_UNDECIDED
2423: || linestate[lineno+1] == LINE_REMEMBERED_AS_PREVIOUS
2424: || linestate[lineno+1] == LINE_AS_PREVIOUS)
2425: linestate[lineno+1] = LINE_BORDER_PREV;
2426: break;
2427: }
2428: }
2429:
2430: void notice_interlace_seen (void)
2431: {
2432: interlace_seen = 1;
2433: penguins_enabled_thisframe = 0;
2434: }
2435:
2436: void reset_drawing (void)
2437: {
2438: int i;
2439:
2440: inhibit_frame = 0;
2441: uae_sem_init (&gui_sem, 0, 1);
2442:
2443: #ifdef PICASSO96
2444: InitPicasso96 ();
2445: picasso_on = 0;
2446: picasso_requested_on = 0;
2447: gfx_set_picasso_state (0);
2448: #endif
2449: max_diwstop = 0;
2450:
2451: lores_factor = currprefs.gfx_lores ? 1 : 2;
2452: lores_shift = currprefs.gfx_lores ? 0 : 1;
2453: sprite_width = currprefs.gfx_lores ? 16 : 32;
2454:
2455: /*memset(blitcount, 0, sizeof(blitcount)); blitter debug */
2456: for (i = 0; i < sizeof linestate / sizeof *linestate; i++)
2457: linestate[i] = LINE_UNDECIDED;
2458:
2459: xlinebuffer = gfxvidinfo.bufmem;
2460:
2461: init_aspect_maps ();
2462:
2463: if (line_drawn == 0)
2464: line_drawn = (char *)malloc (gfxvidinfo.height);
2465:
2466: init_row_map();
2467:
2468: last_redraw_point = 0;
2469:
2470: init_drawing_frame ();
2471: }
2472:
2473: void drawing_init ()
2474: {
2475: native2amiga_line_map = 0;
2476: amiga2aspect_line_map = 0;
2477: line_drawn = 0;
2478:
2479: gen_pfield_tables();
2480:
2481: #ifdef SUPPORT_PENGUINS
2482: init_comm_pipe (&drawing_pipe, 800, 5);
2483: uae_sem_init (&drawing_lock, 0, 0);
2484: start_penguin (drawing_penguin, 0, &our_penguin);
2485: /*atexit(kill_drawing_penguin);*/
2486: #endif
2487: }
2488:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.