![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to picasso96.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 picasso96.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The U*nix Amiga Emulator
3: *
4: * Picasso96 Support Module
5: *
6: * Copyright 1997 Brian King <[email protected], [email protected]>
7: *
8: * Theory of operation:
9: * On the Amiga side, a Picasso card consists mainly of a memory area that
10: * contains the frame buffer. On the UAE side, we allocate a block of memory
11: * that will hold the frame buffer. This block is in normal memory, it is
12: * never directly on the graphics card. All graphics operations, which are
13: * mainly reads and writes into this block and a few basic operations like
14: * filling a rectangle, operate on this block of memory.
15: * Since the memory is not on the graphics card, some work must be done to
16: * synchronize the display with the data in the Picasso frame buffer. There
17: * are various ways to do this. One possibility is to allocate a second
18: * buffer of the same size, and perform all write operations twice. Since
19: * we never read from the second buffer, it can actually be placed in video
20: * memory. The X11 driver could be made to use the Picasso frame buffer as
21: * the data buffer of an XImage, which could then be XPutImage()d from time
22: * to time. Another possibility is to translate all Picasso accesses into
23: * Xlib (or GDI, or whatever your graphics system is) calls. This possibility
24: * is a bit tricky, since there is a risk of generating very many single pixel
25: * accesses which may be rather slow.
26: *
27: * TODO:
28: * - add an 8 bit emulation for hicolor/truecolor screens. This would allow
29: * users to select an 8 bit Workbench resolution that would work regardless
30: * of which color depth the display is currently in.
31: * - add panning capability
32: */
33:
34: #include "sysconfig.h"
35: #include "sysdeps.h"
36:
37: #include "config.h"
38: #include "options.h"
39: #include "threaddep/penguin.h"
40: #include "uae.h"
41: #include "memory.h"
42: #include "custom.h"
43: #include "readcpu.h"
44: #include "newcpu.h"
45: #include "xwin.h"
46: #include "picasso96.h"
47:
48: #ifdef PICASSO96
49:
50: extern uae_u8 *lockscr (void);
51: extern void unlockscr (void);
52:
53: #define MyOutputDebugString printf
54:
55: static uae_u32 gfxmem_lget (uaecptr) REGPARAM;
56: static uae_u32 gfxmem_wget (uaecptr) REGPARAM;
57: static uae_u32 gfxmem_bget (uaecptr) REGPARAM;
58: static void gfxmem_lput (uaecptr, uae_u32) REGPARAM;
59: static void gfxmem_wput (uaecptr, uae_u32) REGPARAM;
60: static void gfxmem_bput (uaecptr, uae_u32) REGPARAM;
61: static int gfxmem_check (uaecptr addr, uae_u32 size) REGPARAM;
62: static uae_u8 *gfxmem_xlate (uaecptr addr) REGPARAM;
63:
64: static void write_gfx_long (uaecptr addr, uae_u32 value);
65: static void write_gfx_word (uaecptr addr, uae_u16 value);
66: static void write_gfx_byte (uaecptr addr, uae_u8 value);
67:
68: static uae_u8 all_ones_bitmap, all_zeros_bitmap; /* yuk */
69:
70: struct picasso96_state_struct picasso96_state;
71: struct picasso_vidbuf_description picasso_vidinfo;
72:
73: /* These are the maximum resolutions... They are filled in by GetSupportedResolutions() */
74: /* have to fill this in, otherwise problems occur
75: * @@@ ??? what problems?
76: */
77: struct ScreenResolution planar = { 320, 240 };
78: struct ScreenResolution chunky = { 640, 480 };
79: struct ScreenResolution hicolour = { 640, 480 };
80: struct ScreenResolution truecolour = { 640, 480 };
81: struct ScreenResolution alphacolour = { 460, 480 };
82:
83: uae_u16 picasso96_pixel_format = RGBFF_CHUNKY;
84:
85: struct PicassoResolution DisplayModes[MAX_PICASSO_MODES];
86:
87: static int mode_count = 0;
88:
89: static uae_u32 p2ctab[256][2];
90:
91: /*
92: * Debugging dumps
93: */
94:
95: static void DumpModeInfoStructure (uaecptr amigamodeinfoptr)
96: {
97: int i;
98: MyOutputDebugString ("ModeInfo Structure Dump:\n");
99: MyOutputDebugString (" Node.ln_Succ = 0x%x\n", get_long (amigamodeinfoptr));
100: MyOutputDebugString (" Node.ln_Pred = 0x%x\n", get_long (amigamodeinfoptr + 4));
101: MyOutputDebugString (" Node.ln_Type = 0x%x\n", get_byte (amigamodeinfoptr + 8));
102: MyOutputDebugString (" Node.ln_Pri = %d\n", get_byte (amigamodeinfoptr + 9));
103: /*MyOutputDebugString (" Node.ln_Name = %s\n", uaememptr->Node.ln_Name); */
104: MyOutputDebugString (" OpenCount = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_OpenCount));
105: MyOutputDebugString (" Active = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_Active));
106: MyOutputDebugString (" Width = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_Width));
107: MyOutputDebugString (" Height = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_Height));
108: MyOutputDebugString (" Depth = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_Depth));
109: MyOutputDebugString (" Flags = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_Flags));
110: MyOutputDebugString (" HorTotal = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_HorTotal));
111: MyOutputDebugString (" HorBlankSize = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_HorBlankSize));
112: MyOutputDebugString (" HorSyncStart = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_HorSyncStart));
113: MyOutputDebugString (" HorSyncSize = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_HorSyncSize));
114: MyOutputDebugString (" HorSyncSkew = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_HorSyncSkew));
115: MyOutputDebugString (" HorEnableSkew = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_HorEnableSkew));
116: MyOutputDebugString (" VerTotal = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_VerTotal));
117: MyOutputDebugString (" VerBlankSize = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_VerBlankSize));
118: MyOutputDebugString (" VerSyncStart = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_VerSyncStart));
119: MyOutputDebugString (" VerSyncSize = %d\n", get_word (amigamodeinfoptr + PSSO_ModeInfo_VerSyncSize));
120: MyOutputDebugString (" Clock = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_first_union));
121: MyOutputDebugString (" ClockDivide = %d\n", get_byte (amigamodeinfoptr + PSSO_ModeInfo_second_union));
122: MyOutputDebugString (" PixelClock = %d\n", get_long (amigamodeinfoptr + PSSO_ModeInfo_PixelClock));
123: }
124:
125: static void DumpLibResolutionStructure (uaecptr amigalibresptr)
126: {
127: int i;
128: uaecptr amigamodeinfoptr;
129: struct LibResolution *uaememptr = (struct LibResolution *)get_mem_bank(amigalibresptr).xlateaddr(amigalibresptr);
130:
131: return;
132:
133: MyOutputDebugString ("LibResolution Structure Dump:\n");
134:
135: if (get_long (amigalibresptr + PSSO_LibResolution_DisplayID) == 0xFFFFFFFF) {
136: MyOutputDebugString (" Finished With LibResolutions...\n");
137: } else {
138: MyOutputDebugString (" Name = %s\n", uaememptr->P96ID);
139: MyOutputDebugString (" DisplayID = 0x%x\n", get_long (amigalibresptr + PSSO_LibResolution_DisplayID));
140: MyOutputDebugString (" Width = %d\n", get_word (amigalibresptr + PSSO_LibResolution_Width));
141: MyOutputDebugString (" Height = %d\n", get_word (amigalibresptr + PSSO_LibResolution_Height));
142: MyOutputDebugString (" Flags = %d\n", get_word (amigalibresptr + PSSO_LibResolution_Flags));
143: for (i = 0; i < MAXMODES; i++) {
144: amigamodeinfoptr = get_long (amigalibresptr + PSSO_LibResolution_Modes + i*4);
145: MyOutputDebugString (" ModeInfo[%d] = 0x%x\n", i, amigamodeinfoptr);
146: if (amigamodeinfoptr)
147: DumpModeInfoStructure(amigamodeinfoptr);
148: }
149: MyOutputDebugString (" BoardInfo = 0x%x\n", get_long (amigalibresptr + PSSO_LibResolution_BoardInfo));
150: }
151: }
152:
153: static char binary_byte[8];
154:
155: static char *BuildBinaryString (uae_u8 value)
156: {
157: int i;
158: for (i = 0; i < 8; i++) {
159: binary_byte[i] = (value & (1 << (7 - i))) ? '#' : '.';
160: }
161: return binary_byte;
162: }
163:
164: static void DumpPattern (struct Pattern *patt)
165: {
166: uae_u8 *mem;
167: int row, col;
168: for (row = 0; row < (1 << patt->Size); row++) {
169: mem = patt->Memory + row * 2;
170: for (col = 0; col < 2; col++) {
171: MyOutputDebugString ("%s", BuildBinaryString (*mem++));
172: }
173: MyOutputDebugString ("\n");
174: }
175: }
176:
177: static void DumpTemplate (struct Template *tmp, uae_u16 w, uae_u16 h)
178: {
179: uae_u8 *mem = tmp->Memory;
180: int row, col, width;
181: width = (w + 7) >> 3;
182: MyOutputDebugString ("xoffset = %d, bpr = %d\n", tmp->XOffset, tmp->BytesPerRow);
183: for (row = 0; row < h; row++) {
184: mem = tmp->Memory + row * tmp->BytesPerRow;
185: for (col = 0; col < width; col++) {
186: MyOutputDebugString ("%s", BuildBinaryString (*mem++));
187: }
188: MyOutputDebugString ("\n");
189: }
190: }
191:
192: static void ShowSupportedResolutions (void)
193: {
194: int i;
195:
196: return;
197:
198: for (i = 0; i < mode_count; i++)
199: MyOutputDebugString ("%s\n", DisplayModes[i].name);
200: }
201:
202: /*
203: * Amiga <-> native structure conversion functions
204: */
205:
206: static int CopyRenderInfoStructureA2U (uaecptr amigamemptr, struct RenderInfo *ri)
207: {
208: uaecptr memp = get_long (amigamemptr + PSSO_RenderInfo_Memory);
209:
210: if (valid_address (memp, 1 /* FIXME */)) {
211: ri->Memory = get_real_address (memp);
212: ri->BytesPerRow = get_word (amigamemptr + PSSO_RenderInfo_BytesPerRow);
213: ri->RGBFormat = get_long (amigamemptr + PSSO_RenderInfo_RGBFormat);
214: return 1;
215: }
216: MyOutputDebugString ("ERROR - Invalid RenderInfo memory area...\n");
217: return 0;
218: }
219:
220: static int CopyPatternStructureA2U (uaecptr amigamemptr, struct Pattern *pattern)
221: {
222: uaecptr memp = get_long (amigamemptr + PSSO_Pattern_Memory);
223: if (valid_address (memp, 1 /* FIXME */)) {
224: pattern->Memory = get_real_address (memp);
225: pattern->XOffset = get_word (amigamemptr + PSSO_Pattern_XOffset);
226: pattern->YOffset = get_word (amigamemptr + PSSO_Pattern_YOffset);
227: pattern->FgPen = get_long (amigamemptr + PSSO_Pattern_FgPen);
228: pattern->BgPen = get_long (amigamemptr + PSSO_Pattern_BgPen);
229: pattern->Size = get_byte (amigamemptr + PSSO_Pattern_Size);
230: pattern->DrawMode = get_byte (amigamemptr + PSSO_Pattern_DrawMode);
231: return 1;
232: }
233: MyOutputDebugString ("ERROR - Invalid Pattern memory area...\n");
234: return 0;
235: }
236:
237: static void CopyColorIndexMappingA2U (uaecptr amigamemptr, struct ColorIndexMapping *cim)
238: {
239: int i;
240: cim->ColorMask = get_long (amigamemptr);
241: for (i = 0; i < 256; i++, amigamemptr += 4)
242: cim->Colors[i] = get_long (amigamemptr + 4);
243: }
244:
245: static int CopyBitMapStructureA2U (uaecptr amigamemptr, struct BitMap *bm)
246: {
247: int i;
248:
249: bm->BytesPerRow = get_word (amigamemptr + PSSO_BitMap_BytesPerRow);
250: bm->Rows = get_word (amigamemptr + PSSO_BitMap_Rows);
251: bm->Flags = get_byte (amigamemptr + PSSO_BitMap_Flags);
252: bm->Depth = get_byte (amigamemptr + PSSO_BitMap_Depth);
253:
254: for (i = 0; i < bm->Depth; i++) {
255: uaecptr plane = get_long (amigamemptr + PSSO_BitMap_Planes + i*4);
256: switch (plane) {
257: case 0:
258: bm->Planes[i] = &all_zeros_bitmap;
259: break;
260: case 0xFFFFFFFF:
261: bm->Planes[i] = &all_ones_bitmap;
262: break;
263: default:
264: if (valid_address (plane, bm->BytesPerRow * bm->Rows))
265: bm->Planes[i] = get_real_address (plane);
266: else
267: return 0;
268: break;
269: }
270: }
271: return 1;
272: }
273:
274: static int CopyTemplateStructureA2U (uaecptr amigamemptr, struct Template *tmpl)
275: {
276: uaecptr memp = get_long (amigamemptr + PSSO_Template_Memory);
277:
278: if (valid_address (memp, 1 /* FIXME */)) {
279: tmpl->Memory = get_real_address (memp);
280: tmpl->BytesPerRow = get_word (amigamemptr + PSSO_Template_BytesPerRow);
281: tmpl->XOffset = get_byte (amigamemptr + PSSO_Template_XOffset);
282: tmpl->DrawMode = get_byte (amigamemptr + PSSO_Template_DrawMode);
283: tmpl->FgPen = get_long (amigamemptr + PSSO_Template_FgPen);
284: tmpl->BgPen = get_long (amigamemptr + PSSO_Template_BgPen);
285: return 1;
286: }
287: MyOutputDebugString ("ERROR - Invalid Template memory area...\n");
288: return 0;
289: }
290:
291: static void CopyLibResolutionStructureU2A (struct LibResolution *libres, uaecptr amigamemptr)
292: {
293: char *uaememptr = 0;
294: int i;
295:
296: uaememptr = gfxmem_xlate(amigamemptr); /* I know that amigamemptr is inside my gfxmem chunk, so I can just do the xlate() */
297: memset(uaememptr, 0, PSSO_LibResolution_sizeof); /* zero out our LibResolution structure */
298: strcpy(uaememptr + PSSO_LibResolution_P96ID, libres->P96ID);
299: put_long(amigamemptr + PSSO_LibResolution_DisplayID, libres->DisplayID);
300: put_word(amigamemptr + PSSO_LibResolution_Width, libres->Width);
301: put_word(amigamemptr + PSSO_LibResolution_Height, libres->Height);
302: put_word(amigamemptr + PSSO_LibResolution_Flags, libres->Flags);
303: for (i = 0; i < MAXMODES; i++)
304: put_long(amigamemptr + PSSO_LibResolution_Modes + i*4, libres->Modes[i]);
305: #if 0
306: put_long(amigamemptr, libres->Node.ln_Succ);
307: put_long(amigamemptr + 4, libres->Node.ln_Pred);
308: put_byte(amigamemptr + 8, libres->Node.ln_Type);
309: put_byte(amigamemptr + 9, libres->Node.ln_Pri);
310: #endif
311: put_long(amigamemptr + 10, amigamemptr + PSSO_LibResolution_P96ID);
312: put_long(amigamemptr + PSSO_LibResolution_BoardInfo, libres->BoardInfo);
313: }
314:
315: /* list is Amiga address of list, in correct endian format for UAE
316: * node is Amiga address of node, in correct endian format for UAE */
317: static void AmigaListAddTail (uaecptr list, uaecptr node)
318: {
319: uaecptr amigamemptr = 0;
320:
321: if (get_long (list + 8) == list) {
322: /* Empty list - set it up */
323: put_long(list, node); /* point the lh_Head to our new node */
324: put_long(list + 4, 0); /* set the lh_Tail to NULL */
325: put_long(list + 8, node); /* point the lh_TailPred to our new node */
326:
327: /* Adjust the new node - don't rely on it being zeroed out */
328: put_long(node, 0); /* ln_Succ */
329: put_long(node + 4, 0); /* ln_Pred */
330: } else {
331: amigamemptr = get_long (list + 8); /* get the lh_TailPred contents */
332:
333: put_long(list + 8, node); /* point the lh_TailPred to our new node */
334:
335: /* Adjust the previous lh_TailPred node */
336: put_long(amigamemptr, node); /* point the ln_Succ to our new node */
337:
338: /* Adjust the new node - don't rely on it being zeroed out */
339: put_long(node, 0); /* ln_Succ */
340: put_long(node + 4, amigamemptr); /* ln_Pred */
341: }
342: }
343:
344: /*
345: * Functions to perform an action on the real screen
346: */
347:
348: /*
349: * Fill a rectangle on the screen. src points to the start of a line of the
350: * filled rectangle in the frame buffer; it can be used as a memcpy source if
351: * there is no OS specific function to fill the rectangle.
352: */
353:
354: static void do_fillrect (uae_u8 *src, int x, int y, int width, int height)
355: {
356: int lines;
357: uae_u8 *dst;
358: /* Try OS specific fillrect function here; and return if successful. */
359:
360: DX_Invalidate (y, y + height - 1);
361: if (! picasso_vidinfo.extra_mem)
362: return;
363:
364: width *= picasso96_state.BytesPerPixel;
365: dst = lockscr ();
366: if (!dst)
367: return;
368:
369: dst += y*picasso_vidinfo.rowbytes + x*picasso96_state.BytesPerPixel;
370: while (height-- > 0) {
371: memcpy (dst, src, width);
372: dst += picasso_vidinfo.rowbytes;
373: }
374: unlockscr ();
375: }
376:
377: /*
378: * This routine modifies the real screen buffer after a blit has been
379: * performed in the save area. If can_do_blit is nonzero, the blit can
380: * be performed within the real screen buffer; otherwise, this routine
381: * must do it by hand using the data in the save area, pointed to by
382: * srcp.
383: */
384:
385: static void do_blit (uae_u8 *srcp, unsigned long src_rowbytes,
386: int srcx, int srcy, int dstx, int dsty,
387: int width, int height, int can_do_blit)
388: {
389: uae_u8 *dstp;
390: /* If this RenderInfo points at something else than the currently visible
391: * screen, we must ignore the blit. */
392: if (can_do_blit) {
393: /*
394: * Call OS blitting function that can do it in video memory.
395: * Should return if it was successful
396: */
397: }
398:
399: DX_Invalidate (dsty, dsty + height - 1);
400: if (! picasso_vidinfo.extra_mem)
401: return;
402:
403: width *= picasso96_state.BytesPerPixel;
404: dstp = lockscr ();
405: if (dstp == 0)
406: return;
407:
408: /* The areas can't overlap: the source is always in the Picasso frame buffer,
409: * and the destination is a different buffer owned by the graphics code. */
410:
411: dstp += dsty * picasso_vidinfo.rowbytes + dstx * picasso96_state.BytesPerPixel;
412: while (height-- > 0) {
413: memcpy (dstp, srcp, width);
414: srcp += src_rowbytes;
415: dstp += picasso_vidinfo.rowbytes;
416: }
417: unlockscr ();
418: }
419:
420: /*
421: * Invert a rectangle on the screen. src and src_rowbytes describe the
422: * inverted rectangle in the frame buffer, so that do_blit can be used if
423: * there is no OS specific function to fill the rectangle.
424: */
425:
426: static void do_invertrect (uae_u8 *src, unsigned long src_rowbytes,
427: int x, int y, int width, int height)
428: {
429: /* Try OS specific invertrect function here; and return if successful. */
430:
431: do_blit (src, src_rowbytes, 0, 0, x, y, width, height, 0);
432: }
433:
434: static uaecptr wgfx_linestart;
435: static uaecptr wgfx_lineend;
436: static uaecptr wgfx_min, wgfx_max;
437: static unsigned long wgfx_y;
438:
439: static void wgfx_do_flushline (void)
440: {
441: uae_u8 *src, *dstp;
442:
443: DX_Invalidate (wgfx_y, wgfx_y);
444: if (! picasso_vidinfo.extra_mem)
445: goto out;
446:
447: dstp = lockscr ();
448: if (dstp == 0)
449: goto out;
450: /*printf("flushing %d (%x %x %x)\n", wgfx_y, wgfx_linestart, wgfx_min, wgfx_max); */
451: src = (gfxmemory + wgfx_min);
452:
453: dstp += wgfx_y * picasso_vidinfo.rowbytes + wgfx_min - wgfx_linestart;
454: memcpy (dstp, src, wgfx_max - wgfx_min);
455: unlockscr ();
456:
457: out:
458: wgfx_linestart = 0xFFFFFFFF;
459: }
460:
461: static __inline__ void wgfx_flushline (void)
462: {
463: if (wgfx_linestart == 0xFFFFFFFF)
464: return;
465: wgfx_do_flushline ();
466: }
467:
468:
469: static int renderinfo_is_current_screen (struct RenderInfo *ri)
470: {
471: if (! picasso_on)
472: return 0;
473: if (ri->Memory != gfxmemory + (picasso96_state.Address - gfxmem_start)) {
474: return 0;
475: }
476: return 1;
477: }
478:
479: /* Clear our screen, since we've got a new Picasso screen-mode, and refresh with the proper contents
480: * NOTE: This is called in two cases:
481: * 1. Amiga-->Picasso transition, via SetSwitch()
482: * 2. Picasso-->Picasso transition, via SetPanning(). */
483: static void picasso_refresh (void)
484: {
485: struct RenderInfo ri;
486:
487: if (! picasso_on)
488: return;
489:
490: /* Make sure that the first time we show a Picasso video mode, we don't blit any crap.
491: * We can do this by checking if we have an Address yet. */
492: if (picasso96_state.Address) {
493: /* blit the stuff from our static frame-buffer to the gfx-card */
494: uae_u8 *ptr = gfxmemory + (picasso96_state.Address - gfxmem_start);
495: ri.BytesPerRow = picasso96_state.BytesPerRow;
496: ri.RGBFormat = picasso96_state.RGBFormat;
497: do_blit (ptr, picasso96_state.BytesPerRow, 0, 0, 0, 0,
498: picasso96_state.Width, picasso96_state.Height, 0);
499: MyOutputDebugString ("picasso_refresh() successful.\n");
500: } else
501: MyOutputDebugString ("ERROR - picasso_refresh() can't refresh!\n");
502: }
503:
504: /*
505: * BOOL FindCard(struct BoardInfo *bi); and
506: *
507: * FindCard is called in the first stage of the board initialisation and
508: * configuration and is used to look if there is a free and unconfigured
509: * board of the type the driver is capable of managing. If it finds one,
510: * it immediately reserves it for use by Picasso96, usually by clearing
511: * the CDB_CONFIGME bit in the flags field of the ConfigDev struct of
512: * this expansion card. But this is only a common example, a driver can
513: * do whatever it wants to mark this card as used by the driver. This
514: * mechanism is intended to ensure that a board is only configured and
515: * used by one driver. FindBoard also usually fills some fields of the
516: * BoardInfo struct supplied by the caller, the rtg.library, for example
517: * the MemoryBase, MemorySize and RegisterBase fields.
518: */
519: uae_u32 picasso_FindCard (void)
520: {
521: int loop;
522: uaecptr AmigaBoardInfo = m68k_areg(regs, 0);
523: /* NOTES: See BoardInfo struct definition in Picasso96 dev info */
524:
525: if (gfxmem_size && !picasso96_state.CardFound) {
526: /* Fill in MemoryBase, MemorySize */
527: put_long(AmigaBoardInfo + PSSO_BoardInfo_MemoryBase, gfxmem_start);
528: /* size of memory, minus a 32K chunk: 16K for pattern bitmaps, 16K for resolution list */
529: put_long(AmigaBoardInfo + PSSO_BoardInfo_MemorySize, gfxmem_size - 32768);
530:
531: picasso96_state.CardFound = 1; /* mark our "card" as being found */
532: return -1;
533: } else
534: return 0;
535: }
536:
537: static void FillBoardInfo (uaecptr amigamemptr, struct LibResolution *res, struct PicassoResolution *dm)
538: {
539: char *uaememptr;
540: switch (dm->depth) {
541: case 1:
542: res->Modes[CHUNKY] = amigamemptr;
543: break;
544: case 2:
545: res->Modes[HICOLOR] = amigamemptr;
546: break;
547: case 3:
548: res->Modes[TRUECOLOR] = amigamemptr;
549: break;
550: default:
551: res->Modes[TRUEALPHA] = amigamemptr;
552: break;
553: }
554: uaememptr = gfxmem_xlate(amigamemptr); /* I know that amigamemptr is inside my gfxmem chunk, so I can just do the xlate() */
555: memset(uaememptr, 0, PSSO_ModeInfo_sizeof); /* zero out our ModeInfo struct */
556:
557: put_word(amigamemptr + PSSO_ModeInfo_Width, dm->res.width);
558: put_word(amigamemptr + PSSO_ModeInfo_Height, dm->res.height);
559: put_byte(amigamemptr + PSSO_ModeInfo_Depth, dm->depth * 8);
560: put_byte(amigamemptr + PSSO_ModeInfo_Flags, 0);
561: put_word(amigamemptr + PSSO_ModeInfo_HorTotal, dm->res.width);
562: put_word(amigamemptr + PSSO_ModeInfo_HorBlankSize, 0);
563: put_word(amigamemptr + PSSO_ModeInfo_HorSyncStart, 0);
564: put_word(amigamemptr + PSSO_ModeInfo_HorSyncSize, 0);
565: put_byte(amigamemptr + PSSO_ModeInfo_HorSyncSkew, 0);
566: put_byte(amigamemptr + PSSO_ModeInfo_HorEnableSkew, 0);
567:
568: put_word(amigamemptr + PSSO_ModeInfo_VerTotal, dm->res.height);
569: put_word(amigamemptr + PSSO_ModeInfo_VerBlankSize, 0);
570: put_word(amigamemptr + PSSO_ModeInfo_VerSyncStart, 0);
571: put_word(amigamemptr + PSSO_ModeInfo_VerSyncSize, 0);
572:
573: put_byte(amigamemptr + PSSO_ModeInfo_first_union, 98);
574: put_byte(amigamemptr + PSSO_ModeInfo_second_union, 14);
575:
576: put_long(amigamemptr + PSSO_ModeInfo_PixelClock, dm->res.width * dm->res.height * dm->refresh);
577: }
578:
579: /****************************************
580: * InitCard()
581: *
582: * a2: BoardInfo structure ptr - Amiga-based address in Intel endian-format
583: *
584: * Job - fill in the following structure members:
585: * gbi_RGBFormats: the pixel formats that the host-OS of UAE supports
586: * If UAE is running in a window, it should ONLY report the pixel format of the host-OS desktop
587: * If UAE is running full-screen, it should report ALL pixel formats that the host-OS can handle in full-screen
588: * NOTE: If full-screen, and the user toggles to windowed-mode, all hell will break loose visually. Must inform
589: * user that they're doing something stupid (unless their desktop and full-screen colour modes match).
590: * gbi_SoftSpriteFlags: should be the same as above for now, until actual cursor support is added
591: * gbi_BitsPerCannon: could be 6 or 8 or ???, depending on the host-OS gfx-card
592: * gbi_MaxHorResolution: fill this in for all modes (even if you don't support them)
593: * gbi_MaxVerResolution: fill this in for all modes (even if you don't support them)
594: */
595: uae_u32 picasso_InitCard (void)
596: {
597: struct LibResolution res;
598: int i;
599: int ModeInfoStructureCount = 1, LibResolutionStructureCount = 0;
600: uaecptr amigamemptr = 0;
601: uaecptr AmigaBoardInfo = m68k_areg(regs, 2);
602: put_word(AmigaBoardInfo + PSSO_BoardInfo_BitsPerCannon, DX_BitsPerCannon());
603: put_word(AmigaBoardInfo + PSSO_BoardInfo_RGBFormats, picasso96_pixel_format);
604: put_word(AmigaBoardInfo + PSSO_BoardInfo_SoftSpriteFlags, picasso96_pixel_format);
605: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 0, planar.width);
606: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 2, chunky.width);
607: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 4, hicolour.width);
608: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 6, truecolour.width);
609: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 8, alphacolour.width);
610: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 0, planar.height);
611: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 2, chunky.height);
612: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 4, hicolour.height);
613: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 6, truecolour.height);
614: put_word(AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 8, alphacolour.height);
615:
616: for (i = 0; i < mode_count;) {
617: int j = i;
618: /* Add a LibResolution structure to the ResolutionsList MinList in our BoardInfo */
619: res.DisplayID = 0x50001000 + LibResolutionStructureCount * 0x10000;
620: res.BoardInfo = AmigaBoardInfo;
621: res.Width = DisplayModes[i].res.width;
622: res.Height = DisplayModes[i].res.height;
623: res.Flags = P96F_PUBLIC;
624: res.P96ID[0] = 'P';
625: res.P96ID[1] = '9';
626: res.P96ID[2] = '6';
627: res.P96ID[3] = '-';
628: res.P96ID[4] = '0';
629: res.P96ID[5] = ':';
630: strcpy (res.Name, "uaegfx:");
631: strncat (res.Name, DisplayModes[i].name, strchr(DisplayModes[i].name, ',') - DisplayModes[i].name);
632: res.Modes[PLANAR] = 0;
633: res.Modes[CHUNKY] = 0;
634: res.Modes[HICOLOR] = 0;
635: res.Modes[TRUECOLOR] = 0;
636: res.Modes[TRUEALPHA] = 0;
637:
638: do {
639: /* Handle this display mode's depth */
640: amigamemptr = gfxmem_start + gfxmem_size - (PSSO_ModeInfo_sizeof * ModeInfoStructureCount++);
641: FillBoardInfo(amigamemptr, &res, &DisplayModes[i]);
642: i++;
643: } while (i < mode_count
644: && DisplayModes[i].res.width == DisplayModes[j].res.width
645: && DisplayModes[i].res.height == DisplayModes[j].res.height);
646:
647: amigamemptr = gfxmem_start + gfxmem_size - 16384 + (PSSO_LibResolution_sizeof * LibResolutionStructureCount++);
648: CopyLibResolutionStructureU2A (&res, amigamemptr);
649: DumpLibResolutionStructure( amigamemptr);
650: AmigaListAddTail (AmigaBoardInfo + PSSO_BoardInfo_ResolutionsList, amigamemptr);
651: }
652:
653: return 0;
654: }
655:
656: extern int x_size, y_size;
657:
658: /*
659: * SetSwitch:
660: * a0: struct BoardInfo
661: * d0.w: BOOL state
662: * this function should set a board switch to let the Amiga signal pass
663: * through when supplied with a 0 in d0 and to show the board signal if
664: * a 1 is passed in d0. You should remember the current state of the
665: * switch to avoid unneeded switching. If your board has no switch, then
666: * simply supply a function that does nothing except a RTS.
667: *
668: * NOTE: Return the opposite of the switch-state. BDK
669: */
670: uae_u32 picasso_SetSwitch (void)
671: {
672: uae_u16 flag = m68k_dreg(regs, 0) & 0xFFFF;
673: uae_u32 result;
674:
675: /* Do not switch immediately. Tell the custom chip emulation about the
676: * desired state, and wait for custom.c to call picasso_enablescreen
677: * whenever it is ready to change the screen state. */
678: picasso_requested_on = !!flag;
679: MyOutputDebugString ("SetSwitch() - trying to show %s screen\n", flag ? "picasso96":"amiga");
680:
681: /* Put old switch-state in D0 */
682: return !flag;
683: }
684:
685: void picasso_enablescreen (int on)
686: {
687: wgfx_linestart = 0xFFFFFFFF;
688: picasso_refresh ();
689: MyOutputDebugString ("SetSwitch() - showing %s screen\n", on ? "picasso96":"amiga");
690: }
691:
692: /*
693: * SetColorArray:
694: * a0: struct BoardInfo
695: * d0.w: startindex
696: * d1.w: count
697: * when this function is called, your driver has to fetch "count" color
698: * values starting at "startindex" from the CLUT field of the BoardInfo
699: * structure and write them to the hardware. The color values are always
700: * between 0 and 255 for each component regardless of the number of bits
701: * per cannon your board has. So you might have to shift the colors
702: * before writing them to the hardware.
703: */
704: uae_u32 picasso_SetColorArray (void)
705: {
706: /* Fill in some static UAE related structure about this new CLUT setting
707: * We need this for CLUT-based displays, and for mapping CLUT to hi/true colour */
708: uae_u16 start = m68k_dreg(regs, 0);
709: uae_u16 count = m68k_dreg(regs, 1);
710: int i;
711: uaecptr boardinfo = m68k_areg(regs, 0);
712: uaecptr clut = boardinfo + PSSO_BoardInfo_CLUT + start * 3;
713:
714: for (i = start; i < start + count; i++) {
715: picasso96_state.CLUT[i].Red = get_byte (clut);
716: picasso96_state.CLUT[i].Green = get_byte (clut + 1);
717: picasso96_state.CLUT[i].Blue = get_byte (clut + 2);
718: clut += 3;
719: }
720: DX_SetPalette(start, count);
721: /*MyOutputDebugString ("SetColorArray(%d,%d)\n", start, count); */
722: return m68k_dreg(regs, 0);
723: }
724:
725: static uae_u8 GetBytesPerPixel(uae_u32 RGBfmt)
726: {
727: switch (RGBfmt) {
728: case RGBFB_CLUT:
729: return 1;
730:
731: case RGBFB_A8R8G8B8:
732: case RGBFB_A8B8G8R8:
733: case RGBFB_R8G8B8A8:
734: case RGBFB_B8G8R8A8:
735: return 4;
736:
737: case RGBFB_B8G8R8:
738: case RGBFB_R8G8B8:
739: return 3;
740:
741: case RGBFB_R5G5B5:
742: case RGBFB_R5G6B5:
743: case RGBFB_R5G6B5PC:
744: case RGBFB_R5G5B5PC:
745: case RGBFB_B5G6R5PC:
746: case RGBFB_B5G5R5PC:
747: return 2;
748: default:
749: MyOutputDebugString ("ERROR - GetBytesPerPixel() was unsuccessful with 0x%x?!\n", RGBfmt);
750: return 0;
751: }
752: }
753:
754: /*
755: * SetDAC:
756: * a0: struct BoardInfo
757: * d7: RGBFTYPE RGBFormat
758: * This function is called whenever the RGB format of the display changes,
759: * e.g. from chunky to TrueColor. Usually, all you have to do is to set
760: * the RAMDAC of your board accordingly.
761: */
762: uae_u32 picasso_SetDAC (void)
763: {
764: /* Fill in some static UAE related structure about this new DAC setting
765: * Lets us keep track of what pixel format the Amiga is thinking about in our frame-buffer */
766:
767: MyOutputDebugString ("SetDAC()\n");
768: return m68k_dreg(regs, 0);
769: }
770:
771: /*
772: * SetGC:
773: * a0: struct BoardInfo
774: * a1: struct ModeInfo
775: * d0: BOOL Border
776: * This function is called whenever another ModeInfo has to be set. This
777: * function simply sets up the CRTC and TS registers to generate the
778: * timing used for that screen mode. You should not set the DAC, clocks
779: * or linear start adress. They will be set when appropriate by their
780: * own functions.
781: */
782: uae_u32 picasso_SetGC (void)
783: {
784: /* Fill in some static UAE related structure about this new ModeInfo setting */
785: uaecptr modeinfo = m68k_areg(regs, 1);
786:
787: picasso96_state.Width = get_word (modeinfo + PSSO_ModeInfo_Width);
788: picasso96_state.VirtualWidth = picasso96_state.Width; /* in case SetPanning doesn't get called */
789:
790: picasso96_state.Height = get_word (modeinfo + PSSO_ModeInfo_Height);
791: picasso96_state.VirtualHeight = picasso96_state.Height;
792:
793: picasso96_state.GC_Depth = get_byte (modeinfo + PSSO_ModeInfo_Depth);
794: picasso96_state.GC_Flags = get_byte (modeinfo + PSSO_ModeInfo_Flags);
795:
796: MyOutputDebugString ("SetGC(%d,%d,%d)\n", picasso96_state.Width, picasso96_state.Height, picasso96_state.GC_Depth);
797:
798: gfx_set_picasso_modeinfo (picasso96_state.Width, picasso96_state.Height,
799: picasso96_state.GC_Depth);
800: wgfx_linestart = 0xFFFFFFFF;
801: picasso_refresh ();
802:
803: return m68k_dreg(regs, 0);
804: }
805:
806: /*
807: * SetPanning:
808: * a0: struct BoardInfo
809: * a1: UBYTE *Memory
810: * d0: uae_u16 Width
811: * d1: WORD XOffset
812: * d2: WORD YOffset
813: * d7: RGBFTYPE RGBFormat
814: * This function sets the view origin of a display which might also be
815: * overscanned. In register a1 you get the start address of the screen
816: * bitmap on the Amiga side. You will have to subtract the starting
817: * address of the board memory from that value to get the memory start
818: * offset within the board. Then you get the offset in pixels of the
819: * left upper edge of the visible part of an overscanned display. From
820: * these values you will have to calculate the LinearStartingAddress
821: * fields of the CRTC registers.
822:
823: * NOTE: SetPanning() can be used to know when a Picasso96 screen is
824: * being opened. Better to do the appropriate clearing of the
825: * background here than in SetSwitch() derived functions,
826: * because SetSwitch() is not called for subsequent Picasso screens.
827: */
828: uae_u32 picasso_SetPanning (void)
829: {
830: uae_u16 Width = m68k_dreg(regs, 0);
831: uaecptr start_of_screen = m68k_areg(regs, 1);
832:
833: picasso96_state.Address = start_of_screen; /* Amiga-side address */
834: picasso96_state.XOffset = (uae_s16)m68k_dreg(regs, 1);
835: picasso96_state.YOffset = (uae_s16)m68k_dreg(regs, 2);
836: picasso96_state.VirtualWidth = Width;
837: picasso96_state.RGBFormat = m68k_dreg(regs, 7);
838: picasso96_state.BytesPerPixel = GetBytesPerPixel(picasso96_state.RGBFormat);
839: picasso96_state.BytesPerRow = Width * picasso96_state.BytesPerPixel;
840:
841: /* I assume SetGC() has been called, so I can calculate the Extent */
842: picasso96_state.Extent = picasso96_state.Address + (picasso96_state.BytesPerRow * picasso96_state.Height);
843:
844: MyOutputDebugString ("SetPanning(%d, %d, %d) Start 0x%x, BPR %d\n",
845: Width,picasso96_state.XOffset, picasso96_state.YOffset,
846: start_of_screen, picasso96_state.BytesPerRow);
847: DX_SetPalette(0, 256);
848:
849: wgfx_linestart = 0xFFFFFFFF;
850: picasso_refresh ();
851:
852: return m68k_dreg(regs, 0);
853: }
854:
855: static void do_xor8 (uae_u8 *ptr, long len, uae_u32 val)
856: {
857: int i;
858: #if 0 && defined ALIGN_POINTER_TO32
859: int align_adjust = ALIGN_POINTER_TO32(ptr);
860: int len2;
861:
862: len -= align_adjust;
863: while (align_adjust) {
864: *ptr ^= val;
865: ptr++;
866: align_adjust--;
867: }
868: len2 = len >> 2;
869: len -= len2 << 2;
870: for (i = 0; i < len2; i++, ptr += 4) {
871: *(uae_u32 *)ptr ^= val;
872: }
873: while (len) {
874: *ptr ^= val;
875: ptr++;
876: len--;
877: }
878: return;
879: #endif
880: for (i = 0; i < len; i++, ptr++) {
881: do_put_mem_byte (ptr, do_get_mem_byte (ptr) ^ val);
882: }
883: }
884:
885: /*
886: * InvertRect:
887: *
888: * Inputs:
889: * a0:struct BoardInfo *bi
890: * a1:struct RenderInfo *ri
891: * d0.w:X
892: * d1.w:Y
893: * d2.w:Width
894: * d3.w:Height
895: * d4.l:Mask
896: * d7.l:RGBFormat
897: *
898: * This function is used to invert a rectangular area on the board. It is called by BltBitMap,
899: * BltPattern and BltTemplate.
900: */
901: uae_u32 picasso_InvertRect (void)
902: {
903: uaecptr boardinfo = m68k_areg(regs, 0);
904: uaecptr renderinfo = m68k_areg(regs, 1);
905: long X = (uae_u16)m68k_dreg(regs, 0);
906: long Y = (uae_u16)m68k_dreg(regs, 1);
907: long Width = (uae_u16)m68k_dreg(regs, 2);
908: long Height = (uae_u16)m68k_dreg(regs, 3);
909: uae_u32 mask = m68k_dreg(regs, 4);
910: int Bpp = GetBytesPerPixel (m68k_dreg(regs, 7));
911: uae_u32 xorval;
912: int lines;
913: struct RenderInfo ri;
914: uae_u8 *uae_mem, *rectstart;
915: long width_in_bytes;
916:
917: wgfx_flushline ();
918:
919: if (!CopyRenderInfoStructureA2U (renderinfo, &ri))
920: return 0;
921:
922: /*MyOutputDebugString ("InvertRect %d %lx\n", Bpp, (long)mask);*/
923:
924: /* ??? Brian? mask used to be 32 bit, but it appears that only 8 bit
925: * values are passed to this function. This code here seems to work
926: * much better... */
927: if (mask != 0xFF && Bpp > 8) {
928: MyOutputDebugString ("InvertRect: not obeying mask 0x%x properly with Bpp %d.\n", mask, Bpp);
929: mask = 0xFF;
930: }
931: if ((mask & ~0xFF) != 0) {
932: MyOutputDebugString ("InvertRect: mask has high bits set!\n");
933: }
934: xorval = 0x01010101 * (mask & 0xFF);
935: width_in_bytes = Bpp * Width;
936: rectstart = uae_mem = ri.Memory + Y*ri.BytesPerRow + X*Bpp;
937:
938: for (lines = 0; lines < Height; lines++, uae_mem += ri.BytesPerRow) {
939: int j;
940: uae_u8 *start = uae_mem;
941: do_xor8 (uae_mem, width_in_bytes, xorval);
942: }
943: if (renderinfo_is_current_screen (&ri)) {
944: if (mask == 0xFF)
945: do_invertrect (rectstart, ri.BytesPerRow, X, Y, Width, Height);
946: else
947: do_blit (rectstart, ri.BytesPerRow, 0, 0, X, Y, Width, Height, 0);
948: }
949:
950: return 1; /* 1 if supported, 0 otherwise */
951: }
952:
953: /***********************************************************
954: FillRect:
955: ***********************************************************
956: * a0: struct BoardInfo *
957: * a1: struct RenderInfo *
958: * d0: WORD X
959: * d1: WORD Y
960: * d2: WORD Width
961: * d3: WORD Height
962: * d4: uae_u32 Pen
963: * d5: UBYTE Mask
964: * d7: uae_u32 RGBFormat
965: ***********************************************************/
966: uae_u32 picasso_FillRect (void)
967: {
968: uaecptr boardinfo = m68k_areg(regs, 0);
969: uaecptr renderinfo = m68k_areg(regs, 1);
970: unsigned long X = (uae_u16)m68k_dreg(regs, 0);
971: unsigned long Y = (uae_u16)m68k_dreg(regs, 1);
972: unsigned long Width = (uae_u16)m68k_dreg(regs, 2);
973: unsigned long Height = (uae_u16)m68k_dreg(regs, 3);
974: uae_u32 Pen = m68k_dreg(regs, 4);
975: uae_u8 Mask = (uae_u8)m68k_dreg(regs, 5);
976: uae_u32 RGBFormat = m68k_dreg(regs, 7);
977:
978: uae_u8 *src, *dst;
979: uae_u8 *start, *oldstart;
980: struct RenderInfo local_ri;
981: unsigned long lines, cols;
982: int Bpp;
983: struct RenderInfo ri;
984:
985: wgfx_flushline ();
986:
987: if (! CopyRenderInfoStructureA2U(renderinfo, &ri) || Y == 0xFFFF)
988: return 0;
989:
990: if (ri.RGBFormat != RGBFormat)
991: MyOutputDebugString ("Weird Stuff!\n");
992:
993: Bpp = GetBytesPerPixel(RGBFormat);
994:
995: /*MyOutputDebugString ("FillRect(%d, %d, %d, %d) Pen 0x%x BPP %d BPR %d Mask 0x%x\n",
996: X, Y, Width, Height, Pen, Bpp, ri.BytesPerRow, Mask); */
997:
998: if (Mask == 0xFF) {
999: /* Do our virtual frame-buffer memory. First, we do a single line fill by hand */
1000: oldstart = start = ri.Memory + Y*ri.BytesPerRow + X*Bpp;
1001: switch (Bpp) {
1002: case 1:
1003: memset (start, Pen, Width);
1004: break;
1005: case 2:
1006: for (cols = 0; cols < Width; cols++) {
1007: do_put_mem_word ((uae_u16 *)start, Pen);
1008: start += 2;
1009: }
1010: break;
1011: case 3:
1012: for (cols = 0; cols < Width; cols++) {
1013: do_put_mem_byte (start, Pen & 0x000000FF);
1014: start++;
1015: *(uae_u16 *)(start) = (Pen & 0x00FFFF00) >> 8;
1016: start+=2;
1017: }
1018: break;
1019: case 4:
1020: for (cols = 0; cols < Width; cols++) {
1021: /**start = Pen; */
1022: do_put_mem_long ((uae_u32 *)start, Pen);
1023: start += 4;
1024: }
1025: break;
1026: }
1027: src = oldstart;
1028: dst = src + ri.BytesPerRow;
1029: /* next, we do the remaining line fills via memcpy() */
1030: for (lines = 0; lines < (Height - 1); lines++, dst += ri.BytesPerRow)
1031: memcpy(dst, src, Width * Bpp);
1032:
1033: if (renderinfo_is_current_screen (&ri)) {
1034: do_fillrect (src, X, Y, Width, Height);
1035: }
1036: return 1;
1037: }
1038:
1039: /* We get here only if Mask != 0xFF */
1040: if (Bpp != 1) {
1041: write_log ("Picasso: mask != 0xFF in truecolor mode!\n");
1042: return 0;
1043: }
1044: Pen &= Mask;
1045: Mask = ~Mask;
1046:
1047: oldstart = start = ri.Memory + Y*ri.BytesPerRow + X*Bpp;
1048: for (lines = 0; lines < Height; lines++, start += ri.BytesPerRow) {
1049: uae_u8 *p = start;
1050: for (cols = 0; cols < Width; cols++) {
1051: uae_u32 tmpval = do_get_mem_byte (p) & Mask;
1052: do_put_mem_byte (p, Pen | tmpval);
1053: p++;
1054: }
1055: }
1056: if (renderinfo_is_current_screen (&ri))
1057: do_blit (oldstart, ri.BytesPerRow, 0, 0, X, Y, Width, Height, 0);
1058:
1059: return 1;
1060: }
1061:
1062: /*
1063: * BlitRect() is a generic (any chunky pixel format) rectangle copier
1064: * NOTE: If dstri is NULL, then we're only dealing with one RenderInfo area, and called from picasso_BlitRect()
1065: */
1066: static void BlitRect (struct RenderInfo *ri, struct RenderInfo *dstri,
1067: uae_u16 srcx, uae_u16 srcy, uae_u16 dstx, uae_u16 dsty,
1068: uae_u16 width, uae_u16 height, uae_u8 mask)
1069: {
1070: uae_u8 *src, *dst, *tmp, *tmp2, *tmp3;
1071: int lines;
1072: uae_u8 Bpp = GetBytesPerPixel(ri->RGBFormat);
1073: uae_u8 *blitsrc;
1074: unsigned long total_width = width * Bpp;
1075: unsigned long linewidth = (total_width + 15) & ~15;
1076: int cant_blit = 1;
1077:
1078: /*
1079: * If we have no destination RenderInfo, then we're dealing with a single-buffer action, called
1080: * from picasso_BlitRect(). The code up to the DX_xxxxx() functions deals with the frame-buffer,
1081: * while the DX_ functions actually deal with the visible screen.
1082: *
1083: * If we have a destination RenderInfo, then we've been called from picasso_BlitRectNoMaskComplete()
1084: * and we need to put the results on the screen from the frame-buffer.
1085: */
1086: if (dstri == NULL) {
1087: dstri = ri;
1088: cant_blit = 0;
1089: }
1090:
1091: /* Do our virtual frame-buffer memory first */
1092: src = ri->Memory + srcx*Bpp + srcy*ri->BytesPerRow;
1093: dst = dstri->Memory + dstx*Bpp + dsty*dstri->BytesPerRow;
1094: blitsrc = dst;
1095: if (mask != 0xFF && Bpp > 1)
1096: MyOutputDebugString ("ERROR - not obeying BlitRect() mask 0x%x properly with Bpp %d.\n", mask, Bpp);
1097:
1098: if (mask == 0xFF || Bpp > 1) {
1099: /* handle normal case efficiently */
1100: if (ri->Memory == dstri->Memory && dsty == srcy) {
1101: int i;
1102: for (i = 0; i < height; i++, src += ri->BytesPerRow, dst += dstri->BytesPerRow)
1103: memmove (dst, src, total_width);
1104: } else if (dsty < srcy) {
1105: int i;
1106: for (i = 0; i < height; i++, src += ri->BytesPerRow, dst += dstri->BytesPerRow)
1107: memcpy (dst, src, total_width);
1108: } else {
1109: int i;
1110: src += (height-1) * ri->BytesPerRow;
1111: dst += (height-1) * dstri->BytesPerRow;
1112: for (i = 0; i < height; i++, src -= ri->BytesPerRow, dst -= dstri->BytesPerRow)
1113: memcpy (dst, src, total_width);
1114: }
1115: if (renderinfo_is_current_screen (dstri))
1116: do_blit (blitsrc, dstri->BytesPerRow, srcx, srcy, dstx, dsty,
1117: width, height, ! cant_blit);
1118: return;
1119: }
1120:
1121: tmp3 = tmp2 = tmp = xmalloc (linewidth * height); /* allocate enough memory for the src-rect */
1122: if (!tmp)
1123: return;
1124:
1125: /* copy the src-rect into our temporary buffer space */
1126: for (lines = 0; lines < height; lines++, src += ri->BytesPerRow, tmp2 += linewidth) {
1127: memcpy (tmp2, src, total_width);
1128: }
1129:
1130: /* copy the temporary buffer to the destination */
1131: for (lines = 0; lines < height; lines++, dst += dstri->BytesPerRow, tmp += linewidth) {
1132: int cols;
1133: for (cols = 0; cols < width; cols++) {
1134: dst[cols] &= ~mask;
1135: dst[cols] |= tmp[cols] & mask;
1136: }
1137: }
1138: if (renderinfo_is_current_screen (dstri))
1139: do_blit (blitsrc, dstri->BytesPerRow, srcx, srcy, dstx, dsty,
1140: width, height, 0);
1141: /* free the temp-buf */
1142: free (tmp3);
1143:
1144: }
1145:
1146: /***********************************************************
1147: BlitRect:
1148: ***********************************************************
1149: * a0: struct BoardInfo
1150: * a1: struct RenderInfo
1151: * d0: WORD SrcX
1152: * d1: WORD SrcY
1153: * d2: WORD DstX
1154: * d3: WORD DstY
1155: * d4: WORD Width
1156: * d5: WORD Height
1157: * d6: UBYTE Mask
1158: * d7: uae_u32 RGBFormat
1159: ***********************************************************/
1160: uae_u32 picasso_BlitRect (void)
1161: {
1162: uaecptr boardinfo = m68k_areg(regs, 0);
1163: uaecptr renderinfo = m68k_areg(regs, 1);
1164: uae_u16 srcx = (uae_u16)m68k_dreg(regs, 0);
1165: uae_u16 srcy = (uae_u16)m68k_dreg(regs, 1);
1166: uae_u16 dstx = (uae_u16)m68k_dreg(regs, 2);
1167: uae_u16 dsty = (uae_u16)m68k_dreg(regs, 3);
1168: uae_u16 width = (uae_u16)m68k_dreg(regs, 4);
1169: uae_u16 height = (uae_u16)m68k_dreg(regs, 5);
1170: uae_u8 Mask = (uae_u8)m68k_dreg(regs, 6);
1171: uae_u32 RGBFormat = m68k_dreg(regs, 7);
1172:
1173: struct RenderInfo ri;
1174:
1175: wgfx_flushline ();
1176:
1177: if (!CopyRenderInfoStructureA2U (renderinfo, &ri))
1178: return 0;
1179:
1180: BlitRect(&ri, NULL, srcx, srcy, dstx, dsty, width, height, Mask);
1181: /*MyOutputDebugString ("BlitRect(%d, %d, %d, %d, %d, %d, 0x%x)\n", srcx, srcy, dstx, dsty, width, height, Mask); */
1182:
1183: return 1;
1184: }
1185:
1186: /***********************************************************
1187: BlitRectNoMaskComplete:
1188: ***********************************************************
1189: * a0: struct BoardInfo
1190: * a1: struct RenderInfo (src)
1191: * a2: struct RenderInfo (dst)
1192: * d0: WORD SrcX
1193: * d1: WORD SrcY
1194: * d2: WORD DstX
1195: * d3: WORD DstY
1196: * d4: WORD Width
1197: * d5: WORD Height
1198: * d6: UBYTE OpCode
1199: * d7: uae_u32 RGBFormat
1200: * NOTE: MUST return 0 in D0 if we're not handling this operation
1201: * because the RGBFormat or opcode aren't supported.
1202: * OTHERWISE return 1
1203: ***********************************************************/
1204: uae_u32 picasso_BlitRectNoMaskComplete (void)
1205: {
1206: uaecptr boardinfo = m68k_areg(regs, 0);
1207: uaecptr srcri = m68k_areg(regs, 1);
1208: uaecptr dstri = m68k_areg(regs, 2);
1209: uae_u16 srcx = m68k_dreg(regs, 0);
1210: uae_u16 srcy = m68k_dreg(regs, 1);
1211: uae_u16 dstx = m68k_dreg(regs, 2);
1212: uae_u16 dsty = m68k_dreg(regs, 3);
1213: uae_u16 width = m68k_dreg(regs, 4);
1214: uae_u16 height = m68k_dreg(regs, 5);
1215: uae_u8 OpCode = m68k_dreg(regs, 6);
1216: uae_u32 RGBFmt = m68k_dreg(regs, 7);
1217:
1218: uae_u8 Bpp = GetBytesPerPixel(RGBFmt), *srcri_ptr = NULL, *dstri_ptr = NULL;
1219: struct RenderInfo src_ri, dst_ri;
1220:
1221: wgfx_flushline ();
1222:
1223: if (!CopyRenderInfoStructureA2U(srcri, &src_ri) || !CopyRenderInfoStructureA2U(dstri, &dst_ri))
1224: return 0;
1225:
1226: /*MyOutputDebugString ("BlitRectNoMaskComplete() op 0x%2x, Bpp %d, xy(%4d,%4d) --> xy(%4d,%4d), wh(%4d,%4d)\n",
1227: OpCode, Bpp, srcx, srcy, dstx, dsty, width, height); */
1228: /*MyOutputDebugString ("-- src mem 0x%x BPR %d, dst mem 0x%x BPR %d, screen-mem 0x%x - 0x%x\n",
1229: src_ri.Memory, src_ri.BytesPerRow, dst_ri.Memory, dst_ri.BytesPerRow, picasso96_state.Address, picasso96_state.Extent); */
1230:
1231: switch (OpCode) {
1232: case 0x0C:
1233: BlitRect(&src_ri, &dst_ri, srcx, srcy, dstx, dsty, width, height, 0xFF);
1234: return 1;
1235:
1236: default:
1237: /* FOR NOW! */
1238: return 0;
1239: }
1240: }
1241:
1242: /* This utility function is used both by BlitTemplate() and BlitPattern() */
1243: static __inline__ void PixelWrite1(uae_u8 *mem, int bits, uae_u32 fgpen, uae_u32 mask)
1244: {
1245: if (mask != 0xFF)
1246: fgpen = (fgpen & mask) | (do_get_mem_byte (mem + bits) & ~mask);
1247: do_put_mem_byte (mem + bits, fgpen);
1248: }
1249:
1250: static __inline__ void PixelWrite2(uae_u8 *mem, int bits, uae_u32 fgpen)
1251: {
1252: do_put_mem_word (((uae_u16 *)mem) + bits, fgpen);
1253: }
1254:
1255: static __inline__ void PixelWrite3(uae_u8 *mem, int bits, uae_u32 fgpen)
1256: {
1257: do_put_mem_byte (mem + bits*3, fgpen & 0x000000FF);
1258: *(uae_u16 *)(mem + bits*3+1) = (fgpen & 0x00FFFF00) >> 8;
1259: }
1260:
1261: static __inline__ void PixelWrite4(uae_u8 *mem, int bits, uae_u32 fgpen)
1262: {
1263: do_put_mem_long (((uae_u32 *)mem) + bits, fgpen);
1264: }
1265:
1266: static __inline__ void PixelWrite(uae_u8 *mem, int bits, uae_u32 fgpen, uae_u8 Bpp, uae_u32 mask)
1267: {
1268: switch (Bpp) {
1269: case 1:
1270: if (mask != 0xFF)
1271: fgpen = (fgpen & mask) | (do_get_mem_byte (mem + bits) & ~mask);
1272: do_put_mem_byte (mem + bits, fgpen);
1273: break;
1274: case 2:
1275: do_put_mem_word (((uae_u16 *)mem) + bits, fgpen);
1276: break;
1277: case 3:
1278: do_put_mem_byte (mem + bits*3, fgpen & 0x000000FF);
1279: *(uae_u16 *)(mem + bits*3+1) = (fgpen & 0x00FFFF00) >> 8;
1280: break;
1281: case 4:
1282: do_put_mem_long (((uae_u32 *)mem) + bits, fgpen);
1283: break;
1284: }
1285: }
1286:
1287: /*
1288: * BlitPattern:
1289: *
1290: * Synopsis:BlitPattern(bi, ri, pattern, X, Y, Width, Height, Mask, RGBFormat);
1291: * Inputs:
1292: * a0:struct BoardInfo *bi
1293: * a1:struct RenderInfo *ri
1294: * a2:struct Pattern *pattern
1295: * d0.w:X
1296: * d1.w:Y
1297: * d2.w:Width
1298: * d3.w:Height
1299: * d4.w:Mask
1300: * d7.l:RGBFormat
1301: *
1302: * This function is used to paint a pattern on the board memory using the blitter. It is called by
1303: * BltPattern, if a AreaPtrn is used with positive AreaPtSz. The pattern consists of a b/w image
1304: * using a single plane of image data which will be expanded repeatedly to the destination RGBFormat
1305: * using ForeGround and BackGround pens as well as draw modes. The width of the pattern data is
1306: * always 16 pixels (one word) and the height is calculated as 2^Size. The data must be shifted up
1307: * and to the left by XOffset and YOffset pixels at the beginning.
1308: */
1309: uae_u32 picasso_BlitPattern (void)
1310: {
1311: uaecptr boardinfo = m68k_areg(regs, 0);
1312: uaecptr rinf = m68k_areg(regs, 1);
1313: uaecptr pinf = m68k_areg(regs, 2);
1314: long X = (uae_u16)m68k_dreg(regs, 0);
1315: long Y = (uae_u16)m68k_dreg(regs, 1);
1316: long W = (uae_u16)m68k_dreg(regs, 2);
1317: long H = (uae_u16)m68k_dreg(regs, 3);
1318: uae_u8 Mask = (uae_u8)m68k_dreg(regs, 4);
1319: uae_u32 RGBFmt = m68k_dreg(regs, 7);
1320:
1321: uae_u8 Bpp = GetBytesPerPixel(RGBFmt);
1322: int inversion = 0;
1323: struct RenderInfo ri;
1324: struct Pattern pattern;
1325: uae_u16 rows;
1326: uae_u32 fgpen, bgpen, value;
1327: uae_u8 *uae_mem, *frame_buffer_UAM;
1328: unsigned long ysize_mask;
1329: int xshift;
1330:
1331: wgfx_flushline ();
1332:
1333: if (!CopyRenderInfoStructureA2U(rinf, &ri) || !CopyPatternStructureA2U(pinf, &pattern))
1334: return 0;
1335:
1336: Bpp = GetBytesPerPixel(ri.RGBFormat);
1337: uae_mem = ri.Memory + Y*ri.BytesPerRow + X*Bpp; /* offset with address */
1338:
1339: if (pattern.DrawMode & INVERS)
1340: inversion = 1;
1341:
1342: pattern.DrawMode &= 0x03;
1343: if (Mask != 0xFF) {
1344: if (Bpp > 1)
1345: MyOutputDebugString ("ERROR - not obeying BlitPattern() mask 0x%x properly with Bpp %d.\n", Mask, Bpp);
1346: else if (pattern.DrawMode == COMP) {
1347: MyOutputDebugString ("ERROR - Unsupported Mask value 0x%x with COMP Draw in BlitPattern(), using fallback method.\n", Mask);
1348: return 0;
1349: }
1350: }
1351:
1352: /*MyOutputDebugString ("BlitPattern() xy(%d,%d), wh(%d,%d) draw 0x%x, off(%d,%d), ph %d\n",
1353: X, Y, W, H, pattern.DrawMode, pattern.XOffset, pattern.YOffset, 1<<pattern.Size); */
1354: #ifdef _DEBUG
1355: DumpPattern(&pattern);
1356: #endif
1357: ysize_mask = (1 << pattern.Size) - 1;
1358: xshift = pattern.XOffset & 15;
1359:
1360: for (rows = 0; rows < H; rows++, uae_mem += ri.BytesPerRow) {
1361: int prow = (rows + pattern.YOffset) & ysize_mask;
1362: unsigned int d = do_get_mem_word (((uae_u16 *)pattern.Memory) + prow);
1363: uae_u8 *uae_mem2 = uae_mem;
1364: long cols;
1365:
1366: if (xshift != 0)
1367: d = (d << xshift) | (d >> (16 - xshift));
1368:
1369: for (cols = 0; cols < W; cols += 16, uae_mem2 += Bpp << 4) {
1370: long bits;
1371: long max = W - cols;
1372: unsigned int data = d;
1373:
1374: if (max > 16)
1375: max = 16;
1376:
1377: for (bits = 0; bits < max; bits++) {
1378: int bit_set = data & 0x8000;
1379: data <<= 1;
1380: switch (pattern.DrawMode) {
1381: case JAM1:
1382: if (inversion)
1383: bit_set = !bit_set;
1384: if (bit_set)
1385: PixelWrite(uae_mem2, bits, pattern.FgPen, Bpp, Mask);
1386: break;
1387: case JAM2:
1388: if (inversion)
1389: bit_set = !bit_set;
1390: if (bit_set)
1391: PixelWrite(uae_mem2, bits, pattern.FgPen, Bpp, Mask);
1392: else
1393: PixelWrite(uae_mem2, bits, pattern.BgPen, Bpp, Mask);
1394: break;
1395: case COMP:
1396: if (bit_set) {
1397: fgpen = pattern.FgPen;
1398:
1399: switch (Bpp) {
1400: case 1:
1401: {
1402: uae_u8 *addr = uae_mem2 + bits;
1403: do_put_mem_byte (addr, do_get_mem_byte (addr) ^ fgpen);
1404: }
1405: break;
1406: case 2:
1407: {
1408: uae_u16 *addr = ((uae_u16 *)uae_mem2) + bits;
1409: do_put_mem_word (addr, do_get_mem_word (addr) ^ fgpen);
1410: }
1411: break;
1412: case 3:
1413: {
1414: uae_u32 *addr = (uae_u32 *)(uae_mem2 + bits * 3);
1415: do_put_mem_long (addr, do_get_mem_long (addr) ^ (fgpen & 0x00FFFFFF));
1416: }
1417: break;
1418: case 4:
1419: {
1420: uae_u32 *addr = ((uae_u32 *)uae_mem2) + bits;
1421: do_put_mem_long (addr, do_get_mem_long (addr) ^ fgpen);
1422: }
1423: break;
1424: }
1425: }
1426: break;
1427: }
1428: }
1429: }
1430: }
1431:
1432: frame_buffer_UAM = ri.Memory + X*picasso96_state.BytesPerPixel + Y*ri.BytesPerRow;
1433: if (renderinfo_is_current_screen (&ri))
1434: do_blit (frame_buffer_UAM, ri.BytesPerRow, 0, 0, X, Y, W, H, 0);
1435:
1436: return 1;
1437: }
1438:
1439: /*************************************************
1440: BlitTemplate:
1441: **************************************************
1442: * Synopsis: BlitTemplate(bi, ri, template, X, Y, Width, Height, Mask, RGBFormat);
1443: * a0: struct BoardInfo *bi
1444: * a1: struct RenderInfo *ri
1445: * a2: struct Template *template
1446: * d0.w: X
1447: * d1.w: Y
1448: * d2.w: Width
1449: * d3.w: Height
1450: * d4.w: Mask
1451: * d7.l: RGBFormat
1452: *
1453: * This function is used to paint a template on the board memory using the blitter.
1454: * It is called by BltPattern and BltTemplate. The template consists of a b/w image
1455: * using a single plane of image data which will be expanded to the destination RGBFormat
1456: * using ForeGround and BackGround pens as well as draw modes.
1457: ***********************************************************************************/
1458: uae_u32 picasso_BlitTemplate (void)
1459: {
1460: uae_u8 inversion = 0;
1461: uaecptr rinf = m68k_areg(regs, 1);
1462: uaecptr tmpl = m68k_areg(regs, 2);
1463: uae_u16 X = m68k_dreg(regs, 0);
1464: uae_u16 Y = m68k_dreg(regs, 1);
1465: uae_u16 W = m68k_dreg(regs, 2);
1466: uae_u16 H = m68k_dreg(regs, 3);
1467: uae_u16 Mask = m68k_dreg(regs, 4);
1468: uae_u32 Fmt = m68k_dreg(regs, 7);
1469: struct Template tmp;
1470: struct RenderInfo ri;
1471: long rows;
1472: int bitoffset;
1473: uae_u32 fgpen, bgpen, value;
1474: uae_u8 *uae_mem, *uae_mem2, Bpp, *frame_buffer_UAM;
1475: uae_u8 *tmpl_base;
1476:
1477: wgfx_flushline ();
1478:
1479: if (!CopyRenderInfoStructureA2U(rinf, &ri) || !CopyTemplateStructureA2U(tmpl, &tmp))
1480: return 0;
1481:
1482: Bpp = GetBytesPerPixel(ri.RGBFormat);
1483: uae_mem = ri.Memory + Y*ri.BytesPerRow + X*Bpp; /* offset into address */
1484:
1485: if (tmp.DrawMode & INVERS)
1486: inversion = 1;
1487:
1488: tmp.DrawMode &= 0x03;
1489: if (Mask != 0xFF) {
1490: if (Bpp > 1)
1491: MyOutputDebugString ("ERROR - not obeying BlitTemplate() mask 0x%x properly with Bpp %d.\n", Mask, Bpp);
1492: else if (tmp.DrawMode == COMP) {
1493: MyOutputDebugString ("ERROR - Unsupported Mask value 0x%x with COMP Draw in BlitTemplate(), using fallback method.\n", Mask);
1494: return 0;
1495: }
1496: }
1497:
1498: /*MyOutputDebugString ("BlitTemplate() xy(%d,%d), wh(%d,%d) draw 0x%x fg 0x%x bg 0x%x \n",
1499: X, Y, W, H, tmp.DrawMode, tmp.FgPen, tmp.BgPen); */
1500:
1501: bitoffset = tmp.XOffset % 8;
1502:
1503: #ifdef _DEBUG
1504: DumpTemplate(&tmp, W, H);
1505: #endif
1506:
1507: tmpl_base = tmp.Memory + tmp.XOffset/8;
1508:
1509: for (rows = 0; rows < H; rows++, uae_mem += ri.BytesPerRow, tmpl_base += tmp.BytesPerRow) {
1510: long cols;
1511: uae_u8 *tmpl_mem = tmpl_base;
1512: uae_u8 *uae_mem2 = uae_mem;
1513: unsigned int data = *tmpl_mem;
1514:
1515: for (cols = 0; cols < W; cols += 8, uae_mem2 += Bpp << 3) {
1516: unsigned int byte;
1517: long bits;
1518: long max = W - cols;
1519:
1520: if (max > 8)
1521: max = 8;
1522:
1523: data <<= 8;
1524: data |= *++tmpl_mem;
1525:
1526: byte = data >> (8 - bitoffset);
1527:
1528: for (bits = 0; bits < max; bits++) {
1529: int bit_set = (byte & 0x80);
1530: byte <<= 1;
1531: switch (tmp.DrawMode) {
1532: case JAM1:
1533: if (inversion)
1534: bit_set = !bit_set;
1535: if (bit_set) {
1536: fgpen = tmp.FgPen;
1537: PixelWrite(uae_mem2, bits, fgpen, Bpp, Mask);
1538: }
1539: break;
1540: case JAM2:
1541: if (inversion)
1542: bit_set = !bit_set;
1543: fgpen = tmp.BgPen;
1544: if (bit_set)
1545: fgpen = tmp.FgPen;
1546:
1547: PixelWrite(uae_mem2, bits, fgpen, Bpp, Mask);
1548: break;
1549: case COMP:
1550: if (bit_set) {
1551: fgpen = tmp.FgPen;
1552:
1553: switch (Bpp) {
1554: case 1:
1555: {
1556: uae_u8 *addr = uae_mem2 + bits;
1557: do_put_mem_byte (addr, do_get_mem_byte (addr) ^ fgpen);
1558: }
1559: break;
1560: case 2:
1561: {
1562: uae_u16 *addr = ((uae_u16 *)uae_mem2) + bits;
1563: do_put_mem_word (addr, do_get_mem_word (addr) ^ fgpen);
1564: }
1565: break;
1566: case 3:
1567: {
1568: uae_u32 *addr = (uae_u32 *)(uae_mem2 + bits * 3);
1569: do_put_mem_long (addr, do_get_mem_long (addr) ^ (fgpen & 0x00FFFFFF));
1570: }
1571: break;
1572: case 4:
1573: {
1574: uae_u32 *addr = ((uae_u32 *)uae_mem2) + bits;
1575: do_put_mem_long (addr, do_get_mem_long (addr) ^ fgpen);
1576: }
1577: break;
1578: }
1579: }
1580: break;
1581: }
1582: }
1583: }
1584: }
1585:
1586: frame_buffer_UAM = ri.Memory + X*picasso96_state.BytesPerPixel + Y*ri.BytesPerRow;
1587: if (renderinfo_is_current_screen (&ri))
1588: do_blit (frame_buffer_UAM, ri.BytesPerRow, 0, 0, X, Y, W, H, 0);
1589:
1590: return 1;
1591: }
1592:
1593: /*
1594: * CalculateBytesPerRow:
1595: * a0: struct BoardInfo
1596: * d0: uae_u16 Width
1597: * d7: RGBFTYPE RGBFormat
1598: * This function calculates the amount of bytes needed for a line of
1599: * "Width" pixels in the given RGBFormat.
1600: */
1601: uae_u32 picasso_CalculateBytesPerRow (void)
1602: {
1603: uae_u16 width = m68k_dreg(regs, 0);
1604: uae_u32 type = m68k_dreg(regs, 7);
1605:
1606: width = GetBytesPerPixel(type)*width;
1607: /*MyOutputDebugString ("CalculateBytesPerRow() = %d\n",width); */
1608:
1609: return width;
1610: }
1611:
1612: /*
1613: * SetDisplay:
1614: * a0: struct BoardInfo
1615: * d0: BOOL state
1616: * This function enables and disables the video display.
1617: *
1618: * NOTE: return the opposite of the state
1619: */
1620: uae_u32 picasso_SetDisplay (void)
1621: {
1622: uae_u32 state = m68k_dreg(regs, 0);
1623: /*MyOutputDebugString ("SetDisplay(%d)\n", state);*/
1624: return !state;
1625: }
1626:
1627: /*
1628: * WaitVerticalSync:
1629: * a0: struct BoardInfo
1630: * This function waits for the next horizontal retrace.
1631: */
1632: uae_u32 picasso_WaitVerticalSync (void)
1633: {
1634: /*MyOutputDebugString ("WaitVerticalSync()\n");*/
1635: return 1;
1636: }
1637:
1638: /* NOTE: Watch for those planeptrs of 0x00000000 and 0xFFFFFFFF for all zero / all one bitmaps !!!! */
1639: static void PlanarToChunky(struct RenderInfo *ri, struct BitMap *bm, long srcx, long srcy,
1640: long dstx, long dsty, long width, long height, uae_u8 mask)
1641: {
1642: int j, bits;
1643:
1644: uae_u8 *PLANAR[8], *image = ri->Memory + dstx * GetBytesPerPixel (ri->RGBFormat) + dsty*ri->BytesPerRow;
1645: int Depth = bm->Depth;
1646: uae_u16 rows, total_bits, value, bitoffset = srcx & 7;
1647: long eol_offset;
1648:
1649: /* if (mask != 0xFF)
1650: MyOutputDebugString ("P2C - pixel-width = %d, bit-offset = %d\n", width, bitoffset); */
1651:
1652: /* Set up our bm->Planes[] pointers to the right horizontal offset */
1653: for (j = 0; j < Depth; j++) {
1654: uae_u8 *p = bm->Planes[j];
1655: if (p != &all_zeros_bitmap && p != &all_ones_bitmap)
1656: p += srcx/8 + srcy*bm->BytesPerRow;
1657: PLANAR[j] = p;
1658: if ((mask & (1 << j)) == 0)
1659: PLANAR[j] = &all_zeros_bitmap;
1660: }
1661: eol_offset = (long)bm->BytesPerRow - ((width + 7) >> 3);
1662: for (rows = 0; rows < height; rows++, image += ri->BytesPerRow) {
1663: long cols;
1664:
1665: for (cols = 0; cols < width; cols += 8) {
1666: int k;
1667: uae_u32 a = 0, b = 0;
1668: unsigned int msk = 0xFF;
1669: long tmp = cols + 8 - width;
1670: if (tmp > 0) {
1671: msk <<= tmp;
1672: b = do_get_mem_long ((uae_u32 *)(image + cols + 4));
1673: if (tmp < 4)
1674: b &= 0xFFFFFFFF >> (32 - tmp * 8);
1675: else if (tmp > 4) {
1676: a = do_get_mem_long ((uae_u32 *)(image + cols));
1677: a &= 0xFFFFFFFF >> (64 - tmp * 8);
1678: }
1679: }
1680: for (k = 0; k < Depth; k++) {
1681: unsigned int data;
1682: if (PLANAR[k] == &all_zeros_bitmap)
1683: data = 0;
1684: else if (PLANAR[k] == &all_ones_bitmap)
1685: data = 0xFF;
1686: else {
1687: data = (uae_u8)(do_get_mem_word ((uae_u16 *)PLANAR[k]) >> (8 - bitoffset));
1688: PLANAR[k]++;
1689: }
1690: data &= msk;
1691: a |= p2ctab[data][0] << k;
1692: b |= p2ctab[data][1] << k;
1693: }
1694: do_put_mem_long ((uae_u32 *)(image + cols), a);
1695: do_put_mem_long ((uae_u32 *)(image + cols + 4), b);
1696: }
1697: for (j = 0; j < Depth; j++) {
1698: if (PLANAR[j] != &all_zeros_bitmap && PLANAR[j] != &all_ones_bitmap) {
1699: PLANAR[j] += eol_offset;
1700: }
1701: }
1702: }
1703: }
1704:
1705: /*
1706: * BlitPlanar2Chunky:
1707: * a0: struct BoardInfo *bi
1708: * a1: struct BitMap *bm - source containing planar information and assorted details
1709: * a2: struct RenderInfo *ri - dest area and its details
1710: * d0.w: SrcX
1711: * d1.w: SrcY
1712: * d2.w: DstX
1713: * d3.w: DstY
1714: * d4.w: SizeX
1715: * d5.w: SizeY
1716: * d6.b: MinTerm - uh oh!
1717: * d7.b: Mask - uh oh!
1718: *
1719: * This function is currently used to blit from planar bitmaps within system memory to chunky bitmaps
1720: * on the board. Watch out for plane pointers that are 0x00000000 (represents a plane with all bits "0")
1721: * or 0xffffffff (represents a plane with all bits "1").
1722: */
1723: uae_u32 picasso_BlitPlanar2Chunky (void)
1724: {
1725: uaecptr bi = m68k_areg(regs, 0);
1726: uaecptr bm = m68k_areg(regs, 1);
1727: uaecptr ri = m68k_areg(regs, 2);
1728: uae_u16 srcx = m68k_dreg(regs, 0) & 0xFFFF;
1729: uae_u16 srcy = m68k_dreg(regs, 1) & 0xFFFF;
1730: uae_u16 dstx = m68k_dreg(regs, 2) & 0xFFFF;
1731: uae_u16 dsty = m68k_dreg(regs, 3) & 0xFFFF;
1732: uae_u16 width = m68k_dreg(regs, 4) & 0xFFFF;
1733: uae_u16 height = m68k_dreg(regs, 5) & 0xFFFF;
1734: uae_u8 minterm = m68k_dreg(regs, 6) & 0xFF;
1735: uae_u8 mask = m68k_dreg(regs, 7) & 0xFF;
1736: int i;
1737: struct RenderInfo local_ri;
1738: uae_u8 *uaebm = NULL;
1739: struct BitMap local_bm;
1740:
1741: wgfx_flushline ();
1742:
1743: if (minterm != 0x0C) {
1744: MyOutputDebugString ("ERROR - BlitPlanar2Chunky() has minterm 0x%x, which I don't handle. Using fall-back routine.\n",
1745: minterm);
1746: return 0;
1747: }
1748: if (!CopyRenderInfoStructureA2U(ri, &local_ri) || !CopyBitMapStructureA2U(bm, &local_bm))
1749: return 0;
1750:
1751: /*MyOutputDebugString ("BlitPlanar2Chunky(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n",
1752: srcx, srcy, dstx, dsty, width, height, minterm, mask, local_bm.Depth);
1753: MyOutputDebugString ("P2C - BitMap has %d BPR, %d rows\n", local_bm.BytesPerRow, local_bm.Rows); */
1754: PlanarToChunky(&local_ri, &local_bm, srcx, srcy, dstx, dsty, width, height, mask);
1755: if (renderinfo_is_current_screen (&local_ri))
1756: do_blit (local_ri.Memory + dstx * GetBytesPerPixel (local_ri.RGBFormat) + dsty * local_ri.BytesPerRow,
1757: local_ri.BytesPerRow,
1758: 0, 0, dstx, dsty, width, height, 0);
1759:
1760: return m68k_dreg(regs, 0);
1761: }
1762:
1763: /* NOTE: Watch for those planeptrs of 0x00000000 and 0xFFFFFFFF for all zero / all one bitmaps !!!! */
1764: static void PlanarToDirect(struct RenderInfo *ri, struct BitMap *bm,
1765: long srcx, long srcy, long dstx, long dsty,
1766: long width, long height, uae_u8 mask,
1767: struct ColorIndexMapping *cim)
1768: {
1769: int j;
1770: int bpp = GetBytesPerPixel(ri->RGBFormat);
1771: uae_u8 *PLANAR[8];
1772: uae_u8 *image = ri->Memory + dstx * bpp + dsty * ri->BytesPerRow;
1773: int Depth = bm->Depth;
1774: long rows;
1775: long eol_offset;
1776:
1777: /* Set up our bm->Planes[] pointers to the right horizontal offset */
1778: for (j = 0; j < Depth; j++) {
1779: uae_u8 *p = bm->Planes[j];
1780: if (p != &all_zeros_bitmap && p != &all_ones_bitmap)
1781: p += srcx/8 + srcy*bm->BytesPerRow;
1782: PLANAR[j] = p;
1783: if ((mask & (1 << j)) == 0)
1784: PLANAR[j] = &all_zeros_bitmap;
1785: }
1786:
1787: eol_offset = (long)bm->BytesPerRow - ((width + (srcx & 7)) >> 3);
1788: for (rows = 0; rows < height; rows++, image += ri->BytesPerRow) {
1789: long cols;
1790: uae_u8 *image2 = image;
1791: unsigned int bitoffs = 7 - (srcx & 7);
1792: int i;
1793:
1794: for (cols = 0; cols < width; cols ++) {
1795: int v = 0, k;
1796: for (k = 0; k < Depth; k++) {
1797: if (PLANAR[k] == &all_ones_bitmap)
1798: v |= 1 << k;
1799: else if (PLANAR[k] != &all_zeros_bitmap) {
1800: v |= ((*PLANAR[k] >> bitoffs) & 1) << k;
1801: }
1802: }
1803:
1804: switch (bpp) {
1805: case 2:
1806: do_put_mem_word ((uae_u16 *)image2, cim->Colors[v]);
1807: image2 += 2;
1808: break;
1809: case 3:
1810: do_put_mem_byte (image2++, cim->Colors[v] & 0x000000FF);
1811: do_put_mem_word ((uae_u16 *)image2, (cim->Colors[v] & 0x00FFFF00) >> 8);
1812: image2 += 2;
1813: break;
1814: case 4:
1815: do_put_mem_long ((uae_u32 *)image2, cim->Colors[v]);
1816: image2 += 4;
1817: break;
1818: }
1819: bitoffs--;
1820: bitoffs &= 7;
1821: if (bitoffs == 7) {
1822: int k;
1823: for (k = 0; k < Depth; k++) {
1824: if (PLANAR[k] != &all_zeros_bitmap && PLANAR[k] != &all_ones_bitmap) {
1825: PLANAR[k]++;
1826: }
1827: }
1828: }
1829: }
1830:
1831: for (i = 0; i < Depth; i++) {
1832: if (PLANAR[i] != &all_zeros_bitmap && PLANAR[i] != &all_ones_bitmap) {
1833: PLANAR[i] += eol_offset;
1834: }
1835: }
1836: }
1837: }
1838:
1839: /*
1840: * BlitPlanar2Direct:
1841: *
1842: * Synopsis:
1843: * BlitPlanar2Direct(bi, bm, ri, cim, SrcX, SrcY, DstX, DstY, SizeX, SizeY, MinTerm, Mask);
1844: * Inputs:
1845: * a0:struct BoardInfo *bi
1846: * a1:struct BitMap *bm
1847: * a2:struct RenderInfo *ri
1848: * a3:struct ColorIndexMapping *cmi
1849: * d0.w:SrcX
1850: * d1.w:SrcY
1851: * d2.w:DstX
1852: * d3.w:DstY
1853: * d4.w:SizeX
1854: * d5.w:SizeY
1855: * d6.b:MinTerm
1856: * d7.b:Mask
1857: *
1858: * This function is currently used to blit from planar bitmaps within system memory to direct color
1859: * bitmaps (15, 16, 24 or 32 bit) on the board. Watch out for plane pointers that are 0x00000000 (represents
1860: * a plane with all bits "0") or 0xffffffff (represents a plane with all bits "1"). The ColorIndexMapping is
1861: * used to map the color index of each pixel formed by the bits in the bitmap's planes to a direct color value
1862: * which is written to the destination RenderInfo. The color mask and all colors within the mapping are words,
1863: * triple bytes or longwords respectively similar to the color values used in FillRect(), BlitPattern() or
1864: * BlitTemplate().
1865: */
1866: uae_u32 picasso_BlitPlanar2Direct (void)
1867: {
1868: uaecptr bi = m68k_areg(regs, 0);
1869: uaecptr bm = m68k_areg(regs, 1);
1870: uaecptr ri = m68k_areg(regs, 2);
1871: uaecptr cim = m68k_areg(regs, 3);
1872: uae_u16 srcx = m68k_dreg(regs, 0);
1873: uae_u16 srcy = m68k_dreg(regs, 1);
1874: uae_u16 dstx = m68k_dreg(regs, 2);
1875: uae_u16 dsty = m68k_dreg(regs, 3);
1876: uae_u16 width = m68k_dreg(regs, 4);
1877: uae_u16 height = m68k_dreg(regs, 5);
1878: uae_u8 minterm = m68k_dreg(regs, 6);
1879: uae_u8 Mask = m68k_dreg(regs, 7);
1880: struct RenderInfo local_ri;
1881: uae_u8 *uaebm = NULL;
1882: struct BitMap local_bm;
1883: struct ColorIndexMapping local_cim;
1884:
1885: wgfx_flushline ();
1886:
1887: if (minterm != 0x0C) {
1888: MyOutputDebugString ("ERROR - BlitPlanar2Direct() has op-code 0x%x, which I don't handle. Using fall-back routine.\n",
1889: minterm);
1890: return 0;
1891: }
1892: if (Mask != 0xFF) {
1893: MyOutputDebugString ("ERROR - Unsupported Mask value 0x%x in BlitPlanar2Direct(), using fallback method.\n", Mask);
1894: return 0;
1895: }
1896: if (!CopyRenderInfoStructureA2U (ri, &local_ri) || !CopyBitMapStructureA2U (bm, &local_bm))
1897: return 0;
1898:
1899: CopyColorIndexMappingA2U (cim, &local_cim);
1900: /* MyOutputDebugString ("BlitPlanar2Direct(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n",
1901: srcx, srcy, dstx, dsty, width, height, minterm, Mask, local_bm.Depth); */
1902: PlanarToDirect(&local_ri, &local_bm, srcx, srcy, dstx, dsty, width, height, Mask, &local_cim);
1903: if (renderinfo_is_current_screen (&local_ri))
1904: do_blit (local_ri.Memory + dstx * GetBytesPerPixel (local_ri.RGBFormat) + dsty * local_ri.BytesPerRow,
1905: local_ri.BytesPerRow,
1906: 0, 0, dstx, dsty, width, height, 0);
1907: return 1;
1908: }
1909:
1910: /* @@@ - Work to be done here!
1911: *
1912: * The address is the offset into our Picasso96 frame-buffer (pointed to by gfxmem_start)
1913: * where the value was put.
1914: *
1915: * Porting work: on some machines you may not need these functions, ie. if the memory for the
1916: * Picasso96 frame-buffer is directly viewable or directly blittable. On Win32 with DirectX,
1917: * this is not the case. So I provide some write-through functions (as per Mathias' orders!)
1918: */
1919: static void write_gfx_long (uaecptr addr, uae_u32 value)
1920: {
1921: uaecptr oldaddr = addr;
1922: int x, xbytes, y;
1923: uae_u8 *dst;
1924:
1925: if (!picasso_on)
1926: return;
1927:
1928: /*
1929: * Several writes to successive memory locations are a common access pattern.
1930: * Try to optimize it.
1931: */
1932: if (addr >= wgfx_linestart && addr + 4 <= wgfx_lineend) {
1933: if (addr < wgfx_min)
1934: wgfx_min = addr;
1935: if (addr + 4 > wgfx_max)
1936: wgfx_max = addr + 4;
1937: return;
1938: } else
1939: wgfx_flushline ();
1940:
1941: addr += gfxmem_start;
1942: /* Check to see if this needs to be written through to the display, or was it an "offscreen" area? */
1943: if (addr < picasso96_state.Address || addr + 4 > picasso96_state.Extent)
1944: return;
1945:
1946: addr -= picasso96_state.Address;
1947: y = addr / picasso96_state.BytesPerRow;
1948:
1949: #if 0
1950: DX_Invalidate (y, y);
1951: if (! picasso_vidinfo.extra_mem)
1952: return;
1953:
1954: xbytes = addr - y * picasso96_state.BytesPerRow;
1955: x = xbytes / picasso96_state.BytesPerPixel;
1956:
1957: if (x < picasso96_state.Width && y < picasso96_state.Height) {
1958: dst = lockscr();
1959: if (dst) {
1960: do_put_mem_long ((uae_u32 *)(dst + y * picasso_vidinfo.rowbytes + xbytes), value);
1961: unlockscr();
1962: }
1963: }
1964: #else
1965: if (y >= picasso96_state.Height)
1966: return;
1967: wgfx_linestart = picasso96_state.Address - gfxmem_start + y * picasso96_state.BytesPerRow;
1968: wgfx_lineend = wgfx_linestart + picasso96_state.BytesPerRow;
1969: wgfx_y = y;
1970: wgfx_min = oldaddr;
1971: wgfx_max = oldaddr + 4;
1972: #endif
1973: }
1974:
1975: static void write_gfx_word (uaecptr addr, uae_u16 value)
1976: {
1977: uaecptr oldaddr = addr;
1978: int x, xbytes, y;
1979: uae_u8 *dst;
1980:
1981: if (!picasso_on)
1982: return;
1983:
1984: /*
1985: * Several writes to successive memory locations are a common access pattern.
1986: * Try to optimize it.
1987: */
1988: if (addr >= wgfx_linestart && addr + 2 <= wgfx_lineend) {
1989: if (addr < wgfx_min)
1990: wgfx_min = addr;
1991: if (addr + 2 > wgfx_max)
1992: wgfx_max = addr + 2;
1993: return;
1994: } else
1995: wgfx_flushline ();
1996:
1997: addr += gfxmem_start;
1998: /* Check to see if this needs to be written through to the display, or was it an "offscreen" area? */
1999: if (addr < picasso96_state.Address || addr + 2 > picasso96_state.Extent)
2000: return;
2001:
2002: addr -= picasso96_state.Address;
2003: y = addr / picasso96_state.BytesPerRow;
2004:
2005: #if 0
2006: DX_Invalidate (y, y);
2007: if (! picasso_vidinfo.extra_mem)
2008: return;
2009:
2010: xbytes = addr - y * picasso96_state.BytesPerRow;
2011: x = xbytes / picasso96_state.BytesPerPixel;
2012:
2013: if (x < picasso96_state.Width && y < picasso96_state.Height) {
2014: dst = lockscr();
2015: if (dst) {
2016: do_put_mem_word ((uae_u16 *)(dst + y * picasso_vidinfo.rowbytes + xbytes), value);
2017: unlockscr();
2018: }
2019: }
2020: #else
2021: if (y >= picasso96_state.Height)
2022: return;
2023: wgfx_linestart = picasso96_state.Address - gfxmem_start + y * picasso96_state.BytesPerRow;
2024: wgfx_lineend = wgfx_linestart + picasso96_state.BytesPerRow;
2025: wgfx_y = y;
2026: wgfx_min = oldaddr;
2027: wgfx_max = oldaddr + 2;
2028: #endif
2029: }
2030:
2031: static void write_gfx_byte (uaecptr addr, uae_u8 value)
2032: {
2033: uaecptr oldaddr = addr;
2034: int x, xbytes, y;
2035: uae_u8 *dst;
2036:
2037: if (!picasso_on)
2038: return;
2039:
2040: /*
2041: * Several writes to successive memory locations are a common access pattern.
2042: * Try to optimize it.
2043: */
2044: if (addr >= wgfx_linestart && addr + 4 <= wgfx_lineend) {
2045: if (addr < wgfx_min)
2046: wgfx_min = addr;
2047: if (addr + 1 > wgfx_max)
2048: wgfx_max = addr + 1;
2049: return;
2050: } else
2051: wgfx_flushline ();
2052:
2053: addr += gfxmem_start;
2054: /* Check to see if this needs to be written through to the display, or was it an "offscreen" area? */
2055: if (addr < picasso96_state.Address || addr + 1 > picasso96_state.Extent)
2056: return;
2057:
2058: addr -= picasso96_state.Address;
2059: y = addr / picasso96_state.BytesPerRow;
2060:
2061: #if 0
2062: DX_Invalidate (y, y);
2063: if (! picasso_vidinfo.extra_mem)
2064: return;
2065:
2066: xbytes = addr - y * picasso96_state.BytesPerRow;
2067: x = xbytes / picasso96_state.BytesPerPixel;
2068:
2069: if (x < picasso96_state.Width && y < picasso96_state.Height) {
2070: dst = lockscr();
2071: if (dst) {
2072: *(uae_u8 *)(dst + y * picasso_vidinfo.rowbytes + xbytes) = value;
2073: unlockscr();
2074: }
2075: }
2076: #else
2077: if (y >= picasso96_state.Height)
2078: return;
2079: wgfx_linestart = picasso96_state.Address - gfxmem_start + y * picasso96_state.BytesPerRow;
2080: wgfx_lineend = wgfx_linestart + picasso96_state.BytesPerRow;
2081: wgfx_y = y;
2082: wgfx_min = oldaddr;
2083: wgfx_max = oldaddr + 1;
2084: #endif
2085: }
2086:
2087: static uae_u32 REGPARAM2 gfxmem_lget (uaecptr addr)
2088: {
2089: uae_u32 *m;
2090: addr -= gfxmem_start & gfxmem_mask;
2091: addr &= gfxmem_mask;
2092: m = (uae_u32 *)(gfxmemory + addr);
2093: return do_get_mem_long(m);
2094: }
2095:
2096: static uae_u32 REGPARAM2 gfxmem_wget (uaecptr addr)
2097: {
2098: uae_u16 *m;
2099: addr -= gfxmem_start & gfxmem_mask;
2100: addr &= gfxmem_mask;
2101: m = (uae_u16 *)(gfxmemory + addr);
2102: return do_get_mem_word(m);
2103: }
2104:
2105: static uae_u32 REGPARAM2 gfxmem_bget (uaecptr addr)
2106: {
2107: addr -= gfxmem_start & gfxmem_mask;
2108: addr &= gfxmem_mask;
2109: return gfxmemory[addr];
2110: }
2111:
2112: static void REGPARAM2 gfxmem_lput (uaecptr addr, uae_u32 l)
2113: {
2114: uae_u32 *m;
2115: addr -= gfxmem_start & gfxmem_mask;
2116: addr &= gfxmem_mask;
2117: m = (uae_u32 *)(gfxmemory + addr);
2118: do_put_mem_long(m, l);
2119:
2120: /* write the long-word to our displayable memory */
2121: write_gfx_long(addr, l);
2122: }
2123:
2124: static void REGPARAM2 gfxmem_wput (uaecptr addr, uae_u32 w)
2125: {
2126: uae_u16 *m;
2127: addr -= gfxmem_start & gfxmem_mask;
2128: addr &= gfxmem_mask;
2129: m = (uae_u16 *)(gfxmemory + addr);
2130: do_put_mem_word(m, (uae_u16)w);
2131:
2132: /* write the word to our displayable memory */
2133: write_gfx_word(addr, (uae_u16)w);
2134: }
2135:
2136: static void REGPARAM2 gfxmem_bput (uaecptr addr, uae_u32 b)
2137: {
2138: addr -= gfxmem_start & gfxmem_mask;
2139: addr &= gfxmem_mask;
2140: gfxmemory[addr] = b;
2141:
2142: /* write the byte to our displayable memory */
2143: write_gfx_byte(addr, (uae_u8)b);
2144: }
2145:
2146: static int REGPARAM2 gfxmem_check (uaecptr addr, uae_u32 size)
2147: {
2148: addr -= gfxmem_start & gfxmem_mask;
2149: addr &= gfxmem_mask;
2150: return (addr + size) < gfxmem_size;
2151: }
2152:
2153: static uae_u8 REGPARAM2 *gfxmem_xlate (uaecptr addr)
2154: {
2155: addr -= gfxmem_start & gfxmem_mask;
2156: addr &= gfxmem_mask;
2157: return gfxmemory + addr;
2158: }
2159:
2160: addrbank gfxmem_bank = {
2161: gfxmem_lget, gfxmem_wget, gfxmem_bget,
2162: gfxmem_lput, gfxmem_wput, gfxmem_bput,
2163: gfxmem_xlate, gfxmem_check
2164: };
2165:
2166: static int resolution_compare (const void *a, const void *b)
2167: {
2168: struct PicassoResolution *ma = (struct PicassoResolution *)a;
2169: struct PicassoResolution *mb = (struct PicassoResolution *)b;
2170: if (ma->res.width > mb->res.width)
2171: return -1;
2172: if (ma->res.width < mb->res.width)
2173: return 1;
2174: if (ma->res.height > mb->res.height)
2175: return -1;
2176: if (ma->res.height < mb->res.height)
2177: return 1;
2178: return ma->depth - mb->depth;
2179: }
2180: /* Call this function first, near the beginning of code flow
2181: * NOTE: Don't stuff it in InitGraphics() which seems reasonable...
2182: * Instead, put it in customreset() for safe-keeping. */
2183: void InitPicasso96 (void)
2184: {
2185: static int first_time = 1;
2186:
2187: if (first_time) {
2188: int i;
2189:
2190: for (i = 0; i < 256; i++) {
2191: p2ctab[i][0] = (((i & 128) ? 0x01000000 : 0)
2192: | ((i & 64) ? 0x010000 : 0)
2193: | ((i & 32) ? 0x0100 : 0)
2194: | ((i & 16) ? 0x01 : 0));
2195: p2ctab[i][1] = (((i & 8) ? 0x01000000 : 0)
2196: | ((i & 4) ? 0x010000 : 0)
2197: | ((i & 2) ? 0x0100 : 0)
2198: | ((i & 1) ? 0x01 : 0));
2199: }
2200: #if 0
2201: /* If we have some gfxmem settings, then we want Picasso96 support */
2202: if (gfxmem_size > 0) {
2203: gfxmem_mask = gfxmem_size - 1;
2204: gfxmemory = (uae_u8 *)xmalloc (gfxmem_size);
2205: map_banks(&gfxmem_bank, 0x800, gfxmem_size >> 16);
2206: }
2207: #endif
2208: memset(&picasso96_state, 0, sizeof(struct picasso96_state_struct));
2209: mode_count = DX_FillResolutions (&picasso96_pixel_format);
2210: qsort (DisplayModes, mode_count, sizeof (struct PicassoResolution),
2211: resolution_compare);
2212:
2213: for (i = 0; i < mode_count; i++) {
2214: sprintf(DisplayModes[i].name, "%dx%d, %d-bit, %d Hz",
2215: DisplayModes[i].res.width, DisplayModes[i].res.height,
2216: DisplayModes[i].depth * 8, DisplayModes[i].refresh);
2217: switch (DisplayModes[i].depth) {
2218: case 1:
2219: if (DisplayModes[i].res.width > chunky.width)
2220: chunky.width = DisplayModes[i].res.width;
2221: if (DisplayModes[i].res.height > chunky.height)
2222: chunky.height = DisplayModes[i].res.height;
2223: break;
2224: case 2:
2225: if (DisplayModes[i].res.width > hicolour.width)
2226: hicolour.width = DisplayModes[i].res.width;
2227: if (DisplayModes[i].res.height > hicolour.height)
2228: hicolour.height = DisplayModes[i].res.height;
2229: break;
2230: case 3:
2231: if (DisplayModes[i].res.width > truecolour.width)
2232: truecolour.width = DisplayModes[i].res.width;
2233: if (DisplayModes[i].res.height > truecolour.height)
2234: truecolour.height = DisplayModes[i].res.height;
2235: break;
2236: case 4:
2237: if (DisplayModes[i].res.width > alphacolour.width)
2238: alphacolour.width = DisplayModes[i].res.width;
2239: if (DisplayModes[i].res.height > alphacolour.height)
2240: alphacolour.height = DisplayModes[i].res.height;
2241: break;
2242: }
2243: }
2244: ShowSupportedResolutions();
2245:
2246: first_time = 0;
2247: }
2248:
2249: if (gfxmem_size > 0) {
2250: memset(&picasso96_state, 0, sizeof(struct picasso96_state_struct));
2251: }
2252: }
2253:
2254: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.