rtarea_base = base;
}
}
+
+uaecptr makedatatable (uaecptr resid, uaecptr resname, uae_u8 type, uae_s8 priority, uae_u16 ver, uae_u16 rev)
+{
+ uaecptr datatable = here ();
+
+ dw (0xE000); /* INITBYTE */
+ dw (0x0008); /* LN_TYPE */
+ dw (type << 8);
+ dw (0xE000); /* INITBYTE */
+ dw (0x0009); /* LN_PRI */
+ dw (priority << 8);
+ dw (0xC000); /* INITLONG */
+ dw (0x000A); /* LN_NAME */
+ dl (resname);
+ dw (0xE000); /* INITBYTE */
+ dw (0x000E); /* LIB_FLAGS */
+ dw (0x0600); /* LIBF_SUMUSED | LIBF_CHANGED */
+ dw (0xD000); /* INITWORD */
+ dw (0x0014); /* LIB_VERSION */
+ dw (ver);
+ dw (0xD000); /* INITWORD */
+ dw (0x0016); /* LIB_REVISION */
+ dw (rev);
+ dw (0xC000); /* INITLONG */
+ dw (0x0018); /* LIB_IDSTRING */
+ dl (resid);
+ dw (0x0000); /* end of table */
+ return datatable;
+}
+
dw (0xE000); /* INITBYTE */
dw (0x0008); /* LN_TYPE */
dw (0x0900); /* NT_LIBRARY */
+ dw (0xE000); /* INITBYTE */
+ dw (0x0009); /* LN_PRI */
+ dw (0xCE00); /* -50 */
dw (0xC000); /* INITLONG */
dw (0x000A); /* LN_NAME */
dl (resname);
bogusframe = 1;
sprite_buffer_res = (currprefs.chipset_mask & CSMASK_AGA) ? RES_SUPERHIRES : RES_LORES;
+ if (sprite_buffer_res > currprefs.gfx_resolution)
+ sprite_buffer_res = currprefs.gfx_resolution;
if (savestate_state == STATE_RESTORE) {
uae_u16 v;
uae_u32 vv;
/* OCS/ECS color lookup table. */
xcolnr xcolors[4096];
-static uae_u8 spritepixels[MAX_PIXELS_PER_LINE * 4]; /* used when sprite resolution > lores */
+static uae_u8 spritepixels[MAX_PIXELS_PER_LINE * 5]; /* used when sprite resolution > lores */
+static int sprite_aga_first_x, sprite_aga_last_x;
#ifdef AGA
/* AGA mode color lookup tables */
unpainted = visible_left_border < playfield_start ? 0 : visible_left_border - playfield_start;
src_pixel = MAX_PIXELS_PER_LINE + res_shift_from_window (playfield_start - native_ddf_left + unpainted);
- if (seen_sprites) {
+ if (sprite_aga_first_x < sprite_aga_last_x) {
+ uae_u8 *p = spritepixels + sprite_aga_first_x;
+ int len = sprite_aga_last_x - sprite_aga_first_x + 1;
+ int i;
/* clear previous sprite data storage line */
- memset (spritepixels, 0, sizeof (spritepixels));
- seen_sprites = 0;
+ for (i = 0; i < (1 << (res_shift < 0 ? 0 : res_shift)); i++) {
+ memset (p, 0, len);
+ p += MAX_PIXELS_PER_LINE;
+ }
+ sprite_aga_last_x = 0;
+ sprite_aga_first_x = MAX_PIXELS_PER_LINE;
}
+ seen_sprites = 0;
if (dip_for_drawing->nr_sprites == 0)
return;
- if (seen_sprites < 0)
- memset (spritepixels, 0, sizeof (spritepixels));
+ if (seen_sprites < 0 && sprite_buffer_res > 0)
+ memset (spritepixels, 0, sizeof spritepixels);
seen_sprites = 1;
/* Must clear parts of apixels. */
if (linetoscr_diw_start < native_ddf_left) {
else if (posdoubling)
window_pos <<= posdoubling;
window_pos += pixels_offset;
-
+ if (aga) {
+ if (window_pos < sprite_aga_first_x)
+ sprite_aga_first_x = window_pos;
+ }
for (pos = e->pos; pos < e->max; pos += 1 << sizeskip) {
int maskshift, plfmask;
unsigned int v = buf[pos];
}
}
+ if (aga) {
+ if (window_pos > sprite_aga_last_x)
+ sprite_aga_last_x = window_pos;
+ }
}
STATIC_INLINE void draw_sprites_1 (struct sprite_entry *e, int ham, int dualpf,
int doubling, int skip, int has_attach)
extern void calltrap (uae_u32);
extern void org (uae_u32);
extern uae_u32 here (void);
+extern uaecptr makedatatable (uaecptr resid, uaecptr resname, uae_u8 type, uae_s8 priority, uae_u16 ver, uae_u16 rev);
#define deftrap(f) define_trap((f), 0, "")
#define deftrap2(f, mode, str) define_trap((f), (mode), (str))
extern struct mnemolookup {
instrmnem mnemo;
const char *name;
+ const char *friendlyname;
} lookuptab[];
ENUMDECL {
custmem1 = 0;
custmem2 = 0;
+ init_mem_banks ();
+
kickmemory = mapped_malloc (0x80000, "kick");
memset (kickmemory, 0, 0x80000);
kickmem_bank.baseaddr = kickmemory;
hrtmon_load();
#endif
#endif
-
- init_mem_banks ();
}
void memory_cleanup (void)
if (currprefs.cpu_model == 68060) {
regs.pcr = currprefs.fpu_model ? MC68060_PCR : MC68EC060_PCR;
regs.pcr |= (currprefs.cpu060_revision & 0xff) << 8;
- regs.pcr |= 2;
+ regs.pcr |= 2; /* disable FPU */
}
fill_prefetch_slow (®s);
}
{ "T ","F ","HI","LS","CC","CS","NE","EQ",
"VC","VS","PL","MI","GE","LT","GT","LE" };
+static void addmovemreg (char *out, int *prevreg, int *lastreg, int *first, int reg)
+{
+ char *p = out + strlen (out);
+ if (*prevreg < 0) {
+ *prevreg = reg;
+ *lastreg = reg;
+ return;
+ }
+ if ((*prevreg) + 1 != reg || (reg & 8) != ((*prevreg & 8))) {
+ sprintf (p, "%s%c%d", (*first) ? "" : "/", (*lastreg) < 8 ? 'D' : 'A', (*lastreg) & 7);
+ p = p + strlen (p);
+ if ((*lastreg) + 2 == reg) {
+ sprintf (p, "/%c%d", (*prevreg) < 8 ? 'D' : 'A', (*prevreg) & 7);
+ } else if ((*lastreg) != (*prevreg)) {
+ sprintf (p, "-%c%d", (*prevreg) < 8 ? 'D' : 'A', (*prevreg) & 7);
+ }
+ *lastreg = reg;
+ *first = 0;
+ }
+ *prevreg = reg;
+}
+
+static void movemout (char *out, uae_u16 mask, int mode)
+{
+ unsigned int dmask, amask;
+ int prevreg = -1, lastreg = -1, first = 1;
+ if (mode == Apdi) {
+ int i;
+ uae_u8 dmask2 = (mask >> 8) & 0xff;
+ uae_u8 amask2 = mask & 0xff;
+ dmask = 0;
+ amask = 0;
+ for (i = 0; i < 8; i++) {
+ if (dmask2 & (1 << i))
+ dmask |= 1 << (7 - i);
+ if (amask2 & (1 << i))
+ amask |= 1 << (7 - i);
+ }
+ } else {
+ dmask = mask & 0xff;
+ amask = (mask >> 8) & 0xff;
+ }
+ while (dmask) { addmovemreg (out, &prevreg, &lastreg, &first, movem_index1[dmask]); dmask = movem_next[dmask]; }
+ while (amask) { addmovemreg (out, &prevreg, &lastreg, &first, movem_index1[amask] + 8); amask = movem_next[amask]; }
+ addmovemreg (out, &prevreg, &lastreg, &first, -1);
+}
+
+static void disasm_size (char *instrname, struct instr *dp)
+{
+#if 0
+ int i, size;
+ uae_u16 mnemo = dp->mnemo;
+
+ size = dp->size;
+ for (i = 0; i < 65536; i++) {
+ struct instr *in = &table68k[i];
+ if (in->mnemo == mnemo && in != dp) {
+ if (size != in->size)
+ break;
+ }
+ }
+ if (i == 65536)
+ size = -1;
+#endif
+ switch (dp->size)
+ {
+ case sz_byte:
+ strcat (instrname, ".B ");
+ break;
+ case sz_word:
+ strcat (instrname, ".W ");
+ break;
+ case sz_long:
+ strcat (instrname, ".L ");
+ break;
+ default:
+ strcat (instrname, " ");
+ break;
+ }
+}
+
void m68k_disasm_2 (char *buf, int bufsize, uaecptr addr, uaecptr *nextpc, int cnt, uae_u32 *seaddr, uae_u32 *deaddr, int safemode)
{
uaecptr newpc = 0;
m68kpc_offset += 2;
- strcpy (instrname, lookup->name);
+ if (lookup->friendlyname)
+ strcpy (instrname, lookup->friendlyname);
+ else
+ strcpy (instrname, lookup->name);
ccpt = strstr (instrname, "cc");
if (ccpt != 0) {
strncpy (ccpt, ccnames[dp->cc], 2);
}
- switch (dp->size){
- case sz_byte: strcat (instrname, ".B "); break;
- case sz_word: strcat (instrname, ".W "); break;
- case sz_long: strcat (instrname, ".L "); break;
- default: strcat (instrname, " "); break;
- }
+ disasm_size (instrname, dp);
if (lookup->mnemo == i_MOVEC2 || lookup->mnemo == i_MOVE2C) {
- uae_u16 imm = get_iword_1 (m68kpc_offset) & 0xffff;
+ uae_u16 imm = get_iword_1 (m68kpc_offset);
uae_u16 creg = imm & 0x0fff;
uae_u16 r = imm >> 12;
char regs[16], *cname = "?";
strcat (instrname, regs);
}
m68kpc_offset += 2;
+ } else if (lookup->mnemo == i_MVMEL) {
+ newpc = m68k_getpc (®s) + m68kpc_offset;
+ newpc += ShowEA (0, opcode, dp->dreg, dp->dmode, dp->size, instrname, deaddr, safemode);
+ strcat (instrname, ",");
+ movemout (instrname, get_iword_1 (m68kpc_offset), dp->dmode);
+ m68kpc_offset += 2;
+ } else if (lookup->mnemo == i_MVMLE) {
+ movemout (instrname, get_iword_1 (m68kpc_offset), dp->dmode);
+ strcat (instrname, ",");
+ newpc = m68k_getpc (®s) + m68kpc_offset;
+ newpc += ShowEA (0, opcode, dp->dreg, dp->dmode, dp->size, instrname, deaddr, safemode);
+ m68kpc_offset += 2;
} else {
if (dp->suse) {
newpc = m68k_getpc (®s) + m68kpc_offset;
{
char *buf;
- buf = (char*)malloc ((MAX_LINEWIDTH + 1) * cnt);
+ buf = malloc ((MAX_LINEWIDTH + 1) * cnt);
if (!buf)
return;
m68k_disasm_2 (buf, (MAX_LINEWIDTH + 1) * cnt, addr, nextpc, cnt, seaddr, deaddr, 1);
{
char *buf;
- buf = (char*)malloc ((MAX_LINEWIDTH + 1) * cnt);
+ buf = malloc ((MAX_LINEWIDTH + 1) * cnt);
if (!buf)
return;
m68k_disasm_2 (buf, (MAX_LINEWIDTH + 1) * cnt, addr, nextpc, cnt, NULL, NULL, 0);
#include "zfile.h"
#include "gui.h"
#include "win32.h"
+#include <shlobj.h>
#include "ComType.h"
#include "CapsAPI.h"
int i;
HMODULE h;
struct CapsVersionInfo cvi;
+ char *dllname = "CAPSImg.dll";
if (init)
return 1;
- h = WIN32_LoadLibrary ("CAPSImg.dll");
+ h = WIN32_LoadLibrary (dllname);
if (!h) {
- if (noticed)
- return 0;
- notify_user (NUMSG_NOCAPS);
- noticed = 1;
- return 0;
+ char tmp[MAX_DPATH];
+ if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES_COMMON, NULL, 0, tmp))) {
+ strcat (tmp, "\\Software Preservation Society\\");
+ strcat (tmp, dllname);
+ h = LoadLibrary (tmp);
+ if (!h) {
+ if (noticed)
+ return 0;
+ notify_user (NUMSG_NOCAPS);
+ noticed = 1;
+ return 0;
+ }
+ }
}
if (GetProcAddress(h, "CAPSLockImageMemory") == 0 || GetProcAddress(h, "CAPSGetVersionInfo") == 0) {
if (noticed)
struct ddstuff dxdata;
static int flipinterval_supported = 1;
+int ddforceram = 0;
HRESULT DirectDraw_GetDisplayMode (void)
{
dxdata.backbuffers = 0;
}
-void DirectDraw_Release (void)
-{
- if (!dxdata.ddinit)
- return;
- dxdata.ddinit = 0;
- freemainsurface ();
- if (dxdata.fsmodeset)
- IDirectDraw7_RestoreDisplayMode (dxdata.maindd);
- dxdata.fsmodeset = 0;
- IDirectDraw7_SetCooperativeLevel (dxdata.maindd, dxdata.hwnd, DDSCL_NORMAL);
- releaser (dxdata.dclip, IDirectDrawClipper_Release);
- releaser (dxdata.maindd, IDirectDraw_Release);
- memset (&dxdata, 0, sizeof (dxdata));
-}
-
-int DirectDraw_Start (GUID *guid)
-{
- HRESULT ddrval;
- LPDIRECT3D9 d3d;
- D3DCAPS9 d3dCaps;
-
- if (dxdata.ddinit) {
- if (guid == NULL && dxdata.ddzeroguid)
- return -1;
- if (guid && !memcmp (guid, &dxdata.ddguid, sizeof (GUID)))
- return -1;
- DirectDraw_Release ();
- }
-
- ddrval = DirectDrawCreate (guid, &dxdata.olddd, NULL);
- if (FAILED(ddrval)) {
- if (guid != NULL)
- return 0;
- goto oops;
- }
- ddrval = IDirectDraw_QueryInterface (dxdata.olddd, &IID_IDirectDraw7, (LPVOID*)&dxdata.maindd);
- if(FAILED(ddrval)) {
- gui_message("start_ddraw(): DirectX 7 or newer required");
- DirectDraw_Release();
- return 0;
- }
-
- dxdata.maxwidth = 16384;
- dxdata.maxheight = 16384;
- d3d = Direct3DCreate9 (D3D9b_SDK_VERSION);
- if (d3d) {
- IDirect3D9_GetDeviceCaps (d3d, 0, D3DDEVTYPE_HAL, &d3dCaps);
- dxdata.maxwidth = d3dCaps.MaxTextureWidth;
- dxdata.maxheight = d3dCaps.MaxTextureHeight;
- write_log ("Max hardware surface size: %dx%d\n", dxdata.maxwidth, dxdata.maxheight);
- }
-
- if (SUCCEEDED (DirectDraw_GetDisplayMode ())) {
- dxdata.ddinit = 1;
- dxdata.ddzeroguid = 1;
- if (guid) {
- dxdata.ddzeroguid = 0;
- memcpy (&dxdata.ddguid, guid, sizeof (GUID));
- }
- return 1;
- }
- oops:
- write_log ("DirectDraw_Start: %s\n", DXError (ddrval));
- DirectDraw_Release();
- return 0;
-}
-
HRESULT restoresurface (LPDIRECTDRAWSURFACE7 surf)
{
HRESULT ddrval;
write_log ("IDirectDrawSurface7_Unlock: %s\n", DXError (ddrval));
}
-LPDIRECTDRAWSURFACE7 allocsurface (int width, int height)
+static char *alloctexts[] = { "NonLocalVRAM", "DefaultRAM", "VRAM", "RAM" };
+LPDIRECTDRAWSURFACE7 allocsurface_2 (int width, int height, int forcemode)
{
HRESULT ddrval;
- DDSURFACEDESC2 desc = { 0 };
+ DDSURFACEDESC2 desc;
LPDIRECTDRAWSURFACE7 surf;
+ memset (&desc, 0, sizeof desc);
desc.dwSize = sizeof (desc);
desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
- desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
- if (width > dxdata.maxwidth || height > dxdata.maxheight)
- desc.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
+ desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_NONLOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
+ if (forcemode >= DDFORCED_DEFAULT)
+ desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+ if (forcemode == DDFORCED_VIDMEM)
+ desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
+ if (width > dxdata.maxwidth || height > dxdata.maxheight || forcemode == DDFORCED_SYSMEM)
+ desc.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
desc.dwWidth = width;
desc.dwHeight = height;
memcpy (&desc.ddpfPixelFormat, &dxdata.native.ddpfPixelFormat, sizeof (DDPIXELFORMAT));
ddrval = IDirectDraw7_CreateSurface (dxdata.maindd, &desc, &surf, NULL);
if (FAILED (ddrval)) {
- write_log ("IDirectDraw7_CreateSurface: %s\n", DXError (ddrval));
+ write_log ("IDirectDraw7_CreateSurface (%dx%d,%s): %s\n", width, height, alloctexts[forcemode], DXError (ddrval));
} else {
- clearsurf (surf);
+ clearsurf (surf);
+ write_log ("Created %dx%d surface in %s (%d)\n", width, height, alloctexts[forcemode]);
}
return surf;
}
+
+LPDIRECTDRAWSURFACE7 allocsurface (int width, int height)
+{
+ LPDIRECTDRAWSURFACE7 s;
+ int mode = ddforceram;
+
+ for (;;) {
+ s = allocsurface_2 (width, height, mode);
+ if (s)
+ return s;
+ mode++;
+ if (mode >= 4)
+ mode = 0;
+ if (mode == ddforceram)
+ return NULL;
+ }
+}
+
void freesurface (LPDIRECTDRAWSURFACE7 surf)
{
if (surf)
return ddrval;
}
+void DirectDraw_Release (void)
+{
+ if (!dxdata.ddinit)
+ return;
+ dxdata.ddinit = 0;
+ freemainsurface ();
+ if (dxdata.fsmodeset)
+ IDirectDraw7_RestoreDisplayMode (dxdata.maindd);
+ dxdata.fsmodeset = 0;
+ IDirectDraw7_SetCooperativeLevel (dxdata.maindd, dxdata.hwnd, DDSCL_NORMAL);
+ releaser (dxdata.dclip, IDirectDrawClipper_Release);
+ releaser (dxdata.maindd, IDirectDraw_Release);
+ memset (&dxdata, 0, sizeof (dxdata));
+}
+
+int DirectDraw_Start (GUID *guid)
+{
+ HRESULT ddrval;
+ LPDIRECT3D9 d3d;
+ D3DCAPS9 d3dCaps;
+
+ if (dxdata.ddinit) {
+ if (guid == NULL && dxdata.ddzeroguid)
+ return -1;
+ if (guid && !memcmp (guid, &dxdata.ddguid, sizeof (GUID)))
+ return -1;
+ DirectDraw_Release ();
+ }
+
+ ddrval = DirectDrawCreate (guid, &dxdata.olddd, NULL);
+ if (FAILED(ddrval)) {
+ if (guid != NULL)
+ return 0;
+ goto oops;
+ }
+ ddrval = IDirectDraw_QueryInterface (dxdata.olddd, &IID_IDirectDraw7, (LPVOID*)&dxdata.maindd);
+ if(FAILED(ddrval)) {
+ gui_message("start_ddraw(): DirectX 7 or newer required");
+ DirectDraw_Release();
+ return 0;
+ }
+
+ dxdata.maxwidth = 16384;
+ dxdata.maxheight = 16384;
+ d3d = Direct3DCreate9 (D3D9b_SDK_VERSION);
+ if (d3d) {
+ IDirect3D9_GetDeviceCaps (d3d, 0, D3DDEVTYPE_HAL, &d3dCaps);
+ dxdata.maxwidth = d3dCaps.MaxTextureWidth;
+ dxdata.maxheight = d3dCaps.MaxTextureHeight;
+ write_log ("Max hardware surface size: %dx%d\n", dxdata.maxwidth, dxdata.maxheight);
+ if (dxdata.maxwidth < 2048)
+ dxdata.maxwidth = 2048;
+ if (dxdata.maxheight < 2048)
+ dxdata.maxheight = 2048;
+ }
+
+ if (SUCCEEDED (DirectDraw_GetDisplayMode ())) {
+ dxdata.ddinit = 1;
+ dxdata.ddzeroguid = 1;
+ if (guid) {
+ dxdata.ddzeroguid = 0;
+ memcpy (&dxdata.ddguid, guid, sizeof (GUID));
+ }
+ return 1;
+ }
+ oops:
+ write_log ("DirectDraw_Start: %s\n", DXError (ddrval));
+ DirectDraw_Release();
+ return 0;
+}
HRESULT DirectDraw_SetPalette (int remove);
HRESULT DirectDraw_CreatePalette (LPPALETTEENTRY pal);
+
+#define DDFORCED_NONLOCAL 0
+#define DDFORCED_DEFAULT 1
+#define DDFORCED_VIDMEM 2
+#define DDFORCED_SYSMEM 3
+
#endif
#include <setupapi.h> // for SetupDiXxx functions.
#include <cfgmgr32.h> // for SetupDiXxx functions.
#endif
+#include <stddef.h>
static int usefloppydrives = 0;
char orgname[1024];
PUCHAR p;
int i, j;
+ int size;
devDesc = (PSTORAGE_DEVICE_DESCRIPTOR) outBuf;
+ size = devDesc->Version;
p = (PUCHAR) outBuf;
+ if (offsetof(STORAGE_DEVICE_DESCRIPTOR, CommandQueueing) > size) {
+ write_log ("too short STORAGE_DEVICE_DESCRIPTOR only %d bytes\n", size);
+ return 1;
+ }
if (devDesc->DeviceType != INQ_DASD && devDesc->DeviceType != INQ_ROMD && devDesc->DeviceType != INQ_OPTD) {
write_log ("not a direct access device, ignored (type=%d)\n", devDesc->DeviceType);
return 1;
}
- if (devDesc->VendorIdOffset && p[devDesc->VendorIdOffset]) {
+ if (size > offsetof(STORAGE_DEVICE_DESCRIPTOR, VendorIdOffset) && devDesc->VendorIdOffset && p[devDesc->VendorIdOffset]) {
j = 0;
for (i = devDesc->VendorIdOffset; p[i] != (UCHAR) NULL && i < returnedLength; i++)
udi->vendor_id[j++] = p[i];
}
- if (devDesc->ProductIdOffset && p[devDesc->ProductIdOffset]) {
+ if (size > offsetof(STORAGE_DEVICE_DESCRIPTOR, ProductIdOffset) && devDesc->ProductIdOffset && p[devDesc->ProductIdOffset]) {
j = 0;
for (i = devDesc->ProductIdOffset; p[i] != (UCHAR) NULL && i < returnedLength; i++)
udi->product_id[j++] = p[i];
}
- if (devDesc->ProductRevisionOffset && p[devDesc->ProductRevisionOffset]) {
+ if (size > offsetof(STORAGE_DEVICE_DESCRIPTOR, ProductRevisionOffset) && devDesc->ProductRevisionOffset && p[devDesc->ProductRevisionOffset]) {
j = 0;
for (i = devDesc->ProductRevisionOffset; p[i] != (UCHAR) NULL && i < returnedLength; i++)
udi->product_rev[j++] = p[i];
}
- if (devDesc->SerialNumberOffset && p[devDesc->SerialNumberOffset]) {
+ if (size > offsetof(STORAGE_DEVICE_DESCRIPTOR, SerialNumberOffset) && devDesc->SerialNumberOffset && p[devDesc->SerialNumberOffset]) {
j = 0;
for (i = devDesc->SerialNumberOffset; p[i] != (UCHAR) NULL && i < returnedLength; i++)
udi->product_serial[j++] = p[i];
adpDesc = (PSTORAGE_ADAPTER_DESCRIPTOR) outBuf;
}
+ memset (outBuf, 0, sizeof outBuf);
query.PropertyId = StorageDeviceProperty;
query.QueryType = PropertyStandardQuery;
status = DeviceIoControl(
&query,
sizeof(STORAGE_PROPERTY_QUERY),
&outBuf,
- sizeof (outBuf),
+ sizeof outBuf,
&returnedLength,
NULL);
if (!status) {
static uae_u32 lowmem (void)
{
uae_u32 change = 0;
- if (currprefs.z3fastmem_size >= 8 * 1024 * 1024 && currprefs.gfxmem_size < 256 * 1024 * 1024) {
+ if (currprefs.z3fastmem_size >= 8 * 1024 * 1024 && currprefs.gfxmem_size < 64 * 1024 * 1024) {
change = currprefs.z3fastmem_size - currprefs.z3fastmem_size / 2;
currprefs.z3fastmem_size >>= 1;
changed_prefs.z3fastmem_size = currprefs.z3fastmem_size;
int init_shm (void)
{
int i;
- LPVOID blah = NULL;
uae_u32 size, totalsize, z3size, natmemsize, rtgbarrier, rtgextra;
+ int rounds = 0;
- if (natmem_offset)
- VirtualFree(natmem_offset, 0, MEM_RELEASE);
- natmem_offset = NULL;
- natmem_offset_end = NULL;
- canbang = 0;
-
- z3size = 0;
- size = 0x1000000;
- rtgextra = 0;
- rtgbarrier = si.dwPageSize;
- if (currprefs.cpu_model >= 68020)
- size = 0x10000000;
- if (currprefs.z3fastmem_size) {
- z3size = currprefs.z3fastmem_size + (currprefs.z3fastmem_start - 0x10000000);
- if (currprefs.gfxmem_size)
- rtgbarrier = 16 * 1024 * 1024;
- } else {
- rtgbarrier = 0;
- }
-
- totalsize = size + z3size + currprefs.gfxmem_size;
- while (totalsize > size64) {
- int change = lowmem ();
- if (!change)
+restart:
+ for (;;) {
+ LPVOID blah = NULL;
+ if (rounds > 0)
+ write_log ("NATMEM: retrying %d..\n", rounds);
+ rounds++;
+ if (natmem_offset)
+ VirtualFree(natmem_offset, 0, MEM_RELEASE);
+ natmem_offset = NULL;
+ natmem_offset_end = NULL;
+ canbang = 0;
+
+ z3size = 0;
+ size = 0x1000000;
+ rtgextra = 0;
+ rtgbarrier = si.dwPageSize;
+ if (currprefs.cpu_model >= 68020)
+ size = 0x10000000;
+ if (currprefs.z3fastmem_size) {
+ z3size = currprefs.z3fastmem_size + (currprefs.z3fastmem_start - 0x10000000);
+ if (currprefs.gfxmem_size)
+ rtgbarrier = 16 * 1024 * 1024;
+ } else {
+ rtgbarrier = 0;
+ }
+ totalsize = size + z3size + currprefs.gfxmem_size;
+ while (totalsize > size64) {
+ int change = lowmem ();
+ if (!change)
+ return 0;
+ totalsize -= change;
+ }
+ if ((rounds > 1 && totalsize < 0x10000000) || rounds > 20) {
+ write_log ("NATMEM: No special area could be allocated (3)!\n");
return 0;
- totalsize -= change;
- }
+ }
+ natmemsize = size + z3size;
- shm_start = 0;
- for (i = 0; i < MAX_SHMID; i++) {
- shmids[i].attached = 0;
- shmids[i].key = -1;
- shmids[i].size = 0;
- shmids[i].addr = NULL;
- shmids[i].name[0] = 0;
- }
- natmemsize = size + z3size;
- xfree (memwatchtable);
- memwatchtable = 0;
- if (currprefs.gfxmem_size) {
- if (!memwatchok) {
- write_log ("GetWriteWatch() not supported, using guard pages, performance will be slower.\n");
- memwatchtable = xcalloc (currprefs.gfxmem_size / si.dwPageSize + 1, 1);
+ shm_start = 0;
+ for (i = 0; i < MAX_SHMID; i++) {
+ shmids[i].attached = 0;
+ shmids[i].key = -1;
+ shmids[i].size = 0;
+ shmids[i].addr = NULL;
+ shmids[i].name[0] = 0;
+ }
+ xfree (memwatchtable);
+ memwatchtable = 0;
+ if (currprefs.gfxmem_size) {
+ if (!memwatchok) {
+ write_log ("GetWriteWatch() not supported, using guard pages, performance will be slower.\n");
+ memwatchtable = xcalloc (currprefs.gfxmem_size / si.dwPageSize + 1, 1);
+ }
}
- }
-restart:
- for (;;) {
- int change;
if (currprefs.gfxmem_size) {
rtgextra = si.dwPageSize;
} else {
rtgextra = 0;
}
blah = VirtualAlloc (NULL, natmemsize + rtgbarrier + currprefs.gfxmem_size + rtgextra + 16 * si.dwPageSize, MEM_RESERVE, PAGE_READWRITE);
- if (blah)
+ if (blah) {
+ natmem_offset = blah;
break;
- write_log ("NATMEM: %dM area failed to allocate, err=%d\n", natmemsize >> 20, GetLastError ());
- change = lowmem ();
- totalsize -= change;
- if (change == 0 || totalsize < 0x10000000) {
+ }
+ write_log ("NATMEM: %dM area failed to allocate, err=%d (Z3=%dM,RTG=%dM)\n",
+ natmemsize >> 20, GetLastError (), currprefs.z3fastmem_size >> 20, currprefs.gfxmem_size >> 20);
+ if (!lowmem ()) {
write_log ("NATMEM: No special area could be allocated (2)!\n");
return 0;
}
}
- natmem_offset = blah;
p96mem_size = currprefs.gfxmem_size;
if (p96mem_size) {
VirtualFree (natmem_offset, 0, MEM_RELEASE);
#define NOBLITTER 0
-static int hwsprite;
+static int hwsprite = 0;
+static int uaegfxcard_old = 1;
#include "registry.h"
#include "dxwrap.h"
static uaecptr cursorbi;
+static uaecptr uaegfx_resname,
+ uaegfx_resid,
+ uaegfx_init,
+ uaegfx_base;
+
typedef enum {
BLIT_FALSE,
BLIT_NOR,
gfx_unlock_picasso ();
}
+static int framecnt;
+int p96skipmode = -1;
+static int doskip (void)
+{
+ if (framecnt >= currprefs.gfx_framerate)
+ framecnt = 0;
+ return framecnt > 0;
+}
+
void picasso_handle_vsync (void)
{
static int vsynccnt;
- static int updatecnt;
+ framecnt++;
mouseupdate ();
if (currprefs.chipset_refreshrate >= 100) {
return;
vsynccnt = 0;
}
- updatecnt--;
- if (updatecnt <= 0) {
+ if (doskip () && p96skipmode == 0) {
+ ;
+ } else {
flushpixels ();
- updatecnt = 1;
}
gfx_unlock_picasso ();
}
return 0;
}
-/*
-SetSprite:
-Synopsis: SetSprite(bi, activate, RGBFormat);
-Inputs: a0: struct BoardInfo *bi
-d0: BOOL activate
-d7: RGBFTYPE RGBFormat
-
-This function activates or deactivates the hardware sprite.
-*/
-uae_u32 REGPARAM2 picasso_SetSprite (struct regstruct *regs)
-{
- uae_u32 result = 0;
- uae_u32 activate = m68k_dreg (regs, 0);
- if (!hwsprite)
- return 0;
- if (activate) {
- picasso_SetSpriteImage (regs);
- cursorvisible = 1;
- } else {
- cursordeactivate = 2;
- }
- result = 1;
- P96TRACE_SPR (("SetSprite: %d\n", activate));
- return result;
-}
-
/*
SetSpritePosition:
Synopsis: SetSpritePosition(bi, RGBFormat);
d7: RGBFTYPE RGBFormat
*/
-uae_u32 REGPARAM2 picasso_SetSpritePosition (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetSpritePosition (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr bi = m68k_areg (regs, 0);
newcursor_x = (uae_s16)get_word (bi + PSSO_BoardInfo_MouseX) - picasso96_state.XOffset;
newcursor_y = (uae_s16)get_word (bi + PSSO_BoardInfo_MouseY) - picasso96_state.YOffset;
This function changes one of the possible three colors of the hardware sprite.
*/
-uae_u32 REGPARAM2 picasso_SetSpriteColor (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetSpriteColor (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr bi = m68k_areg (regs, 0);
uae_u8 idx = m68k_dreg (regs, 0);
uae_u8 red = m68k_dreg (regs, 1);
}
-/*
-SetSpriteImage:
-Synopsis: SetSpriteImage(bi, RGBFormat);
-Inputs: a0: struct BoardInfo *bi
-d7: RGBFTYPE RGBFormat
-
-This function gets new sprite image data from the MouseImage field of the BoardInfo structure and writes
-it to the board.
-
-There are three possible cases:
-
-BIB_HIRESSPRITE is set:
-skip the first two long words and the following sprite data is arranged as an array of two longwords. Those form the
-two bit planes for one image line respectively.
-
-BIB_HIRESSPRITE and BIB_BIGSPRITE are not set:
-skip the first two words and the following sprite data is arranged as an array of two words. Those form the two
-bit planes for one image line respectively.
-
-BIB_HIRESSPRITE is not set and BIB_BIGSPRITE is set:
-skip the first two words and the following sprite data is arranged as an array of two words. Those form the two bit
-planes for one image line respectively. You have to double each pixel horizontally and vertically. All coordinates
-used in this case already assume a zoomed sprite, only the sprite data is not zoomed yet. You will have to
-compensate for this when accounting for hotspot offsets and sprite dimensions.
-*/
-
static uae_u32 setspriteimage (uaecptr bi);
static RECT cursor_r1, cursor_r2;
static int mouseput;
return ret;
}
-uae_u32 REGPARAM2 picasso_SetSpriteImage (struct regstruct *regs)
+/*
+SetSpriteImage:
+Synopsis: SetSpriteImage(bi, RGBFormat);
+Inputs: a0: struct BoardInfo *bi
+d7: RGBFTYPE RGBFormat
+
+This function gets new sprite image data from the MouseImage field of the BoardInfo structure and writes
+it to the board.
+
+There are three possible cases:
+
+BIB_HIRESSPRITE is set:
+skip the first two long words and the following sprite data is arranged as an array of two longwords. Those form the
+two bit planes for one image line respectively.
+
+BIB_HIRESSPRITE and BIB_BIGSPRITE are not set:
+skip the first two words and the following sprite data is arranged as an array of two words. Those form the two
+bit planes for one image line respectively.
+
+BIB_HIRESSPRITE is not set and BIB_BIGSPRITE is set:
+skip the first two words and the following sprite data is arranged as an array of two words. Those form the two bit
+planes for one image line respectively. You have to double each pixel horizontally and vertically. All coordinates
+used in this case already assume a zoomed sprite, only the sprite data is not zoomed yet. You will have to
+compensate for this when accounting for hotspot offsets and sprite dimensions.
+*/
+static uae_u32 REGPARAM2 picasso_SetSpriteImage (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr bi = m68k_areg (regs, 0);
cursorbi = bi;
return setspriteimage (bi);
}
+/*
+SetSprite:
+Synopsis: SetSprite(bi, activate, RGBFormat);
+Inputs: a0: struct BoardInfo *bi
+d0: BOOL activate
+d7: RGBFTYPE RGBFormat
+
+This function activates or deactivates the hardware sprite.
+*/
+static uae_u32 REGPARAM2 picasso_SetSprite (TrapContext *ctx)
+{
+ struct regstruct *regs = &ctx->regs;
+ uae_u32 result = 0;
+ uae_u32 activate = m68k_dreg (regs, 0);
+ if (!hwsprite)
+ return 0;
+ if (activate) {
+ picasso_SetSpriteImage (ctx);
+ cursorvisible = 1;
+ } else {
+ cursordeactivate = 2;
+ }
+ result = 1;
+ P96TRACE_SPR (("SetSprite: %d\n", activate));
+ return result;
+}
+
/*
* BOOL FindCard(struct BoardInfo *bi); and
*
* BoardInfo struct supplied by the caller, the rtg.library, for example
* the MemoryBase, MemorySize and RegisterBase fields.
*/
-uae_u32 REGPARAM2 picasso_FindCard (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_FindCard (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr AmigaBoardInfo = m68k_areg (regs, 0);
/* NOTES: See BoardInfo struct definition in Picasso96 dev info */
+#ifdef UAEGFX_INTERNAL
+ if (!uaegfx_base)
+ return 0;
+ put_long (uaegfx_base + CARD_BOARDINFO, AmigaBoardInfo);
+#endif
if (allocated_gfxmem && !picasso96_state.CardFound) {
/* Fill in MemoryBase, MemorySize */
put_long (AmigaBoardInfo + PSSO_BoardInfo_MemoryBase, gfxmem_start);
put_long (amigamemptr + PSSO_LibResolution_BoardInfo, libres->BoardInfo);
}
+
static int missmodes[] = { 320, 200, 320, 240, 640, 400, 640, 480, -1 };
+#ifdef UAEGFX_INTERNAL
+static uaecptr uaegfx_card_install (TrapContext *ctx, uae_u32 size);
+#endif
void picasso96_alloc (TrapContext *ctx)
{
int i, j, size, cnt;
int misscnt;
- uaecptr rt;
SYSTEM_INFO si;
+ uaegfx_resname = ds ("uaegfx.card");
xfree (newmodes);
newmodes = NULL;
picasso96_amem = picasso96_amemend = 0;
#if 0
ShowSupportedResolutions ();
#endif
+#ifdef UAEGFX_INTERNAL
+ picasso96_amem = NULL;
+ if (uaegfx_card_install (ctx, size)) {
+ picasso96_amem = get_long (uaegfx_base + CARD_RESLIST);
+ picasso96_amemend = picasso96_amem + size;
+ write_log("P96 RESINFO: %08X-%08X (%d,%d)\n", picasso96_amem, picasso96_amemend, cnt, size);
+ }
+#else
m68k_dreg (&ctx->regs, 0) = size;
m68k_dreg (&ctx->regs, 1) = 65536 + 1;
- picasso96_amem = CallLib (ctx, get_long (4), -0xC6); /* AllocMem */
- picasso96_amemend = picasso96_amem + size;
- write_log("P96 RESINFO: %08X-%08X (%d,%d)\n", picasso96_amem, picasso96_amemend, cnt, size);
+ if ((picasso96_amem = CallLib (ctx, get_long (4), -0xC6))) { /* AllocMem */
+ uaecptr rt;
+ picasso96_amemend = picasso96_amem + size;
+ write_log("P96 RESINFO: %08X-%08X (%d,%d)\n", picasso96_amem, picasso96_amemend, cnt, size);
+ /* put magic rtarea pointer to end of display ram */
+ put_long (p96ram_start + allocated_gfxmem - 12, 'UAE_');
+ rt = need_uae_boot_rom ();
+ if (rt)
+ rt += 0xff60;
+ put_long (p96ram_start + allocated_gfxmem - 8, rt);
+ put_long (p96ram_start + allocated_gfxmem - 4, '_UAE');
+ }
+#endif
xfree (gwwbuf);
GetSystemInfo (&si);
gwwbufsize = allocated_gfxmem / gwwpagesize + 1;
gwwpagemask = gwwpagesize - 1;
gwwbuf = xmalloc (gwwbufsize * sizeof (void*));
-
- /* put magic rtarea pointer to end of display ram */
- put_long (p96ram_start + allocated_gfxmem - 12, 'UAE_');
- rt = need_uae_boot_rom ();
- if (rt)
- rt += 0xff60;
- put_long (p96ram_start + allocated_gfxmem - 8, rt);
- put_long (p96ram_start + allocated_gfxmem - 4, '_UAE');
}
+#ifndef UAEGFX_INTERNAL
static void uaegfxversion (uaecptr bi)
{
uaecptr addr = get_long (bi + 16); /* gbi_BoardName */
int max = 1000;
int ok = 0;
+ uaegfxcard_old = 1;
+
addr &= ~1;
for (;;) {
if (!valid_address (addr, 24) || bi == 0) {
uaecptr ver = get_long (addr + 18);
if (valid_address (ver, 8)) {
char *vers = my_strdup (get_real_address (ver));
+ int version = get_byte (addr + 11);
while (strlen (vers) > 0 && (vers[strlen (vers) - 1] == 10 || vers[strlen (vers) - 1] == 13))
vers[strlen (vers) - 1] = 0;
- write_log ("P96: %s\n", vers);
+
+ write_log ("P96: v%d %08X %s\n", version, addr, vers);
+ if (version >= 2)
+ uaegfxcard_old = 0;
xfree (vers);
ok = 1;
}
if (!ok)
write_log ("P96: uaegfx.card not detected!?\n");
}
+#endif
+static void inituaegfxfuncs (uaecptr ABI);
+static void inituaegfx (uaecptr ABI)
+{
+ uae_u32 flags;
+
+ put_word (ABI + PSSO_BoardInfo_BitsPerCannon, 8);
+ put_word (ABI + PSSO_BoardInfo_RGBFormats, picasso96_pixel_format);
+ put_long (ABI + PSSO_BoardInfo_BoardType, BT_uaegfx);
+ put_long (ABI + PSSO_BoardInfo_GraphicsControllerType, GCT_Unknown);
+ put_long (ABI + PSSO_BoardInfo_PaletteChipType, PCT_Unknown);
+ put_long (ABI + PSSO_BoardInfo_BoardName, uaegfx_resname);
+ put_long (ABI + PSSO_BoardInfo_BoardType, 1);
+
+ /* only 1 clock */
+ put_long (ABI + PSSO_BoardInfo_PixelClockCount + PLANAR * 4, 1);
+ put_long (ABI + PSSO_BoardInfo_PixelClockCount + CHUNKY * 4, 1);
+ put_long (ABI + PSSO_BoardInfo_PixelClockCount + HICOLOR * 4, 1);
+ put_long (ABI + PSSO_BoardInfo_PixelClockCount + TRUECOLOR * 4, 1);
+ put_long (ABI + PSSO_BoardInfo_PixelClockCount + TRUEALPHA * 4, 1);
+
+ /* we have 16 bits for horizontal and vertical timings - hack */
+ put_word (ABI + PSSO_BoardInfo_MaxHorValue + PLANAR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxHorValue + CHUNKY * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxHorValue + HICOLOR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxHorValue + TRUECOLOR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxHorValue + TRUEALPHA * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxVerValue + PLANAR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxVerValue + CHUNKY * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxVerValue + HICOLOR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxVerValue + TRUECOLOR * 2, 0xffff);
+ put_word (ABI + PSSO_BoardInfo_MaxVerValue + TRUEALPHA * 2, 0xffff);
+
+ flags = get_long (ABI + PSSO_BoardInfo_Flags);
+ flags &= 0xffff0000;
+ flags |= BIF_HARDWARESPRITE | BIF_BLITTER | BIF_NOMEMORYMODEMIX;
+ put_long (ABI + PSSO_BoardInfo_Flags, flags);
+#ifndef UAEGFX_INTERNAL
+ flags = get_long (ABI + PSSO_BoardInfo_Flags);
+ if (flags & BIF_HARDWARESPRITE) {
+ hwsprite = 1;
+ put_word (ABI + PSSO_BoardInfo_SoftSpriteFlags, 0);
+ write_log ("P96: uaegfx.card: hardware sprite support enabled\n");
+ } else {
+ hwsprite = 0;
+ write_log ("P96: uaegfx.card: no hardware sprite support\n");
+ put_word (ABI + PSSO_BoardInfo_SoftSpriteFlags, picasso96_pixel_format);
+ }
+ if (uaegfxcard_old && (flags & BIF_HARDWARESPRITE)) {
+ flags &= ~BIF_HARDWARESPRITE;
+ write_log ("P96: uaegfx.card: old version (<2.0), forced hardware sprite disabled\n");
+ }
+ if (!(flags & BIF_BLITTER))
+ write_log ("P96: no blitter support, bogus uaegfx.card!?\n");
+ put_long (ABI + PSSO_BoardInfo_Flags, flags);
+#endif
+ if (flags & BIF_NOBLITTER)
+ write_log ("P96: blitter disabled in devs:monitors/uaegfx!\n");
+
+ put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 0, planar.width);
+ put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 2, chunky.width);
+ put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 4, hicolour.width);
+ put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 6, truecolour.width);
+ put_word (ABI + PSSO_BoardInfo_MaxHorResolution + 8, alphacolour.width);
+ put_word (ABI + PSSO_BoardInfo_MaxVerResolution + 0, planar.height);
+ put_word (ABI + PSSO_BoardInfo_MaxVerResolution + 2, chunky.height);
+ put_word (ABI + PSSO_BoardInfo_MaxVerResolution + 4, hicolour.height);
+ put_word (ABI + PSSO_BoardInfo_MaxVerResolution + 6, truecolour.height);
+ put_word (ABI + PSSO_BoardInfo_MaxVerResolution + 8, alphacolour.height);
+#ifdef UAEGFX_INTERNAL
+ inituaegfxfuncs (ABI);
+#endif
+}
/****************************************
* InitCard()
* a2: BoardInfo structure ptr - Amiga-based address in Intel endian-format
*
*/
-uae_u32 REGPARAM2 picasso_InitCard (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_InitCard (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
struct LibResolution res;
int ModeInfoStructureCount = 1, LibResolutionStructureCount = 0;
int i, j, unkcnt;
uaecptr amem;
- uaecptr AmigaBoardInfo = m68k_areg (regs, 2);
- uae_u32 flags;
+ uaecptr AmigaBoardInfo = m68k_areg (regs, 0);
+#ifndef UAEGFX_INTERNAL
uaegfxversion (AmigaBoardInfo);
+#endif
if (!picasso96_amem) {
write_log ("P96: InitCard() but no resolution memory!\n");
return 0;
}
amem = picasso96_amem;
- put_word (AmigaBoardInfo + PSSO_BoardInfo_BitsPerCannon, 8);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_RGBFormats, picasso96_pixel_format);
- put_long (AmigaBoardInfo + PSSO_BoardInfo_BoardType, BT_uaegfx);
- flags = get_long (AmigaBoardInfo + PSSO_BoardInfo_Flags);
- if (flags & BIF_HARDWARESPRITE) {
- hwsprite = 1;
- put_word (AmigaBoardInfo + PSSO_BoardInfo_SoftSpriteFlags, 0);
- write_log ("P96: uaegfx.card: hardware sprite support enabled\n");
- } else {
- hwsprite = 0;
- write_log ("P96: uaegfx.card: no hardware sprite support\n");
- put_word (AmigaBoardInfo + PSSO_BoardInfo_SoftSpriteFlags, picasso96_pixel_format);
- }
- if (!(flags & BIF_BLITTER))
- write_log ("P96: no blitter support, bogus uaegfx.card!?\n");
- if (flags & BIF_NOBLITTER)
- write_log ("P96: blitter disabled in devs:monitors/uaegfx!\n");
- put_long (AmigaBoardInfo + PSSO_BoardInfo_Flags, flags);
-
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 0, planar.width);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 2, chunky.width);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 4, hicolour.width);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 6, truecolour.width);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxHorResolution + 8, alphacolour.width);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 0, planar.height);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 2, chunky.height);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 4, hicolour.height);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 6, truecolour.height);
- put_word (AmigaBoardInfo + PSSO_BoardInfo_MaxVerResolution + 8, alphacolour.height);
+ inituaegfx (AmigaBoardInfo);
i = 0;
unkcnt = 0;
*
* NOTE: Return the opposite of the switch-state. BDK
*/
-uae_u32 REGPARAM2 picasso_SetSwitch (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetSwitch (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uae_u16 flag = m68k_dreg (regs, 0) & 0xFFFF;
char p96text[100];
}
return changed;
}
-uae_u32 REGPARAM2 picasso_SetColorArray (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetColorArray (TrapContext *ctx)
{
/* Fill in some static UAE related structure about this new CLUT setting
* We need this for CLUT-based displays, and for mapping CLUT to hi/true colour */
+ struct regstruct *regs = &ctx->regs;
uae_u16 start = m68k_dreg (regs, 0);
uae_u16 count = m68k_dreg (regs, 1);
uaecptr boardinfo = m68k_areg (regs, 0);
* e.g. from chunky to TrueColor. Usually, all you have to do is to set
* the RAMDAC of your board accordingly.
*/
-uae_u32 REGPARAM2 picasso_SetDAC (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetDAC (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
/* Fill in some static UAE related structure about this new DAC setting
* Lets us keep track of what pixel format the Amiga is thinking about in our frame-buffer */
* or linear start adress. They will be set when appropriate by their
* own functions.
*/
-uae_u32 REGPARAM2 picasso_SetGC (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetGC (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
/* Fill in some static UAE related structure about this new ModeInfo setting */
+ uaecptr AmigaBoardInfo = m68k_areg (regs, 0);
uae_u32 border = m68k_dreg (regs, 0);
uaecptr modeinfo = m68k_areg (regs, 1);
+ put_long (AmigaBoardInfo + PSSO_BoardInfo_ModeInfo, modeinfo);
+ put_word (AmigaBoardInfo + PSSO_BoardInfo_Border, border);
+
picasso96_state.Width = get_word (modeinfo + PSSO_ModeInfo_Width);
picasso96_state.VirtualWidth = picasso96_state.Width; /* in case SetPanning doesn't get called */
* because SetSwitch() is not called for subsequent Picasso screens.
*/
-static void picasso_SetPanningInit(void)
+static void picasso_SetPanningInit (void)
{
picasso96_state.XYOffset = picasso96_state.Address + (picasso96_state.XOffset * picasso96_state.BytesPerPixel)
+ (picasso96_state.YOffset * picasso96_state.BytesPerRow);
picasso96_state.BigAssBitmap = 0;
}
-uae_u32 REGPARAM2 picasso_SetPanning (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetPanning (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uae_u16 Width = m68k_dreg (regs, 0);
uaecptr start_of_screen = m68k_areg (regs, 1);
uaecptr bi = m68k_areg (regs, 0);
picasso96_state.Address = start_of_screen; /* Amiga-side address */
picasso96_state.XOffset = (uae_s16)(m68k_dreg (regs, 1) & 0xFFFF);
picasso96_state.YOffset = (uae_s16)(m68k_dreg (regs, 2) & 0xFFFF);
+ put_word (bi + PSSO_BoardInfo_XOffset, picasso96_state.XOffset);
+ put_word (bi + PSSO_BoardInfo_YOffset, picasso96_state.YOffset);
picasso96_state.VirtualWidth = bme_width;
picasso96_state.VirtualHeight = bme_height;
picasso96_state.RGBFormat = m68k_dreg (regs, 7);
* This function is used to invert a rectangular area on the board. It is called by BltBitMap,
* BltPattern and BltTemplate.
*/
-uae_u32 REGPARAM2 picasso_InvertRect (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_InvertRect (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr renderinfo = m68k_areg (regs, 1);
unsigned long X = (uae_u16)m68k_dreg (regs, 0);
unsigned long Y = (uae_u16)m68k_dreg (regs, 1);
* d5: UBYTE Mask
* d7: uae_u32 RGBFormat
***********************************************************/
-uae_u32 REGPARAM2 picasso_FillRect (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_FillRect (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr renderinfo = m68k_areg (regs, 1);
uae_u32 X = (uae_u16)m68k_dreg (regs, 0);
uae_u32 Y = (uae_u16)m68k_dreg (regs, 1);
* d6: UBYTE Mask
* d7: uae_u32 RGBFormat
***********************************************************/
-uae_u32 REGPARAM2 picasso_BlitRect (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitRect (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr renderinfo = m68k_areg (regs, 1);
unsigned long srcx = (uae_u16)m68k_dreg (regs, 0);
unsigned long srcy = (uae_u16)m68k_dreg (regs, 1);
* because the RGBFormat or opcode aren't supported.
* OTHERWISE return 1
***********************************************************/
-uae_u32 REGPARAM2 picasso_BlitRectNoMaskComplete (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitRectNoMaskComplete (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr srcri = m68k_areg (regs, 1);
uaecptr dstri = m68k_areg (regs, 2);
unsigned long srcx = (uae_u16)m68k_dreg (regs, 0);
if (NOBLITTER)
return 0;
- {
- uaecptr a5 = m68k_areg (regs, 5) & ~0xffff;
- if (a5 != RTAREA_DEFAULT && a5 != RTAREA_BACKUP) {
- static int notified;
- if (!notified)
- gui_message ("Picasso96 function call with invalid parameters!\n"
- "Most likely reason: unsupported version of p96_uae_tweak");
- notified = 1;
- }
- }
P96TRACE(("BlitRectNoMaskComplete() op 0x%02x, %08x:(%4d,%4d) --> %08x:(%4d,%4d), wh(%4d,%4d)\n",
OpCode, get_long (srcri + PSSO_RenderInfo_Memory), srcx, srcy, get_long (dstri + PSSO_RenderInfo_Memory), dstx, dsty, width, height));
* always 16 pixels (one word) and the height is calculated as 2^Size. The data must be shifted up
* and to the left by XOffset and YOffset pixels at the beginning.
*/
-uae_u32 REGPARAM2 picasso_BlitPattern (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitPattern (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr rinf = m68k_areg (regs, 1);
uaecptr pinf = m68k_areg (regs, 2);
unsigned long X = (uae_u16)m68k_dreg (regs, 0);
* using a single plane of image data which will be expanded to the destination RGBFormat
* using ForeGround and BackGround pens as well as draw modes.
***********************************************************************************/
-uae_u32 REGPARAM2 picasso_BlitTemplate (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitTemplate (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uae_u8 inversion = 0;
uaecptr rinf = m68k_areg (regs, 1);
uaecptr tmpl = m68k_areg (regs, 2);
* This function calculates the amount of bytes needed for a line of
* "Width" pixels in the given RGBFormat.
*/
-uae_u32 REGPARAM2 picasso_CalculateBytesPerRow (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_CalculateBytesPerRow (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uae_u16 width = m68k_dreg (regs, 0);
uae_u32 type = m68k_dreg (regs, 7);
width = GetBytesPerPixel (type) * width;
*
* NOTE: return the opposite of the state
*/
-uae_u32 REGPARAM2 picasso_SetDisplay (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_SetDisplay (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uae_u32 state = m68k_dreg (regs, 0);
P96TRACE (("SetDisplay(%d)\n", state));
return !state;
* on the board. Watch out for plane pointers that are 0x00000000 (represents a plane with all bits "0")
* or 0xffffffff (represents a plane with all bits "1").
*/
-uae_u32 REGPARAM2 picasso_BlitPlanar2Chunky (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitPlanar2Chunky (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr bm = m68k_areg (regs, 1);
uaecptr ri = m68k_areg (regs, 2);
unsigned long srcx = (uae_u16)m68k_dreg (regs, 0);
* triple bytes or longwords respectively similar to the color values used in FillRect(), BlitPattern() or
* BlitTemplate().
*/
-uae_u32 REGPARAM2 picasso_BlitPlanar2Direct (struct regstruct *regs)
+static uae_u32 REGPARAM2 picasso_BlitPlanar2Direct (TrapContext *ctx)
{
+ struct regstruct *regs = &ctx->regs;
uaecptr bm = m68k_areg (regs, 1);
uaecptr ri = m68k_areg (regs, 2);
uaecptr cim = m68k_areg (regs, 3);
for (;;) {
gwwcnt = 0;
+
+ if (doskip () && p96skipmode == 1)
+ break;
+
if (palette_changed < 0) {
palette_changed = 1;
if (picasso_palette ()) {
if (dst == NULL)
break;
+ if (doskip () && p96skipmode == 2)
+ break;
+
for (i = 0; i < gwwcnt; i++) {
int pscnt = gwwpagesize;
uae_u8 *p = gwwbuf[i];
if(lock)
gfx_unlock_picasso ();
if (dst && gwwcnt) {
- mman_ResetWatch (src_start, src_end - src_start);
- palette_changed = 0;
+ if (doskip () && p96skipmode == 3) {
+ ;
+ } else {
+ mman_ResetWatch (src_start, src_end - src_start);
+ }
+ palette_changed = 0;
+ }
+ if (maxy >= 0) {
+ if (doskip () && p96skipmode == 4) {
+ ;
+ } else {
+ DX_Invalidate (0, miny, picasso96_state.Width, maxy - miny + 1);
+ }
}
- if (maxy >= 0)
- DX_Invalidate (0, miny, picasso96_state.Width, maxy - miny + 1);
}
static uae_u32 REGPARAM2 gfxmem_lgetx (uaecptr addr)
#endif
+#ifdef UAEGFX_INTERNAL
+#define RTGCALL(ABI,func,funcdef,call) \
+ put_long (ABI + func, here ()); \
+ dl (0x48e78000); \
+ calltrap (deftrap (call)); \
+ dw (0x4a80); \
+ dl (0x4cdf0001);\
+ dw (0x6604); \
+ dw (0x2f28); \
+ dw (funcdef); \
+ dw (RTS);
+
+#define RTGCALL2(ABI,func,call) \
+ put_long (ABI + func, here ()); \
+ calltrap (deftrap (call)); \
+ dw (RTS);
+
+#define RTGCALLDEFAULT(ABI,func,funcdef) \
+ put_long (ABI + func, here ()); \
+ dw (0x2f28); \
+ dw (funcdef); \
+ dw (RTS);
+
+#define RTGNONE(ABI,func) \
+ put_long (ABI + func, start);
+
+static void inituaegfxfuncs (uaecptr ABI)
+{
+ uaecptr start = here ();
+
+ dw (RTS);
+ /* ResolvePixelClock
+ move.l D0,gmi_PixelClock(a1) ; pass the pixelclock through
+ moveq #0,D0 ; index is 0
+ move.b #98,gmi_Numerator(a1) ; whatever
+ move.b #14,gmi_Denominator(a1) ; whatever
+ rts
+ */
+ put_long (ABI + PSSO_BoardInfo_ResolvePixelClock, here ());
+ dl (0x2340002c);
+ dw (0x7000);
+ dl (0x137c0062); dw (0x002a);
+ dl (0x137c000e); dw (0x002b);
+ dw (RTS);
+
+ /* GetPixelClock
+ move.l #CLOCK,D0 ; fill in D0 with our one true pixel clock
+ rts
+ */
+ put_long (ABI + PSSO_BoardInfo_GetPixelClock, here ());
+ dw (0x203c);
+ dl (100227260);
+ dw (RTS);
+
+ /* CalculateMemory
+ ; this is simple, because we're not supporting planar modes in UAE
+ move.l a1,d0
+ rts
+ */
+ put_long (ABI + PSSO_BoardInfo_CalculateMemory, here ());
+ dw (0x2009);
+ dw (RTS);
+
+ /* GetCompatibleFormats
+ ; all formats can coexist without any problems, since we don't support planar stuff in UAE
+ move.l #~RGBFF_PLANAR,d0
+ rts
+ */
+ put_long (ABI + PSSO_BoardInfo_GetCompatibleFormats, here ());
+ dw (0x203c);
+ dl (0xfffffffe);
+ dw (RTS);
+
+ RTGNONE(ABI, PSSO_BoardInfo_SetClock);
+ RTGNONE(ABI, PSSO_BoardInfo_SetMemoryMode);
+ RTGNONE(ABI, PSSO_BoardInfo_SetWriteMask);
+ RTGNONE(ABI, PSSO_BoardInfo_SetClearMask);
+ RTGNONE(ABI, PSSO_BoardInfo_SetReadPlane);
+
+ RTGNONE(ABI, PSSO_BoardInfo_WaitVerticalSync); /* FIXME */
+ RTGNONE(ABI, PSSO_BoardInfo_WaitBlitter);
+
+#if 0
+ RTGCALL2(ABI, PSSO_BoardInfo_, picasso_);
+ RTGCALL(ABI, PSSO_BoardInfo_, PSSO_BoardInfo_Default, picasso_);
+ RTGCALLDEFAULT(ABI, PSSO_BoardInfo_, PSSO_BoardInfo_Default);
+#endif
+
+ RTGCALL(ABI, PSSO_BoardInfo_BlitPlanar2Direct, PSSO_BoardInfo_BlitPlanar2DirectDefault, picasso_BlitPlanar2Direct);
+ RTGCALL(ABI, PSSO_BoardInfo_FillRect, PSSO_BoardInfo_FillRectDefault, picasso_FillRect);
+ RTGCALL(ABI, PSSO_BoardInfo_BlitRect, PSSO_BoardInfo_BlitRectDefault, picasso_BlitRect);
+ RTGCALL(ABI, PSSO_BoardInfo_BlitPlanar2Chunky, PSSO_BoardInfo_BlitPlanar2ChunkyDefault, picasso_BlitPlanar2Chunky);
+ RTGCALL(ABI, PSSO_BoardInfo_BlitTemplate, PSSO_BoardInfo_BlitTemplateDefault, picasso_BlitTemplate);
+ RTGCALL(ABI, PSSO_BoardInfo_InvertRect, PSSO_BoardInfo_InvertRectDefault, picasso_InvertRect);
+ RTGCALL(ABI, PSSO_BoardInfo_BlitRectNoMaskComplete, PSSO_BoardInfo_BlitRectNoMaskCompleteDefault, picasso_BlitRectNoMaskComplete);
+ RTGCALL(ABI, PSSO_BoardInfo_BlitPattern, PSSO_BoardInfo_BlitPatternDefault, picasso_BlitPattern);
+
+ RTGCALL2(ABI, PSSO_BoardInfo_SetSwitch, picasso_SetSwitch);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetColorArray, picasso_SetColorArray);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetDAC, picasso_SetDAC);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetGC, picasso_SetGC);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetPanning, picasso_SetPanning);
+ RTGCALL2(ABI, PSSO_BoardInfo_CalculateBytesPerRow, picasso_CalculateBytesPerRow);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetDisplay, picasso_SetDisplay);
+
+ RTGCALL2(ABI, PSSO_BoardInfo_SetSprite, picasso_SetSprite);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetSpritePosition, picasso_SetSpritePosition);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetSpriteImage, picasso_SetSpriteImage);
+ RTGCALL2(ABI, PSSO_BoardInfo_SetSpriteColor, picasso_SetSpriteColor);
+
+ RTGCALLDEFAULT(ABI, PSSO_BoardInfo_ScrollPlanar, PSSO_BoardInfo_ScrollPlanarDefault);
+ RTGCALLDEFAULT(ABI, PSSO_BoardInfo_UpdatePlanar, PSSO_BoardInfo_UpdatePlanarDefault);
+ RTGCALLDEFAULT(ABI, PSSO_BoardInfo_DrawLine, PSSO_BoardInfo_DrawLineDefault);
+
+ write_log ("uaegfx.card magic code: %08X-%08X\n", start, here ());
+}
+
+#define UAEGFX_VERSION 3
+#define UAEGFX_REVISION 0
+
+static uae_u32 REGPARAM2 gfx_open (TrapContext *context)
+{
+ put_word (uaegfx_base + 32, get_word (uaegfx_base + 32) + 1);
+ return uaegfx_base;
+}
+static uae_u32 REGPARAM2 gfx_close (TrapContext *context)
+{
+ put_word (uaegfx_base + 32, get_word (uaegfx_base + 32) - 1);
+ return 0;
+}
+static uae_u32 REGPARAM2 gfx_expunge (TrapContext *context)
+{
+ return 0;
+}
+
+static uaecptr uaegfx_card_install (TrapContext *ctx, uae_u32 extrasize)
+{
+ uae_u32 functable, datatable, a2;
+ uaecptr openfunc, closefunc, expungefunc;
+ uaecptr findcardfunc, initcardfunc;
+ uaecptr exec = get_long (4);
+
+ uaegfx_resid = ds ("UAE Graphics Card 3.0");
+
+ /* Open */
+ openfunc = here ();
+ calltrap (deftrap (gfx_open)); dw (RTS);
+
+ /* Close */
+ closefunc = here ();
+ calltrap (deftrap (gfx_close)); dw (RTS);
+
+ /* Expunge */
+ expungefunc = here ();
+ calltrap (deftrap (gfx_expunge)); dw (RTS);
+
+ /* FindCard */
+ findcardfunc = here ();
+ calltrap (deftrap (picasso_FindCard)); dw (RTS);
+
+ /* InitCard */
+ initcardfunc = here ();
+ calltrap (deftrap (picasso_InitCard)); dw (RTS);
+
+ functable = here ();
+ dl (openfunc);
+ dl (closefunc);
+ dl (expungefunc);
+ dl (EXPANSION_nullfunc);
+ dl (findcardfunc);
+ dl (initcardfunc);
+ dl (0xFFFFFFFF); /* end of table */
+
+ datatable = makedatatable (uaegfx_resid, uaegfx_resname, 0x09, -50, UAEGFX_VERSION, UAEGFX_REVISION);
+
+ a2 = m68k_areg (&ctx->regs, 2);
+ m68k_areg (&ctx->regs, 0) = functable;
+ m68k_areg (&ctx->regs, 1) = datatable;
+ m68k_areg (&ctx->regs, 2) = 0;
+ m68k_dreg (&ctx->regs, 0) = CARD_SIZEOF + extrasize;
+ m68k_dreg (&ctx->regs, 1) = 0;
+ uaegfx_base = CallLib (ctx, exec, -0x54); /* MakeLibrary */
+ m68k_areg (&ctx->regs, 2) = a2;
+ if (uaegfx_base) {
+ m68k_areg (&ctx->regs, 1) = uaegfx_base;
+ CallLib (ctx, exec, -0x18c); /* AddLibrary */
+ }
+ m68k_areg (&ctx->regs, 1) = EXPANSION_explibname;
+ m68k_dreg (&ctx->regs, 0) = 0;
+ put_long (uaegfx_base + CARD_EXPANSIONBASE, CallLib (ctx, exec, -0x228)); /* OpenLibrary */
+ put_long (uaegfx_base + CARD_EXECBASE, exec);
+ put_long (uaegfx_base + CARD_NAME, uaegfx_resname);
+ put_long (uaegfx_base + CARD_RESLIST, uaegfx_base + CARD_SIZEOF);
+
+ write_log ("uaegfx.card %d.%d init @%08X\n", UAEGFX_VERSION, UAEGFX_REVISION, uaegfx_base);
+ return uaegfx_base;
+}
+#endif
+
+#ifndef UAEGFX_INTERNAL
+uae_u32 picasso_demux (uae_u32 arg, TrapContext *context)
+{
+ switch (arg)
+ {
+ case 16: return picasso_FindCard (context);
+ case 17: return picasso_FillRect (context);
+ case 18: return picasso_SetSwitch (context);
+ case 19: return picasso_SetColorArray (context);
+ case 20: return picasso_SetDAC (context);
+ case 21: return picasso_SetGC (context);
+ case 22: return picasso_SetPanning (context);
+ case 23: return picasso_CalculateBytesPerRow (context);
+ case 24: return picasso_BlitPlanar2Chunky (context);
+ case 25: return picasso_BlitRect (context);
+ case 26: return picasso_SetDisplay (context);
+ case 27: return picasso_BlitTemplate (context);
+ case 28: return picasso_BlitRectNoMaskComplete (context);
+ case 29: return picasso_InitCard (context);
+ case 30: return picasso_BlitPattern (context);
+ case 31: return picasso_InvertRect (context);
+ case 32: return picasso_BlitPlanar2Direct (context);
+ /* case 34: return picasso_WaitVerticalSync (); handled in asm-code */
+ case 35: return allocated_gfxmem ? 1 : 0;
+ case 36: return picasso_SetSprite (context);
+ case 37: return picasso_SetSpritePosition (context);
+ case 38: return picasso_SetSpriteImage (context);
+ case 39: return picasso_SetSpriteColor (context);
+ }
+ return 0;
+}
+#endif
+
#endif
+
+
uae_u8 Blue;
};
-#define PSSO_BitMap_BytesPerRow 0
-#define PSSO_BitMap_Rows 2
-#define PSSO_BitMap_Flags 4
-#define PSSO_BitMap_Depth 5
-#define PSSO_BitMap_pad 6
-#define PSSO_BitMap_Planes 8
-#define PSSO_BitMap_sizeof 40
+#define PSSO_BitMap_BytesPerRow 0
+#define PSSO_BitMap_Rows 2
+#define PSSO_BitMap_Flags 4
+#define PSSO_BitMap_Depth 5
+#define PSSO_BitMap_pad 6
+#define PSSO_BitMap_Planes 8
+#define PSSO_BitMap_sizeof 40
struct BitMap
{
/************************************************************************/
-#define SETTINGSNAMEMAXCHARS 30
-#define BOARDNAMEMAXCHARS 30
+#define SETTINGSNAMEMAXCHARS 30
+#define BOARDNAMEMAXCHARS 30
struct Settings {
- uae_u32 BoardType;
+ uae_u32 BoardType;
/* a value discribing assignment to nth board local to boardtype
* to be used for reassignment when boards are added or removed. */
- uae_u16 LocalOrdering;
- uae_s16 LastSelected;
- char NameField[SETTINGSNAMEMAXCHARS];
+ uae_u16 LocalOrdering;
+ uae_s16 LastSelected;
+ char NameField[SETTINGSNAMEMAXCHARS];
/* neu! */
- char *BoardName;
+ char *BoardName;
};
#define MAXRESOLUTIONNAMELENGTH 22
* only used within rtg.library *
********************************/
-#define PSSO_LibResolution_P96ID 14
-#define PSSO_LibResolution_Name 20
-#define PSSO_LibResolution_DisplayID 42 /* Name + MAXRESOLUTIONNAMELENGTH */
-#define PSSO_LibResolution_Width 46
-#define PSSO_LibResolution_Height 48
-#define PSSO_LibResolution_Flags 50
-#define PSSO_LibResolution_Modes 52
-#define PSSO_LibResolution_BoardInfo (52 + MAXMODES*4)
-#define PSSO_LibResolution_sizeof (60 + MAXMODES*4)
+#define PSSO_LibResolution_P96ID 14
+#define PSSO_LibResolution_Name 20
+#define PSSO_LibResolution_DisplayID 42 /* Name + MAXRESOLUTIONNAMELENGTH */
+#define PSSO_LibResolution_Width 46
+#define PSSO_LibResolution_Height 48
+#define PSSO_LibResolution_Flags 50
+#define PSSO_LibResolution_Modes 52
+#define PSSO_LibResolution_BoardInfo (52 + MAXMODES * 4)
+#define PSSO_LibResolution_sizeof (60 + MAXMODES * 4)
struct LibResolution {
char P96ID[6];
#define P96F_PUBLIC (1<<P96B_PUBLIC)
#define P96F_MONITOOL (1<<P96B_MONITOOL)
-#define PSSO_ModeInfo_OpenCount 14
-#define PSSO_ModeInfo_Active 16
-#define PSSO_ModeInfo_Width 18
-#define PSSO_ModeInfo_Height 20
-#define PSSO_ModeInfo_Depth 22
-#define PSSO_ModeInfo_Flags 23
-#define PSSO_ModeInfo_HorTotal 24
-#define PSSO_ModeInfo_HorBlankSize 26
-#define PSSO_ModeInfo_HorSyncStart 28
-#define PSSO_ModeInfo_HorSyncSize 30
-#define PSSO_ModeInfo_HorSyncSkew 32
+#define PSSO_ModeInfo_OpenCount 14
+#define PSSO_ModeInfo_Active 16
+#define PSSO_ModeInfo_Width 18
+#define PSSO_ModeInfo_Height 20
+#define PSSO_ModeInfo_Depth 22
+#define PSSO_ModeInfo_Flags 23
+#define PSSO_ModeInfo_HorTotal 24
+#define PSSO_ModeInfo_HorBlankSize 26
+#define PSSO_ModeInfo_HorSyncStart 28
+#define PSSO_ModeInfo_HorSyncSize 30
+#define PSSO_ModeInfo_HorSyncSkew 32
#define PSSO_ModeInfo_HorEnableSkew 33
-#define PSSO_ModeInfo_VerTotal 34
-#define PSSO_ModeInfo_VerBlankSize 36
-#define PSSO_ModeInfo_VerSyncStart 38
-#define PSSO_ModeInfo_VerSyncSize 40
-#define PSSO_ModeInfo_first_union 42
-#define PSSO_ModeInfo_second_union 43
-#define PSSO_ModeInfo_PixelClock 44
-#define PSSO_ModeInfo_sizeof 48
-
-#define PSSO_RenderInfo_Memory 0
-#define PSSO_RenderInfo_BytesPerRow 4
-#define PSSO_RenderInfo_pad 6
-#define PSSO_RenderInfo_RGBFormat 8
-#define PSSO_RenderInfo_sizeof 12
+#define PSSO_ModeInfo_VerTotal 34
+#define PSSO_ModeInfo_VerBlankSize 36
+#define PSSO_ModeInfo_VerSyncStart 38
+#define PSSO_ModeInfo_VerSyncSize 40
+#define PSSO_ModeInfo_first_union 42
+#define PSSO_ModeInfo_second_union 43
+#define PSSO_ModeInfo_PixelClock 44
+#define PSSO_ModeInfo_sizeof 48
+
+#define PSSO_RenderInfo_Memory 0
+#define PSSO_RenderInfo_BytesPerRow 4
+#define PSSO_RenderInfo_pad 6
+#define PSSO_RenderInfo_RGBFormat 8
+#define PSSO_RenderInfo_sizeof 12
struct RenderInfo {
uae_u8 *Memory;
#define PSSO_BitMapExtra_CompanionMaster 50
#define PSSO_BitMapExtra_Last 54
-#define PSSO_BoardInfo_RegisterBase 0
-#define PSSO_BoardInfo_MemoryBase PSSO_BoardInfo_RegisterBase + 4
-#define PSSO_BoardInfo_MemoryIOBase PSSO_BoardInfo_MemoryBase + 4
-#define PSSO_BoardInfo_MemorySize PSSO_BoardInfo_MemoryIOBase + 4
-#define PSSO_BoardInfo_BoardName PSSO_BoardInfo_MemorySize + 4
-#define PSSO_BoardInfo_VBIName PSSO_BoardInfo_BoardName + 4
-#define PSSO_BoardInfo_CardBase PSSO_BoardInfo_VBIName + 32
-#define PSSO_BoardInfo_ChipBase PSSO_BoardInfo_CardBase + 4
-#define PSSO_BoardInfo_ExecBase PSSO_BoardInfo_ChipBase + 4
-#define PSSO_BoardInfo_UtilBase PSSO_BoardInfo_ExecBase + 4
-#define PSSO_BoardInfo_HardInterrupt PSSO_BoardInfo_UtilBase + 4
-#define PSSO_BoardInfo_SoftInterrupt PSSO_BoardInfo_HardInterrupt + 22 /* The HardInterrupt is 22-bytes */
-#define PSSO_BoardInfo_BoardLock PSSO_BoardInfo_SoftInterrupt + 22 /* The SoftInterrupt is 22-bytes */
-#define PSSO_BoardInfo_ResolutionsList PSSO_BoardInfo_BoardLock + 46 /* On the BoardLock, we were having some fun... */
-#define PSSO_BoardInfo_BoardType PSSO_BoardInfo_ResolutionsList + 12 /* The ResolutionsList is 12-bytes */
-#define PSSO_BoardInfo_PaletteChipType PSSO_BoardInfo_BoardType + 4
-#define PSSO_BoardInfo_GraphicsControllerType PSSO_BoardInfo_PaletteChipType + 4
-#define PSSO_BoardInfo_MoniSwitch PSSO_BoardInfo_GraphicsControllerType + 4
-#define PSSO_BoardInfo_BitsPerCannon PSSO_BoardInfo_MoniSwitch + 2
-#define PSSO_BoardInfo_Flags PSSO_BoardInfo_BitsPerCannon + 2
-#define PSSO_BoardInfo_SoftSpriteFlags PSSO_BoardInfo_Flags + 4
-#define PSSO_BoardInfo_ChipFlags PSSO_BoardInfo_SoftSpriteFlags + 2
-#define PSSO_BoardInfo_CardFlags PSSO_BoardInfo_ChipFlags + 2
-#define PSSO_BoardInfo_BoardNum PSSO_BoardInfo_CardFlags + 4
-#define PSSO_BoardInfo_RGBFormats PSSO_BoardInfo_BoardNum + 2
-#define PSSO_BoardInfo_MaxHorValue PSSO_BoardInfo_RGBFormats + 2
-#define PSSO_BoardInfo_MaxVerValue PSSO_BoardInfo_MaxHorValue + MAXMODES*2
-#define PSSO_BoardInfo_MaxHorResolution PSSO_BoardInfo_MaxVerValue + MAXMODES*2
-#define PSSO_BoardInfo_MaxVerResolution PSSO_BoardInfo_MaxHorResolution + MAXMODES*2
-#define PSSO_BoardInfo_MaxMemorySize PSSO_BoardInfo_MaxVerResolution + MAXMODES*2
-#define PSSO_BoardInfo_MaxChunkSize PSSO_BoardInfo_MaxMemorySize + 4
-#define PSSO_BoardInfo_MemoryClock PSSO_BoardInfo_MaxChunkSize + 4
-#define PSSO_BoardInfo_PixelClockCount PSSO_BoardInfo_MemoryClock + 4
-#define PSSO_BoardInfo_AllocCardMem PSSO_BoardInfo_PixelClockCount + MAXMODES*4
-#define PSSO_BoardInfo_SpecialFeatures PSSO_BoardInfo_AllocCardMem + 68*4 /* 68 function pointers */
-#define PSSO_BoardInfo_ModeInfo PSSO_BoardInfo_SpecialFeatures + 12 /* SpecialFeatures is 12-bytes */
-#define PSSO_BoardInfo_RGBFormat PSSO_BoardInfo_ModeInfo + 4
-#define PSSO_BoardInfo_XOffset PSSO_BoardInfo_RGBFormat + 4
-#define PSSO_BoardInfo_YOffset PSSO_BoardInfo_XOffset + 2
-#define PSSO_BoardInfo_Depth PSSO_BoardInfo_YOffset + 2
-#define PSSO_BoardInfo_ClearMask PSSO_BoardInfo_Depth + 1
-#define PSSO_BoardInfo_Border PSSO_BoardInfo_ClearMask + 1
-#define PSSO_BoardInfo_Mask PSSO_BoardInfo_Border + 2 /* BOOL type is only 2-bytes! */
-#define PSSO_BoardInfo_CLUT PSSO_BoardInfo_Mask + 4
-#define PSSO_BoardInfo_ViewPort PSSO_BoardInfo_CLUT + 3*256
-#define PSSO_BoardInfo_VisibleBitMap PSSO_BoardInfo_ViewPort + 4
-#define PSSO_BoardInfo_BitMapExtra PSSO_BoardInfo_VisibleBitMap + 4
-#define PSSO_BoardInfo_BitMapList PSSO_BoardInfo_BitMapExtra + 4
-#define PSSO_BoardInfo_MemList PSSO_BoardInfo_BitMapList + 12 /* BitMapList is 12-bytes */
-#define PSSO_BoardInfo_MouseX PSSO_BoardInfo_MemList + 12 /* MemList is 12-bytes */
-#define PSSO_BoardInfo_MouseY PSSO_BoardInfo_MouseX + 2
-#define PSSO_BoardInfo_MouseWidth PSSO_BoardInfo_MouseY + 2
-#define PSSO_BoardInfo_MouseHeight PSSO_BoardInfo_MouseWidth + 1
-#define PSSO_BoardInfo_MouseXOffset PSSO_BoardInfo_MouseHeight + 1
-#define PSSO_BoardInfo_MouseYOffset PSSO_BoardInfo_MouseXOffset + 1
-#define PSSO_BoardInfo_MouseImage PSSO_BoardInfo_MouseYOffset + 1
-#define PSSO_BoardInfo_MousePens PSSO_BoardInfo_MouseImage + 4
-#define PSSO_BoardInfo_MouseRect PSSO_BoardInfo_MousePens + 4
-#define PSSO_BoardInfo_MouseChunky PSSO_BoardInfo_MouseRect + 8 /* MouseRect is 8-bytes */
-#define PSSO_BoardInfo_MouseRendered PSSO_BoardInfo_MouseChunky + 4
-#define PSSO_BoardInfo_MouseSaveBuffer PSSO_BoardInfo_MouseRendered + 4
-
-#if 0
-struct BoardInfo{
- UBYTE *RegisterBase, *MemoryBase, *MemoryIOBase;
- ULONG MemorySize;
- char *BoardName,VBIName[32];
- struct CardBase *CardBase;
- struct ChipBase *ChipBase;
- struct ExecBase *ExecBase;
- struct Library *UtilBase;
- struct Interrupt HardInterrupt;
- struct Interrupt SoftInterrupt;
- struct SignalSemaphore BoardLock;
- struct MinList ResolutionsList;
- BTYPE BoardType;
- PCTYPE PaletteChipType;
- GCTYPE GraphicsControllerType;
- UWORD MoniSwitch;
- UWORD BitsPerCannon;
- ULONG Flags;
- UWORD SoftSpriteFlags;
- UWORD ChipFlags; // private, chip specific, not touched by RTG
- ULONG CardFlags; // private, card specific, not touched by RTG
- UWORD BoardNum;
- UWORD RGBFormats;
- UWORD MaxHorValue[MAXMODES];
- UWORD MaxVerValue[MAXMODES];
- UWORD MaxHorResolution[MAXMODES];
- UWORD MaxVerResolution[MAXMODES];
- ULONG MaxMemorySize, MaxChunkSize;
- ULONG __obsolete;
- ULONG PixelClockCount[MAXMODES];
-
- APTR __asm (*AllocCardMem)(register __a0 struct BoardInfo *bi, register __d0 ULONG size, register __d1 BOOL force, register __d2 BOOL system);
- BOOL __asm (*FreeCardMem)(register __a0 struct BoardInfo *bi, register __a1 APTR membase);
-
- BOOL __asm (*SetSwitch)(register __a0 struct BoardInfo *, register __d0 BOOL);
-
- void __asm (*SetColorArray)(register __a0 struct BoardInfo *, register __d0 UWORD, register __d1 UWORD);
-
- void __asm (*SetDAC)(register __a0 struct BoardInfo *, register __d7 RGBFTYPE);
- void __asm (*SetGC)(register __a0 struct BoardInfo *, register __a1 struct ModeInfo *, register __d0 BOOL);
- void __asm (*SetPanning)(register __a0 struct BoardInfo *, register __a1 UBYTE *, register __d0 UWORD, register __d1 WORD, register __d2 WORD, register __d7 RGBFTYPE);
- UWORD __asm (*CalculateBytesPerRow)(register __a0 struct BoardInfo *, register __d0 UWORD, register __d7 RGBFTYPE);
- APTR __asm (*CalculateMemory)(register __a0 struct BoardInfo *, register __a1 APTR, register __d7 RGBFTYPE);
- ULONG __asm (*GetCompatibleFormats)(register __a0 struct BoardInfo *, register __d7 RGBFTYPE);
- BOOL __asm (*SetDisplay)(register __a0 struct BoardInfo *, register __d0 BOOL);
-
- LONG __asm (*ResolvePixelClock)(register __a0 struct BoardInfo *, register __a1 struct ModeInfo *, register __d0 ULONG, register __d7 RGBFTYPE);
- ULONG __asm (*GetPixelClock)(register __a0 struct BoardInfo *bi, register __a1 struct ModeInfo *mi, register __d0 Index, register __d7 RGBFormat);
- void __asm (*SetClock)(register __a0 struct BoardInfo *);
-
- void __asm (*SetMemoryMode)(register __a0 struct BoardInfo *, register __d7 RGBFTYPE);
- void __asm (*SetWriteMask)(register __a0 struct BoardInfo *, register __d0 UBYTE);
- void __asm (*SetClearMask)(register __a0 struct BoardInfo *, register __d0 UBYTE);
- void __asm (*SetReadPlane)(register __a0 struct BoardInfo *, register __d0 UBYTE);
-
- void __asm (*WaitVerticalSync)(register __a0 struct BoardInfo *, register __d0 BOOL);
- BOOL __asm (*SetInterrupt)(register __a0 struct BoardInfo *, register __d0 BOOL);
-
- void __asm (*WaitBlitter)(register __a0 struct BoardInfo *);
-
- void __asm (*ScrollPlanar)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 UWORD, register __d1 UWORD, register __d2 UWORD, register __d3 UWORD, register __d4 UWORD, register __d5 UWORD, register __d6 UBYTE);
- void __asm (*ScrollPlanarDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 UWORD, register __d1 UWORD, register __d2 UWORD, register __d3 UWORD, register __d4 UWORD, register __d5 UWORD, register __d6 UBYTE);
- void __asm (*UpdatePlanar)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 UBYTE);
- void __asm (*UpdatePlanarDefault)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 UBYTE);
- void __asm (*BlitPlanar2Chunky)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 SHORT, register __d5 SHORT, register __d6 UBYTE, register __d7 UBYTE);
- void __asm (*BlitPlanar2ChunkyDefault)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 SHORT, register __d5 SHORT, register __d6 UBYTE, register __d7 UBYTE);
-
- void __asm (*FillRect)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 ULONG, register __d5 UBYTE, register __d7 RGBFTYPE);
- void __asm (*FillRectDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 ULONG, register __d5 UBYTE, register __d7 RGBFTYPE);
- void __asm (*InvertRect)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*InvertRectDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitRect)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 WORD, register __d5 WORD, register __d6 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitRectDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 WORD, register __d5 WORD, register __d6 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitTemplate)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct Template *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitTemplateDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct Template *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitPattern)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct Pattern *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitPatternDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct Pattern *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*DrawLine)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*DrawLineDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitRectNoMaskComplete)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 WORD, register __d5 WORD, register __d6 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitRectNoMaskCompleteDefault)(register __a0 struct BoardInfo *, register __a1 struct RenderInfo *, register __a2 struct RenderInfo *, register __d0 WORD, register __d1 WORD, register __d2 WORD, register __d3 WORD, register __d4 WORD, register __d5 WORD, register __d6 UBYTE, register __d7 RGBFTYPE);
- void __asm (*BlitPlanar2Direct)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __a3 struct ColorIndexMapping *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 SHORT, register __d5 SHORT, register __d6 UBYTE, register __d7 UBYTE);
- void __asm (*BlitPlanar2DirectDefault)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct RenderInfo *, register __a3 struct ColorIndexMapping *, register __d0 SHORT, register __d1 SHORT, register __d2 SHORT, register __d3 SHORT, register __d4 SHORT, register __d5 SHORT, register __d6 UBYTE, register __d7 UBYTE);
- void __asm (*Reserved0)(register __a0 struct BoardInfo *);
- void __asm (*Reserved0Default)(register __a0 struct BoardInfo *);
- void __asm (*Reserved1)(register __a0 struct BoardInfo *);
- void __asm (*Reserved1Default)(register __a0 struct BoardInfo *);
- void __asm (*Reserved2)(register __a0 struct BoardInfo *);
- void __asm (*Reserved2Default)(register __a0 struct BoardInfo *);
- void __asm (*Reserved3)(register __a0 struct BoardInfo *);
- void __asm (*Reserved3Default)(register __a0 struct BoardInfo *);
- void __asm (*Reserved4)(register __a0 struct BoardInfo *);
- void __asm (*Reserved4Default)(register __a0 struct BoardInfo *);
- void __asm (*Reserved5)(register __a0 struct BoardInfo *);
- void __asm (*Reserved5Default)(register __a0 struct BoardInfo *);
- void __asm (*SetDPMSLevel)(register __a0 struct BoardInfo *, register __d0 ULONG DPMSLevel);
- void __asm (*ResetChip)(register __a0 struct BoardInfo *);
- ULONG __asm (*GetFeatureAttrs)(register __a0 struct BoardInfo *bi, register __a1 APTR FeatureData, register __d0 ULONG Type, register __a2 struct TagItem *Tags);
-
- struct BitMap * __asm (*AllocBitMap)(register __a0 struct BoardInfo *, register __d0 ULONG, register __d1 ULONG, register __a1 struct TagItem *);
- BOOL __asm (*FreeBitMap)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __a2 struct TagItem *);
- ULONG __asm (*GetBitMapAttr)(register __a0 struct BoardInfo *, register __a1 struct BitMap *, register __d0 ULONG);
-
- BOOL __asm (*SetSprite)(register __a0 struct BoardInfo *, register __d0 BOOL, register __d7 RGBFTYPE);
- void __asm (*SetSpritePosition)(register __a0 struct BoardInfo *, register __d0 WORD, register __d1 WORD, register __d7 RGBFTYPE);
- void __asm (*SetSpriteImage)(register __a0 struct BoardInfo *, register __d7 RGBFTYPE);
- void __asm (*SetSpriteColor)(register __a0 struct BoardInfo *, register __d0 UBYTE, register __d1 UBYTE, register __d2 UBYTE, register __d3 UBYTE, register __d7 RGBFTYPE);
-
- APTR __asm (*CreateFeature)(register __a0 struct BoardInfo *bi, register __d0 ULONG Type, register __a1 struct TagItem *Tags);
- ULONG __asm (*SetFeatureAttrs)(register __a0 struct BoardInfo *bi, register __a1 APTR FeatureData, register __d0 ULONG Type, register __a2 struct TagItem *Tags);
- BOOL __asm (*DeleteFeature)(register __a0 struct BoardInfo *bi, register __a1 APTR FeatureData, register __d0 ULONG Type);
- struct MinList SpecialFeatures;
-
- struct ModeInfo *ModeInfo; /* Chip Settings Stuff */
- RGBFTYPE RGBFormat;
- WORD XOffset, YOffset;
- UBYTE Depth;
- UBYTE ClearMask;
- BOOL Border;
- ULONG Mask;
- struct CLUTEntry CLUT[256];
-
- struct ViewPort *ViewPort; /* ViewPort Stuff */
- struct BitMap *VisibleBitMap;
- struct BitMapExtra *BitMapExtra;
- struct MinList BitMapList;
- struct MinList MemList;
-
- WORD MouseX, MouseY; /* Sprite Stuff */
- UBYTE MouseWidth, MouseHeight;
- UBYTE MouseXOffset, MouseYOffset;
- UWORD *MouseImage;
- UBYTE MousePens[4];
- struct Rectangle MouseRect;
- UBYTE *MouseChunky;
- UWORD *MouseRendered;
- UBYTE *MouseSaveBuffer;
-
- ULONG ChipData[16]; /* for chip driver needs */
- ULONG CardData[16]; /* for card driver needs */
-
- APTR MemorySpaceBase; /* the base address of the board memory address space */
- ULONG MemorySpaceSize; /* size of that area */
-
- APTR DoubleBufferList; /* chain of dbinfos being notified on vblanks */
-
- struct timeval SyncTime; /* system time when screen was set up, used for pseudo vblanks */
- ULONG SyncPeriod; /* length of one frame in micros */
- struct MsgPort SoftVBlankPort; /* MsgPort for software emulation of board interrupt */
-};
-#endif
+#define PSSO_BoardInfo_RegisterBase 0
+#define PSSO_BoardInfo_MemoryBase PSSO_BoardInfo_RegisterBase + 4
+#define PSSO_BoardInfo_MemoryIOBase PSSO_BoardInfo_MemoryBase + 4
+#define PSSO_BoardInfo_MemorySize PSSO_BoardInfo_MemoryIOBase + 4
+#define PSSO_BoardInfo_BoardName PSSO_BoardInfo_MemorySize + 4
+#define PSSO_BoardInfo_VBIName PSSO_BoardInfo_BoardName + 4
+#define PSSO_BoardInfo_CardBase PSSO_BoardInfo_VBIName + 32
+#define PSSO_BoardInfo_ChipBase PSSO_BoardInfo_CardBase + 4
+#define PSSO_BoardInfo_ExecBase PSSO_BoardInfo_ChipBase + 4
+#define PSSO_BoardInfo_UtilBase PSSO_BoardInfo_ExecBase + 4
+#define PSSO_BoardInfo_HardInterrupt PSSO_BoardInfo_UtilBase + 4
+#define PSSO_BoardInfo_SoftInterrupt PSSO_BoardInfo_HardInterrupt + 22 /* The HardInterrupt is 22-bytes */
+#define PSSO_BoardInfo_BoardLock PSSO_BoardInfo_SoftInterrupt + 22 /* The SoftInterrupt is 22-bytes */
+#define PSSO_BoardInfo_ResolutionsList PSSO_BoardInfo_BoardLock + 46 /* On the BoardLock, we were having some fun... */
+#define PSSO_BoardInfo_BoardType PSSO_BoardInfo_ResolutionsList + 12 /* The ResolutionsList is 12-bytes */
+#define PSSO_BoardInfo_PaletteChipType PSSO_BoardInfo_BoardType + 4
+#define PSSO_BoardInfo_GraphicsControllerType PSSO_BoardInfo_PaletteChipType + 4
+#define PSSO_BoardInfo_MoniSwitch PSSO_BoardInfo_GraphicsControllerType + 4
+#define PSSO_BoardInfo_BitsPerCannon PSSO_BoardInfo_MoniSwitch + 2
+#define PSSO_BoardInfo_Flags PSSO_BoardInfo_BitsPerCannon + 2
+#define PSSO_BoardInfo_SoftSpriteFlags PSSO_BoardInfo_Flags + 4
+#define PSSO_BoardInfo_ChipFlags PSSO_BoardInfo_SoftSpriteFlags + 2
+#define PSSO_BoardInfo_CardFlags PSSO_BoardInfo_ChipFlags + 2
+#define PSSO_BoardInfo_BoardNum PSSO_BoardInfo_CardFlags + 4
+#define PSSO_BoardInfo_RGBFormats PSSO_BoardInfo_BoardNum + 2
+#define PSSO_BoardInfo_MaxHorValue PSSO_BoardInfo_RGBFormats + 2
+#define PSSO_BoardInfo_MaxVerValue PSSO_BoardInfo_MaxHorValue + MAXMODES * 2
+#define PSSO_BoardInfo_MaxHorResolution PSSO_BoardInfo_MaxVerValue + MAXMODES * 2
+#define PSSO_BoardInfo_MaxVerResolution PSSO_BoardInfo_MaxHorResolution + MAXMODES * 2
+#define PSSO_BoardInfo_MaxMemorySize PSSO_BoardInfo_MaxVerResolution + MAXMODES * 2
+#define PSSO_BoardInfo_MaxChunkSize PSSO_BoardInfo_MaxMemorySize + 4
+#define PSSO_BoardInfo_MemoryClock PSSO_BoardInfo_MaxChunkSize + 4
+#define PSSO_BoardInfo_PixelClockCount PSSO_BoardInfo_MemoryClock + 4
+
+#define PSSO_BoardInfo_AllocCardMem PSSO_BoardInfo_PixelClockCount + MAXMODES * 4
+#define PSSO_BoardInfo_FreeCardMem PSSO_BoardInfo_AllocCardMem + 4
+
+#define PSSO_BoardInfo_SetSwitch PSSO_BoardInfo_FreeCardMem + 4
+
+#define PSSO_BoardInfo_SetColorArray PSSO_BoardInfo_SetSwitch + 4
+
+#define PSSO_BoardInfo_SetDAC PSSO_BoardInfo_SetColorArray + 4
+#define PSSO_BoardInfo_SetGC PSSO_BoardInfo_SetDAC + 4
+#define PSSO_BoardInfo_SetPanning PSSO_BoardInfo_SetGC + 4
+#define PSSO_BoardInfo_CalculateBytesPerRow PSSO_BoardInfo_SetPanning + 4
+#define PSSO_BoardInfo_CalculateMemory PSSO_BoardInfo_CalculateBytesPerRow + 4
+#define PSSO_BoardInfo_GetCompatibleFormats PSSO_BoardInfo_CalculateMemory + 4
+#define PSSO_BoardInfo_SetDisplay PSSO_BoardInfo_GetCompatibleFormats + 4
+
+#define PSSO_BoardInfo_ResolvePixelClock PSSO_BoardInfo_SetDisplay + 4
+#define PSSO_BoardInfo_GetPixelClock PSSO_BoardInfo_ResolvePixelClock + 4
+#define PSSO_BoardInfo_SetClock PSSO_BoardInfo_GetPixelClock + 4
+
+#define PSSO_BoardInfo_SetMemoryMode PSSO_BoardInfo_SetClock + 4
+#define PSSO_BoardInfo_SetWriteMask PSSO_BoardInfo_SetMemoryMode + 4
+#define PSSO_BoardInfo_SetClearMask PSSO_BoardInfo_SetWriteMask + 4
+#define PSSO_BoardInfo_SetReadPlane PSSO_BoardInfo_SetClearMask + 4
+
+#define PSSO_BoardInfo_WaitVerticalSync PSSO_BoardInfo_SetReadPlane + 4
+#define PSSO_BoardInfo_SetInterrupt PSSO_BoardInfo_WaitVerticalSync + 4
+
+#define PSSO_BoardInfo_WaitBlitter PSSO_BoardInfo_SetInterrupt + 4
+
+#define PSSO_BoardInfo_ScrollPlanar PSSO_BoardInfo_WaitBlitter + 4
+#define PSSO_BoardInfo_ScrollPlanarDefault PSSO_BoardInfo_ScrollPlanar + 4
+#define PSSO_BoardInfo_UpdatePlanar PSSO_BoardInfo_ScrollPlanarDefault + 4
+#define PSSO_BoardInfo_UpdatePlanarDefault PSSO_BoardInfo_UpdatePlanar + 4
+#define PSSO_BoardInfo_BlitPlanar2Chunky PSSO_BoardInfo_UpdatePlanarDefault + 4
+#define PSSO_BoardInfo_BlitPlanar2ChunkyDefault PSSO_BoardInfo_BlitPlanar2Chunky + 4
+
+#define PSSO_BoardInfo_FillRect PSSO_BoardInfo_BlitPlanar2ChunkyDefault + 4
+#define PSSO_BoardInfo_FillRectDefault PSSO_BoardInfo_FillRect + 4
+#define PSSO_BoardInfo_InvertRect PSSO_BoardInfo_FillRectDefault + 4
+#define PSSO_BoardInfo_InvertRectDefault PSSO_BoardInfo_InvertRect + 4
+#define PSSO_BoardInfo_BlitRect PSSO_BoardInfo_InvertRectDefault + 4
+#define PSSO_BoardInfo_BlitRectDefault PSSO_BoardInfo_BlitRect + 4
+#define PSSO_BoardInfo_BlitTemplate PSSO_BoardInfo_BlitRectDefault + 4
+#define PSSO_BoardInfo_BlitTemplateDefault PSSO_BoardInfo_BlitTemplate + 4
+#define PSSO_BoardInfo_BlitPattern PSSO_BoardInfo_BlitTemplateDefault + 4
+#define PSSO_BoardInfo_BlitPatternDefault PSSO_BoardInfo_BlitPattern + 4
+#define PSSO_BoardInfo_DrawLine PSSO_BoardInfo_BlitPatternDefault + 4
+#define PSSO_BoardInfo_DrawLineDefault PSSO_BoardInfo_DrawLine + 4
+#define PSSO_BoardInfo_BlitRectNoMaskComplete PSSO_BoardInfo_DrawLineDefault + 4
+#define PSSO_BoardInfo_BlitRectNoMaskCompleteDefault PSSO_BoardInfo_BlitRectNoMaskComplete + 4
+#define PSSO_BoardInfo_BlitPlanar2Direct PSSO_BoardInfo_BlitRectNoMaskCompleteDefault + 4
+#define PSSO_BoardInfo_BlitPlanar2DirectDefault PSSO_BoardInfo_BlitPlanar2Direct + 4
+
+#define PSSO_BoardInfo_Reserved0 PSSO_BoardInfo_BlitPlanar2DirectDefault + 4
+#define PSSO_BoardInfo_Reserved0Default PSSO_BoardInfo_Reserved0 + 4
+#define PSSO_BoardInfo_Reserved1 PSSO_BoardInfo_Reserved0Default + 4
+#define PSSO_BoardInfo_Reserved1Default PSSO_BoardInfo_Reserved1 + 4
+#define PSSO_BoardInfo_Reserved2 PSSO_BoardInfo_Reserved1Default + 4
+#define PSSO_BoardInfo_Reserved2Default PSSO_BoardInfo_Reserved2 + 4
+#define PSSO_BoardInfo_Reserved3 PSSO_BoardInfo_Reserved2Default + 4
+#define PSSO_BoardInfo_Reserved3Default PSSO_BoardInfo_Reserved3 + 4
+#define PSSO_BoardInfo_Reserved4 PSSO_BoardInfo_Reserved3Default + 4
+#define PSSO_BoardInfo_Reserved4Default PSSO_BoardInfo_Reserved4 + 4
+#define PSSO_BoardInfo_Reserved5 PSSO_BoardInfo_Reserved4Default + 4
+#define PSSO_BoardInfo_Reserved5Default PSSO_BoardInfo_Reserved5 + 4
+
+#define PSSO_BoardInfo_SetDPMSLevel PSSO_BoardInfo_Reserved5Default + 4
+#define PSSO_BoardInfo_ResetChip PSSO_BoardInfo_SetDPMSLevel + 4
+
+#define PSSO_BoardInfo_GetFeatureAttrs PSSO_BoardInfo_ResetChip + 4
+
+#define PSSO_BoardInfo_AllocBitMap PSSO_BoardInfo_GetFeatureAttrs + 4
+#define PSSO_BoardInfo_FreeBitMap PSSO_BoardInfo_AllocBitMap + 4
+#define PSSO_BoardInfo_GetBitMapAttr PSSO_BoardInfo_FreeBitMap + 4
+
+#define PSSO_BoardInfo_SetSprite PSSO_BoardInfo_GetBitMapAttr + 4
+#define PSSO_BoardInfo_SetSpritePosition PSSO_BoardInfo_SetSprite + 4
+#define PSSO_BoardInfo_SetSpriteImage PSSO_BoardInfo_SetSpritePosition + 4
+#define PSSO_BoardInfo_SetSpriteColor PSSO_BoardInfo_SetSpriteImage + 4
+
+#define PSSO_BoardInfo_CreateFeature PSSO_BoardInfo_SetSpriteColor + 4
+#define PSSO_BoardInfo_SetFeatureAttrs PSSO_BoardInfo_CreateFeature + 4
+#define PSSO_BoardInfo_DeleteFeature PSSO_BoardInfo_SetFeatureAttrs + 4
+#define PSSO_BoardInfo_SpecialFeatures PSSO_BoardInfo_DeleteFeature + 4
+
+#define PSSO_BoardInfo_ModeInfo PSSO_BoardInfo_SpecialFeatures + 12 /* SpecialFeatures is 12-bytes */
+#define PSSO_BoardInfo_RGBFormat PSSO_BoardInfo_ModeInfo + 4
+#define PSSO_BoardInfo_XOffset PSSO_BoardInfo_RGBFormat + 4
+#define PSSO_BoardInfo_YOffset PSSO_BoardInfo_XOffset + 2
+#define PSSO_BoardInfo_Depth PSSO_BoardInfo_YOffset + 2
+#define PSSO_BoardInfo_ClearMask PSSO_BoardInfo_Depth + 1
+#define PSSO_BoardInfo_Border PSSO_BoardInfo_ClearMask + 1
+#define PSSO_BoardInfo_Mask PSSO_BoardInfo_Border + 2 /* BOOL type is only 2-bytes! */
+#define PSSO_BoardInfo_CLUT PSSO_BoardInfo_Mask + 4
+#define PSSO_BoardInfo_ViewPort PSSO_BoardInfo_CLUT + 3*256
+#define PSSO_BoardInfo_VisibleBitMap PSSO_BoardInfo_ViewPort + 4
+#define PSSO_BoardInfo_BitMapExtra PSSO_BoardInfo_VisibleBitMap + 4
+#define PSSO_BoardInfo_BitMapList PSSO_BoardInfo_BitMapExtra + 4
+#define PSSO_BoardInfo_MemList PSSO_BoardInfo_BitMapList + 12 /* BitMapList is 12-bytes */
+#define PSSO_BoardInfo_MouseX PSSO_BoardInfo_MemList + 12 /* MemList is 12-bytes */
+#define PSSO_BoardInfo_MouseY PSSO_BoardInfo_MouseX + 2
+#define PSSO_BoardInfo_MouseWidth PSSO_BoardInfo_MouseY + 2
+#define PSSO_BoardInfo_MouseHeight PSSO_BoardInfo_MouseWidth + 1
+#define PSSO_BoardInfo_MouseXOffset PSSO_BoardInfo_MouseHeight + 1
+#define PSSO_BoardInfo_MouseYOffset PSSO_BoardInfo_MouseXOffset + 1
+#define PSSO_BoardInfo_MouseImage PSSO_BoardInfo_MouseYOffset + 1
+#define PSSO_BoardInfo_MousePens PSSO_BoardInfo_MouseImage + 4
+#define PSSO_BoardInfo_MouseRect PSSO_BoardInfo_MousePens + 4
+#define PSSO_BoardInfo_MouseChunky PSSO_BoardInfo_MouseRect + 8 /* MouseRect is 8-bytes */
+#define PSSO_BoardInfo_MouseRendered PSSO_BoardInfo_MouseChunky + 4
+#define PSSO_BoardInfo_MouseSaveBuffer PSSO_BoardInfo_MouseRendered + 4
+
+#define PSSO_BoardInfo_ChipData PSSO_BoardInfo_MouseSaveBuffer + 4
+#define PSSO_BoardInfo_CardData PSSO_BoardInfo_ChipData + 16 * 4
+#define PSSO_BoardInfo_MemorySpaceBase PSSO_BoardInfo_CardData + 16 * 4
+#define PSSO_BoardInfo_MemorySpaceSize PSSO_BoardInfo_MemorySpaceBase + 4
+#define PSSO_BoardInfo_DoubleBufferList PSSO_BoardInfo_MemorySpaceSize + 4
+#define PSSO_BoardInfo_SyncTime PSSO_BoardInfo_DoubleBufferList + 4
+#define PSSO_BoardInfo_SyncPeriod PSSO_BoardInfo_SyncTime + 4
+#define PSSO_BoardInfo_SoftVBlankPort PSSO_BoardInfo_SyncPeriod + 8
+#define PSSO_BoardInfo_SizeOf PSSO_BoardInfo_SoftVBlankPort + 34
/* BoardInfo flags */
/* 0-15: hardware flags */
/* 16-31: user flags */
-#define BIB_HARDWARESPRITE 0 /* board has hardware sprite */
-#define BIB_NOMEMORYMODEMIX 1 /* board does not support modifying planar bitmaps while displaying chunky and vice versa */
-#define BIB_NEEDSALIGNMENT 2 /* bitmaps have to be aligned (not yet supported!) */
-#define BIB_DBLSCANDBLSPRITEY 8 /* hardware sprite y position is doubled on doublescan display modes */
-#define BIB_ILACEHALFSPRITEY 9 /* hardware sprite y position is halved on interlace display modes */
+#define BIB_HARDWARESPRITE 0 /* board has hardware sprite */
+#define BIB_NOMEMORYMODEMIX 1 /* board does not support modifying planar bitmaps while displaying chunky and vice versa */
+#define BIB_NEEDSALIGNMENT 2 /* bitmaps have to be aligned (not yet supported!) */
+#define BIB_DBLSCANDBLSPRITEY 8 /* hardware sprite y position is doubled on doublescan display modes */
+#define BIB_ILACEHALFSPRITEY 9 /* hardware sprite y position is halved on interlace display modes */
#define BIB_ILACEDBLROWOFFSET 10 /* doubled row offset in interlaced display modes needs additional horizontal bit */
#define BIB_FLICKERFIXER 12 /* board can flicker fix Amiga RGB signal */
#define BIB_IGNOREMASK BIB_NOMASKBLITS
-#define BIF_HARDWARESPRITE (1<<BIB_HARDWARESPRITE)
-#define BIF_NOMEMORYMODEMIX (1<<BIB_NOMEMORYMODEMIX)
-#define BIF_NEEDSALIGNMENT (1<<BIB_NEEDSALIGNMENT)
-#define BIF_DBLSCANDBLSPRITEY (1<<BIB_DBLSCANDBLSPRITEY)
-#define BIF_ILACEHALFSPRITEY (1<<BIB_ILACEHALFSPRITEY)
-#define BIF_ILACEDBLROWOFFSET (1<<BIB_ILACEDBLROWOFFSET)
-#define BIF_FLICKERFIXER (1<<BIB_FLICKERFIXER)
-#define BIF_VIDEOCAPTURE (1<<BIB_VIDEOCAPTURE)
-#define BIF_VIDEOWINDOW (1<<BIB_VIDEOWINDOW)
-#define BIF_BLITTER (1<<BIB_BLITTER)
-#define BIF_HIRESSPRITE (1<<BIB_HIRESSPRITE)
-#define BIF_BIGSPRITE (1<<BIB_BIGSPRITE)
-#define BIF_BORDEROVERRIDE (1<<BIB_BORDEROVERRIDE)
-#define BIF_BORDERBLANK (1<<BIB_BORDERBLANK)
-#define BIF_INDISPLAYCHAIN (1<<BIB_INDISPLAYCHAIN)
-#define BIF_QUIET (1<<BIB_QUIET)
-#define BIF_NOMASKBLITS (1<<BIB_NOMASKBLITS)
-#define BIF_NOC2PBLITS (1<<BIB_NOC2PBLITS)
-#define BIF_NOBLITTER (1<<BIB_NOBLITTER)
+#define BIF_HARDWARESPRITE (1 << BIB_HARDWARESPRITE)
+#define BIF_NOMEMORYMODEMIX (1 << BIB_NOMEMORYMODEMIX)
+#define BIF_NEEDSALIGNMENT (1 << BIB_NEEDSALIGNMENT)
+#define BIF_DBLSCANDBLSPRITEY (1 << BIB_DBLSCANDBLSPRITEY)
+#define BIF_ILACEHALFSPRITEY (1 << BIB_ILACEHALFSPRITEY)
+#define BIF_ILACEDBLROWOFFSET (1 << BIB_ILACEDBLROWOFFSET)
+#define BIF_FLICKERFIXER (1 << BIB_FLICKERFIXER)
+#define BIF_VIDEOCAPTURE (1 << BIB_VIDEOCAPTURE)
+#define BIF_VIDEOWINDOW (1 << BIB_VIDEOWINDOW)
+#define BIF_BLITTER (1 << BIB_BLITTER)
+#define BIF_HIRESSPRITE (1 << BIB_HIRESSPRITE)
+#define BIF_BIGSPRITE (1 << BIB_BIGSPRITE)
+#define BIF_BORDEROVERRIDE (1 << BIB_BORDEROVERRIDE)
+#define BIF_BORDERBLANK (1 << BIB_BORDERBLANK)
+#define BIF_INDISPLAYCHAIN (1 << BIB_INDISPLAYCHAIN)
+#define BIF_QUIET (1 << BIB_QUIET)
+#define BIF_NOMASKBLITS (1 << BIB_NOMASKBLITS)
+#define BIF_NOC2PBLITS (1 << BIB_NOC2PBLITS)
+#define BIF_NOBLITTER (1 << BIB_NOBLITTER)
#define BIF_IGNOREMASK BIF_NOMASKBLITS
uae_u8 BytesPerPixel;
uae_u8 CardFound;
//here follow winuae additional entrys
- uae_u8 BigAssBitmap; /* Set to 1 when our Amiga screen is bigger than the displayable area */
- unsigned int Version;
- uae_u8 *HostAddress; /* Active screen address (PC-side) */
+ uae_u8 BigAssBitmap; /* Set to 1 when our Amiga screen is bigger than the displayable area */
+ unsigned int Version;
+ uae_u8 *HostAddress; /* Active screen address (PC-side) */
// host address is need because Windows
// support NO direct access all the time to gfx Card
// everytime windows can remove your surface from card so the mainrender place
extern void InitPicasso96 (void);
-extern int GetNumResolutions( void );
-extern int GetDisplayModeIndex( uae_u32 x, uae_u32 y, uae_u32 d);
-
-extern uae_u32 REGPARAM3 picasso_SetDisplay (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_CalculateBytesPerRow (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_FillRect (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitRect (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_InvertRect (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetPanning (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetGC (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetDAC (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetColorArray (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSwitch (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSwitch (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_FindCard (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_InitCard (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitPlanar2Chunky (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitPlanar2Direct (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitTemplate (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitPattern (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_BlitRectNoMaskComplete (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSprite (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSpritePosition (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSpriteImage (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_SetSpriteColor (struct regstruct *regs);
-extern uae_u32 REGPARAM3 picasso_DrawLine (struct regstruct *regs);
-
extern uae_u32 gfxmem_mask;
extern uae_u8 *gfxmemory;
extern int DX_InvertRect (int X, int Y, int Width, int Height);
extern void DX_SetPalette (int start, int count);
-extern int DX_BitsPerCannon (void);
extern void DX_Invalidate (int, int, int, int);
-extern int DX_Flip(void);
+extern int DX_Flip (void);
extern void picasso_enablescreen (int on);
extern void picasso_refresh (void);
extern void picasso_handle_vsync (void);
extern void picasso_handle_hsync (void);
extern int picasso_palette (void);
-extern uae_u8 *gfxmemory;
-
/* This structure describes the UAE-side framebuffer for the Picasso
* screen. */
struct picasso_vidbuf_description {
extern int p96refresh_active;
extern int p96hsync_counter;
+#define LIB_SIZE 34
+#define CARD_FLAGS LIB_SIZE
+#define CARD_EXECBASE CARD_FLAGS + 2
+#define CARD_EXPANSIONBASE CARD_EXECBASE + 4
+#define CARD_SEGMENTLIST CARD_EXPANSIONBASE + 4
+#define CARD_NAME CARD_SEGMENTLIST + 4
+/* uae specific stuff */
+#define CARD_RESLIST CARD_NAME + 4
+#define CARD_BOARDINFO CARD_RESLIST + 4
+#define CARD_SIZEOF CARD_BOARDINFO + 4
+
#endif
#endif
cd c:\projects\winuae\src\od-win32
zip -9 winuaedebug%1 winuae_msvc\release\winuae.pdb winuae_msvc\fullrelease\winuae.pdb
move winuaedebug%1.zip d:\amiga\winuaepackets\
+copy winuae_msvc\fullrelease\winuae.pdb d:\amiga\dump
+copy d:\amiga\winuae.exe d:\amiga\dump
char *libname = "amigaforever.dll";
h = WIN32_LoadLibrary (libname);
- if (!h)
- return NULL;
+ if (!h) {
+ char path[MAX_DPATH];
+ sprintf (path, "%s..\\Player\\%s", start_path_exe, libname);
+ h = LoadLibrary (path);
+ if (!h)
+ return NULL;
+ }
GetModuleFileName(h, name, MAX_DPATH);
pfnGetKey = (PFN_GetKey)GetProcAddress(h, "GetKey");
if (pfnGetKey) {
return 1;
}
-typedef HRESULT (CALLBACK* SHGETFOLDERPATH)(HWND,int,HANDLE,DWORD,LPTSTR);
-typedef BOOL (CALLBACK* SHGETSPECIALFOLDERPATH)(HWND,LPTSTR,int,BOOL);
-
void create_afnewdir(int remove)
{
- SHGETFOLDERPATH pSHGetFolderPath;
- SHGETSPECIALFOLDERPATH pSHGetSpecialFolderPath;
char tmp[MAX_DPATH], tmp2[MAX_DPATH];
- BOOL ok = FALSE;
-
- pSHGetFolderPath = (SHGETFOLDERPATH)GetProcAddress(
- GetModuleHandle("shell32.dll"), "SHGetFolderPathA");
- pSHGetSpecialFolderPath = (SHGETSPECIALFOLDERPATH)GetProcAddress(
- GetModuleHandle("shell32.dll"), "SHGetSpecialFolderPathA");
- if (pSHGetFolderPath)
- ok = SUCCEEDED(pSHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, tmp));
- else if (pSHGetSpecialFolderPath)
- ok = pSHGetSpecialFolderPath(NULL, tmp, CSIDL_COMMON_DOCUMENTS, 0);
- if (ok) {
+
+ if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, tmp))) {
fixtrailing(tmp);
strcpy (tmp2, tmp);
strcat (tmp2, "Amiga Files");
static void getstartpaths(void)
{
- SHGETFOLDERPATH pSHGetFolderPath;
- SHGETSPECIALFOLDERPATH pSHGetSpecialFolderPath;
char *posn, *p;
char tmp[MAX_DPATH], tmp2[MAX_DPATH], prevpath[MAX_DPATH];
DWORD v;
if (!strcmp(prevpath, "AMIGAFOREVERDATA"))
path_type = PATH_TYPE_AMIGAFOREVERDATA;
- pSHGetFolderPath = (SHGETFOLDERPATH)GetProcAddress(
- GetModuleHandle("shell32.dll"), "SHGetFolderPathA");
- pSHGetSpecialFolderPath = (SHGETSPECIALFOLDERPATH)GetProcAddress(
- GetModuleHandle("shell32.dll"), "SHGetSpecialFolderPathA");
strcpy (start_path_exe, _pgmptr);
if((posn = strrchr (start_path_exe, '\\')))
posn[1] = 0;
}
{
- BOOL ok = FALSE;
- if (pSHGetFolderPath)
- ok = SUCCEEDED(pSHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, tmp));
- else if (pSHGetSpecialFolderPath)
- ok = pSHGetSpecialFolderPath(NULL, tmp, CSIDL_COMMON_DOCUMENTS, 0);
- if (ok) {
+ if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, tmp))) {
fixtrailing(tmp);
strcpy (tmp2, tmp);
strcat (tmp2, "Amiga Files\\");
if (i + 1 < argc) {
char *np = argv[i + 1];
+ if (!strcmp (arg, "-ddforcemode")) {
+ extern int ddforceram;
+ ddforceram = getval (np);
+ if (ddforceram < 0 || ddforceram > 3)
+ ddforceram = 0;
+ i++;
+ continue;
+ }
if (!strcmp (arg, "-affinity")) {
cpu_affinity = getval (np);
i++;
inipath = my_strdup (np);
continue;
}
+ if (!strcmp (arg, "-p96skipmode")) {
+ extern int p96skipmode;
+ i++;
+ p96skipmode = getval (np);
+ continue;
+ }
#ifdef RETROPLATFORM
if (!strcmp (arg, "-rphost")) {
i++;
#define GETBDM(x) (((x) - ((x / 10000) * 10000)) / 100)
#define GETBDD(x) ((x) % 100)
-#define WINUAEBETA 9
+#define WINUAEBETA 10
#define WINUAEPUBLICBETA 1
-#define WINUAEDATE MAKEBD(2008, 3, 18)
+#define WINUAEDATE MAKEBD(2008, 3, 23)
#define WINUAEEXTRA ""
#define WINUAEREV ""
temp_height = dst_height * 3;
if (temp_height > dxdata.maxheight)
temp_height = dxdata.maxheight;
+ if (temp_width < dst_width)
+ temp_width = dst_width;
+ if (temp_height < dst_height)
+ temp_height = dst_height;
tempsurf = allocsurface (temp_width, temp_height);
if (!tempsurf)
write_log ("DDRAW: failed to create temp surface (%dx%d)\n", temp_width, temp_height);
LinkIncremental="2"
SuppressStartupBanner="true"
GenerateManifest="false"
- DelayLoadDLLs="setupapi.dll;wpcap.dll;packet.dll"
+ DelayLoadDLLs="wpcap.dll;packet.dll"
GenerateDebugInformation="true"
ProgramDatabaseFile=".\Debug/winuae.pdb"
SubSystem="2"
+Beta 10:
+
+- MOVEM is not weird in debugger anymore
+- JIT RAM allocation failure path fixed (if Z3+RTG RAM fails to
+ allocate, lower amount of RAM automatically and try again)
+- limit internal sprite resolution to current display resolution
+ (setting in display panel), should improve performance slightly
+ in AGA modes if lots of sprites are used and display isn't shres
+- harddrive detection crash if returned STORAGE_DEVICE_DESCRIPTOR
+ was shorter than expected
+- disable hardware sprite if uaegfx.card is old version without
+ hardware sprite support and devs:monitors/info has softsprite=no
+- added -ddforceram and -ddforcevram debugging command line params
+ try -ddforceram if you have slow P96Speed results
+
Beta 9:
- crash when fullscreen enabled and error dialog was shown before
{ i_SWAP, "SWAP" },
{ i_EXG, "EXG" },
{ i_EXT, "EXT" },
- { i_MVMEL, "MVMEL" },
- { i_MVMLE, "MVMLE" },
+ { i_MVMEL, "MVMEL", "MOVEM" },
+ { i_MVMLE, "MVMLE", "MOVEM" },
{ i_TRAP, "TRAP" },
{ i_MVR2USP, "MVR2USP" },
{ i_MVUSP2R, "MVUSP2R" },
{ i_ROXLW, "ROXLW" },
{ i_ROXRW, "ROXRW" },
- { i_MOVE2C, "MOVE2C" },
- { i_MOVEC2, "MOVEC2" },
+ { i_MOVE2C, "MOVE2C", "MOVEC" },
+ { i_MOVEC2, "MOVEC2", "MOVEC" },
{ i_CAS, "CAS" },
{ i_CAS2, "CAS2" },
{ i_MULL, "MULL" },
}
return 0;
}
+#ifndef UAEGFX_INTERNAL
+extern uae_u32 picasso_demux (uae_u32 arg, TrapContext *context);
+#endif
static uae_u32 REGPARAM2 uaelib_demux2 (TrapContext *context)
{
#define ARG4 (get_long (m68k_areg (&context->regs, 7) + 20))
#define ARG5 (get_long (m68k_areg (&context->regs, 7) + 24))
+#ifndef UAEGFX_INTERNAL
+ if (ARG0 >= 16 && ARG0 <= 39)
+ return picasso_demux (ARG0, context);
+#endif
+
switch (ARG0)
{
case 0: return emulib_GetVersion ();
case 14: return emulib_GetDisk (ARG1, ARG2);
case 15: return emulib_Debug ();
-#ifdef PICASSO96
- case 16: return picasso_FindCard (&context->regs);
- case 17: return picasso_FillRect (&context->regs);
- case 18: return picasso_SetSwitch (&context->regs);
- case 19: return picasso_SetColorArray (&context->regs);
- case 20: return picasso_SetDAC (&context->regs);
- case 21: return picasso_SetGC (&context->regs);
- case 22: return picasso_SetPanning (&context->regs);
- case 23: return picasso_CalculateBytesPerRow (&context->regs);
- case 24: return picasso_BlitPlanar2Chunky (&context->regs);
- case 25: return picasso_BlitRect (&context->regs);
- case 26: return picasso_SetDisplay (&context->regs);
- case 27: return picasso_BlitTemplate (&context->regs);
- case 28: return picasso_BlitRectNoMaskComplete (&context->regs);
- case 29: return picasso_InitCard (&context->regs);
- case 30: return picasso_BlitPattern (&context->regs);
- case 31: return picasso_InvertRect (&context->regs);
- case 32: return picasso_BlitPlanar2Direct (&context->regs);
- /* case 34: return picasso_WaitVerticalSync (); handled in asm-code */
- case 35: return allocated_gfxmem ? 1 : 0;
- case 36: return picasso_SetSprite (&context->regs);
- case 37: return picasso_SetSpritePosition (&context->regs);
- case 38: return picasso_SetSpriteImage (&context->regs);
- case 39: return picasso_SetSpriteColor (&context->regs);
-#endif
case 68: return emulib_Minimize ();
case 69: return emulib_ExecuteNativeCode (&context->regs);
{
uae_u32 v;
struct regstruct *r = &context->regs;
+
if (uaelib_debug)
write_log ("%d: %08x %08x %08x %08x %08x %08x %08x %08x, %08x %08x %08x %08x %08x %08x %08x %08x\n",
ARG0,
r->regs[0],r->regs[1],r->regs[2],r->regs[3],r->regs[4],r->regs[5],r->regs[6],r->regs[7],
r->regs[8],r->regs[9],r->regs[10],r->regs[11],r->regs[12],r->regs[13],r->regs[14],r->regs[15]);
+#ifdef UAEGFX_INTERNAL
+ if (ARG0 >= 16 && ARG0 <= 39) {
+ write_log ("uaelib: obsolete Picasso96 uaelib hook called, call ignored\n");
+ return 0;
+ }
+#endif
v = uaelib_demux2 (context);
if (uaelib_debug)
write_log ("=%08x\n", v);
projects / francis / winuae.git / commitdiff