--- uae/src/picasso96.c 2018/04/24 17:03:52 1.1.1.12 +++ uae/src/picasso96.c 2018/04/24 17:18:27 1.1.1.18 @@ -33,7 +33,6 @@ #include "sysconfig.h" #include "sysdeps.h" -#include "config.h" #include "options.h" #include "threaddep/thread.h" #include "uae.h" @@ -45,8 +44,8 @@ #ifdef PICASSO96 -/*#define P96TRACING_ENABLED */ -#ifdef P96TRACING_ENABLED +#define P96TRACING_ENABLED 0 +#if P96TRACING_ENABLED #define P96TRACE(x) do { write_log x; } while(0) #else #define P96TRACE(x) @@ -92,9 +91,66 @@ static int set_panning_called = 0; SetPanning call. */ static uaecptr oldscr; +int screen_is_picasso; + static uae_u32 p2ctab[256][2]; /* + * Screen handling. + */ + +static void set_window_for_picasso (void) +{ + P96TRACE (("Function: set_window_for_picasso\n")); +#if 0 + if (current_width == picasso_vidinfo.width && current_height == picasso_vidinfo.height) + return; +#endif + + graphics_subshutdown (0); + graphics_subinit (); + + DX_SetPalette (0, 256); +} + +void gfx_set_picasso_modeinfo (int w, int h, int depth, int rgbfmt) +{ + P96TRACE (("Function: gfx_set_picasso_modeinfo w: %i h: %i depth: %i rgbfmt: %i\n", w, h, depth, rgbfmt)); + + if (screen_is_picasso + && picasso_vidinfo.width == w + && picasso_vidinfo.height == h) + return; + + picasso_vidinfo.width = w; + picasso_vidinfo.height = h; + picasso_vidinfo.depth = depth; + if (screen_is_picasso) + set_window_for_picasso (); +} + +void gfx_set_picasso_baseaddr (uaecptr a) +{ +} + +void gfx_set_picasso_state (int on) +{ + P96TRACE (("Function: gfx_set_picasso_state: %d\n", on)); + + if (on == screen_is_picasso) + return; + + graphics_subshutdown (0); + screen_is_picasso = on; + graphics_subinit (); + + if (on) + DX_SetPalette (0, 256); + else + reset_drawing (); +} + +/* * Debugging dumps */ @@ -333,8 +389,13 @@ static void CopyLibResolutionStructureU2 char *uaememptr = 0; int i; - uaememptr = gfxmem_xlate (amigamemptr); /* I know that amigamemptr is inside my gfxmem chunk, so I can just do the xlate() */ - memset (uaememptr, 0, PSSO_LibResolution_sizeof); /* zero out our LibResolution structure */ + /* I know that amigamemptr is inside my gfxmem chunk, so I can just + * do the xlate() */ + uaememptr = gfxmem_xlate (amigamemptr); + + /* zero out our LibResolution structure */ + memset (uaememptr, 0, PSSO_LibResolution_sizeof); + strcpy (uaememptr + PSSO_LibResolution_P96ID, libres->P96ID); put_long (amigamemptr + PSSO_LibResolution_DisplayID, libres->DisplayID); put_word (amigamemptr + PSSO_LibResolution_Width, libres->Width); @@ -390,7 +451,6 @@ static void AmigaListAddTail (uaecptr li * filled rectangle in the frame buffer; it can be used as a memcpy source if * there is no OS specific function to fill the rectangle. */ - static void do_fillrect (uae_u8 * src, int x, int y, int width, int height, uae_u32 pen, int Bpp, RGBFTYPE rgbtype) { @@ -412,6 +472,9 @@ static void do_fillrect (uae_u8 * src, i if (y + height > picasso96_state.Height) height = picasso96_state.Height - y; + if (width <= 0 || height <= 0) + return; + /* Try OS specific fillrect function here; and return if successful. */ DX_Invalidate (y, y + height - 1); @@ -501,6 +564,8 @@ static void do_blit (struct RenderInfo * width = picasso96_state.Width - dstx; if (dsty + height > picasso96_state.Height) height = picasso96_state.Height - dsty; + if (width <= 0 || height <= 0) + return; /* If this RenderInfo points at something else than the currently visible * screen, we must ignore the blit. */ @@ -521,6 +586,9 @@ static void do_blit (struct RenderInfo * if (dstp == 0) goto out; dstp += dsty * picasso_vidinfo.rowbytes + dstx * picasso_vidinfo.pixbytes; + P96TRACE(("do_blit with srcp 0x%x, dstp 0x%x, dst_rowbytes %d, srcx %d, srcy %d, dstx %d, dsty %d, w %d, h %d, dst_pixbytes %d\n", + srcp, dstp, picasso_vidinfo.rowbytes, srcx, srcy, dstx, dsty, width, height, picasso_vidinfo.pixbytes)); + P96TRACE(("gfxmem is at 0x%x\n",gfxmemory)); srcp = ri->Memory + srcx * Bpp + srcy * ri->BytesPerRow; if (picasso_vidinfo.rgbformat == picasso96_state.RGBFormat) { @@ -579,6 +647,10 @@ static void do_invertrect (struct Render width = picasso96_state.Width - x; if (y + height > picasso96_state.Height) height = picasso96_state.Height - y; + + if (width <= 0 || height <= 0) + return; + #endif /* TODO: Try OS specific invertrect function here; and return if successful. */ @@ -600,11 +672,11 @@ static void wgfx_do_flushline (void) wgfx_y -= picasso96_state.YOffset; if (wgfx_y < 0 || wgfx_y >= picasso96_state.Height) - goto out; + goto out1; DX_Invalidate (wgfx_y, wgfx_y); if (!picasso_vidinfo.extra_mem) - goto out; + goto out1; x0 = wgfx_min - wgfx_linestart; width = wgfx_max - wgfx_min; @@ -621,7 +693,7 @@ static void wgfx_do_flushline (void) if (dstp == 0) goto out; - /*printf("flushing %d (%x %x %x)\n", wgfx_y, wgfx_linestart, wgfx_min, wgfx_max); */ + // P96TRACE(("flushing %d\n", wgfx_y)); src = gfxmemory + wgfx_min; if (picasso_vidinfo.rgbformat == picasso96_state.RGBFormat) { @@ -650,6 +722,7 @@ static void wgfx_do_flushline (void) out: gfx_unlock_picasso (); + out1: wgfx_linestart = 0xFFFFFFFF; } @@ -692,7 +765,7 @@ void picasso_refresh (void) ri.BytesPerRow = picasso96_state.BytesPerRow; ri.RGBFormat = picasso96_state.RGBFormat; - if (set_panning_called) { + if (set_panning_called) { width = picasso96_state.VirtualWidth; height = picasso96_state.VirtualHeight; } else { @@ -907,7 +980,7 @@ uae_u32 picasso_SetSwitch (void) * desired state, and wait for custom.c to call picasso_enablescreen * whenever it is ready to change the screen state. */ picasso_requested_on = !!flag; -#if 0 +#if 1 write_log ("SetSwitch() - trying to show %s screen\n", flag ? "picasso96" : "amiga"); #endif /* Put old switch-state in D0 */ @@ -918,7 +991,7 @@ void picasso_enablescreen (int on) { wgfx_linestart = 0xFFFFFFFF; picasso_refresh (); -#if 0 +#if 1 write_log ("SetSwitch() - showing %s screen\n", on ? "picasso96" : "amiga"); #endif } @@ -1065,7 +1138,7 @@ uae_u32 picasso_SetGC (void) picasso96_state.GC_Depth = get_byte (modeinfo + PSSO_ModeInfo_Depth); picasso96_state.GC_Flags = get_byte (modeinfo + PSSO_ModeInfo_Flags); - write_log ("SetGC(%d,%d,%d)\n", picasso96_state.Width, picasso96_state.Height, picasso96_state.GC_Depth); + P96TRACE (("SetGC(%d,%d,%d)\n", picasso96_state.Width, picasso96_state.Height, picasso96_state.GC_Depth)); set_gc_called = 1; /* @@@ when do we need to reset this? */ init_picasso_screen (); @@ -1123,14 +1196,11 @@ uae_u32 picasso_SetPanning (void) picasso96_state.BytesPerRow = Width * picasso96_state.BytesPerPixel; set_panning_called = 1; - write_log ("SetPanning(%d, %d, %d) Start 0x%x, BPR %d\n", - Width, picasso96_state.XOffset, picasso96_state.YOffset, start_of_screen, picasso96_state.BytesPerRow); + P96TRACE (("SetPanning(%d, %d, %d) Start 0x%x, BPR %d\n", + Width, picasso96_state.XOffset, picasso96_state.YOffset, start_of_screen, picasso96_state.BytesPerRow)); init_picasso_screen (); - lastmx += oldxoff - picasso96_state.XOffset; - lastmy += oldyoff - picasso96_state.YOffset; - return 1; } @@ -1166,7 +1236,7 @@ static void do_xor8 (uae_u8 * ptr, long /* * InvertRect: - * + * * Inputs: * a0:struct BoardInfo *bi * a1:struct RenderInfo *ri @@ -1176,7 +1246,7 @@ static void do_xor8 (uae_u8 * ptr, long * d3.w:Height * d4.l:Mask * d7.l:RGBFormat - * + * * This function is used to invert a rectangular area on the board. It is called by BltBitMap, * BltPattern and BltTemplate. */ @@ -1200,6 +1270,7 @@ uae_u32 picasso_InvertRect (void) if (!CopyRenderInfoStructureA2U (renderinfo, &ri)) return 0; + P96TRACE (("InvertRect: X %d Y %d Width %d Height %d\n", X, Y, Width, Height)); /*write_log ("InvertRect %d %lx\n", Bpp, (long)mask); */ /* ??? Brian? mask used to be 32 bit, but it appears that only 8 bit @@ -1311,6 +1382,9 @@ uae_u32 picasso_FillRect (void) if (!CopyRenderInfoStructureA2U (renderinfo, &ri) || Y == 0xFFFF) return 0; + P96TRACE(("FillRect(%d, %d, %d, %d) Pen 0x%x BPP %d BPR %d Mask 0x%x\n", + X, Y, Width, Height, Pen, Bpp, ri.BytesPerRow, Mask)); + if (ri.RGBFormat != RGBFormat) write_log ("Weird Stuff!\n"); @@ -1473,6 +1547,7 @@ uae_u32 picasso_BlitRect (void) if (!CopyRenderInfoStructureA2U (renderinfo, &ri)) return 0; + P96TRACE(("BlitRect(%d, %d, %d, %d, %d, %d, 0x%x)\n", srcx, srcy, dstx, dsty, width, height, Mask)); BlitRect (&ri, NULL, srcx, srcy, dstx, dsty, width, height, Mask, BLIT_SRC); /*write_log ("BlitRect(%d, %d, %d, %d, %d, %d, 0x%x)\n", srcx, srcy, dstx, dsty, width, height, Mask); */ @@ -1517,10 +1592,8 @@ uae_u32 picasso_BlitRectNoMaskComplete ( || !CopyRenderInfoStructureA2U (dstri, &dst_ri)) return 0; - /*write_log ("BlitRectNoMaskComplete() op 0x%2x, Bpp %d, xy(%4d,%4d) --> xy(%4d,%4d), wh(%4d,%4d)\n", - OpCode, Bpp, srcx, srcy, dstx, dsty, width, height); */ - /*write_log ("-- src mem 0x%x BPR %d, dst mem 0x%x BPR %d, screen-mem 0x%x - 0x%x\n", - src_ri.Memory, src_ri.BytesPerRow, dst_ri.Memory, dst_ri.BytesPerRow, picasso96_state.Address, picasso96_state.Extent); */ + P96TRACE(("BlitRectNoMaskComplete() op 0x%2x, xy(%4d,%4d) --> xy(%4d,%4d), wh(%4d,%4d)\n", + OpCode, srcx, srcy, dstx, dsty, width, height)); switch (OpCode) { case 0x0C: @@ -1580,7 +1653,7 @@ STATIC_INLINE void PixelWrite (uae_u8 * /* * BlitPattern: - * + * * Synopsis:BlitPattern(bi, ri, pattern, X, Y, Width, Height, Mask, RGBFormat); * Inputs: * a0:struct BoardInfo *bi @@ -1592,7 +1665,7 @@ STATIC_INLINE void PixelWrite (uae_u8 * * d3.w:Height * d4.w:Mask * d7.l:RGBFormat - * + * * This function is used to paint a pattern on the board memory using the blitter. It is called by * BltPattern, if a AreaPtrn is used with positive AreaPtSz. The pattern consists of a b/w image * using a single plane of image data which will be expanded repeatedly to the destination RGBFormat @@ -1643,8 +1716,8 @@ uae_u32 picasso_BlitPattern (void) } } - /* write_log ("BlitPattern() xy(%d,%d), wh(%d,%d) draw 0x%x, off(%d,%d), ph %d\n", - X, Y, W, H, pattern.DrawMode, pattern.XOffset, pattern.YOffset, 1 << pattern.Size); */ + P96TRACE (("BlitPattern() xy(%d,%d), wh(%d,%d) draw 0x%x, off(%d,%d), ph %d\n", + X, Y, W, H, pattern.DrawMode, pattern.XOffset, pattern.YOffset, 1 << pattern.Size)); #ifdef _DEBUG DumpPattern (&pattern); #endif @@ -1788,8 +1861,8 @@ uae_u32 picasso_BlitTemplate (void) } } - /*write_log ("BlitTemplate() xy(%d,%d), wh(%d,%d) draw 0x%x fg 0x%x bg 0x%x \n", - X, Y, W, H, tmp.DrawMode, tmp.FgPen, tmp.BgPen); */ + P96TRACE (("BlitTemplate() xy(%d,%d), wh(%d,%d) draw 0x%x fg 0x%x bg 0x%x \n", + X, Y, W, H, tmp.DrawMode, tmp.FgPen, tmp.BgPen)); bitoffset = tmp.XOffset % 8; @@ -1896,7 +1969,7 @@ uae_u32 picasso_CalculateBytesPerRow (vo uae_u32 type = m68k_dreg (regs, 7); width = GetBytesPerPixel (type) * width; - /*write_log ("CalculateBytesPerRow() = %d\n",width); */ + P96TRACE (("CalculateBytesPerRow() = %d\n", width)); return width; } @@ -1906,13 +1979,13 @@ uae_u32 picasso_CalculateBytesPerRow (vo * a0: struct BoardInfo * d0: BOOL state * This function enables and disables the video display. - * + * * NOTE: return the opposite of the state */ uae_u32 picasso_SetDisplay (void) { uae_u32 state = m68k_dreg (regs, 0); - write_log ("SetDisplay(%d)\n", state); + P96TRACE (("SetDisplay(%d)\n", state)); return !state; } @@ -1939,7 +2012,7 @@ static void PlanarToChunky (struct Rende unsigned long rows, bitoffset = srcx & 7; long eol_offset; - /* if (mask != 0xFF) + /* if (mask != 0xFF) write_log ("P2C - pixel-width = %d, bit-offset = %d\n", width, bitoffset); */ /* Set up our bm->Planes[] pointers to the right horizontal offset */ @@ -2038,9 +2111,9 @@ uae_u32 picasso_BlitPlanar2Chunky (void) || !CopyBitMapStructureA2U (bm, &local_bm)) return 0; - /*write_log ("BlitPlanar2Chunky(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n", - srcx, srcy, dstx, dsty, width, height, minterm, mask, local_bm.Depth); - write_log ("P2C - BitMap has %d BPR, %d rows\n", local_bm.BytesPerRow, local_bm.Rows); */ + P96TRACE (("BlitPlanar2Chunky(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n", + srcx, srcy, dstx, dsty, width, height, minterm, mask, local_bm.Depth)); + P96TRACE (("P2C - BitMap has %d BPR, %d rows\n", local_bm.BytesPerRow, local_bm.Rows)); PlanarToChunky (&local_ri, &local_bm, srcx, srcy, dstx, dsty, width, height, mask); if (renderinfo_is_current_screen (&local_ri)) do_blit (&local_ri, GetBytesPerPixel (local_ri.RGBFormat), dstx, dsty, dstx, dsty, width, height, BLIT_SRC, 0); @@ -2124,8 +2197,8 @@ static void PlanarToDirect (struct Rende } /* - * BlitPlanar2Direct: - * + * BlitPlanar2Direct: + * * Synopsis: * BlitPlanar2Direct(bi, bm, ri, cim, SrcX, SrcY, DstX, DstY, SizeX, SizeY, MinTerm, Mask); * Inputs: @@ -2141,14 +2214,14 @@ static void PlanarToDirect (struct Rende * d5.w:SizeY * d6.b:MinTerm * d7.b:Mask - * + * * This function is currently used to blit from planar bitmaps within system memory to direct color * bitmaps (15, 16, 24 or 32 bit) 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"). The ColorIndexMapping is * used to map the color index of each pixel formed by the bits in the bitmap's planes to a direct color value * which is written to the destination RenderInfo. The color mask and all colors within the mapping are words, * triple bytes or longwords respectively similar to the color values used in FillRect(), BlitPattern() or - * BlitTemplate(). + * BlitTemplate(). */ uae_u32 picasso_BlitPlanar2Direct (void) { @@ -2182,8 +2255,8 @@ uae_u32 picasso_BlitPlanar2Direct (void) return 0; CopyColorIndexMappingA2U (cim, &local_cim); - /* write_log ("BlitPlanar2Direct(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n", - srcx, srcy, dstx, dsty, width, height, minterm, Mask, local_bm.Depth); */ + P96TRACE (("BlitPlanar2Direct(%d, %d, %d, %d, %d, %d) Minterm 0x%x, Mask 0x%x, Depth %d\n", + srcx, srcy, dstx, dsty, width, height, minterm, Mask, local_bm.Depth)); PlanarToDirect (&local_ri, &local_bm, srcx, srcy, dstx, dsty, width, height, Mask, &local_cim); if (renderinfo_is_current_screen (&local_ri)) do_blit (&local_ri, GetBytesPerPixel (local_ri.RGBFormat), dstx, dsty, dstx, dsty, width, height, BLIT_SRC, 0); @@ -2319,7 +2392,7 @@ static void write_gfx_byte (uaecptr addr static uae_u32 REGPARAM2 gfxmem_lget (uaecptr addr) { uae_u32 *m; - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; m = (uae_u32 *) (gfxmemory + addr); return do_get_mem_long (m); @@ -2328,7 +2401,7 @@ static uae_u32 REGPARAM2 gfxmem_lget (ua static uae_u32 REGPARAM2 gfxmem_wget (uaecptr addr) { uae_u16 *m; - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; m = (uae_u16 *) (gfxmemory + addr); return do_get_mem_word (m); @@ -2336,7 +2409,7 @@ static uae_u32 REGPARAM2 gfxmem_wget (ua static uae_u32 REGPARAM2 gfxmem_bget (uaecptr addr) { - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; return gfxmemory[addr]; } @@ -2344,7 +2417,7 @@ static uae_u32 REGPARAM2 gfxmem_bget (ua static void REGPARAM2 gfxmem_lput (uaecptr addr, uae_u32 l) { uae_u32 *m; - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; m = (uae_u32 *) (gfxmemory + addr); do_put_mem_long (m, l); @@ -2356,7 +2429,7 @@ static void REGPARAM2 gfxmem_lput (uaecp static void REGPARAM2 gfxmem_wput (uaecptr addr, uae_u32 w) { uae_u16 *m; - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; m = (uae_u16 *) (gfxmemory + addr); do_put_mem_word (m, (uae_u16) w); @@ -2367,7 +2440,7 @@ static void REGPARAM2 gfxmem_wput (uaecp static void REGPARAM2 gfxmem_bput (uaecptr addr, uae_u32 b) { - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; gfxmemory[addr] = b; @@ -2377,14 +2450,14 @@ static void REGPARAM2 gfxmem_bput (uaecp static int REGPARAM2 gfxmem_check (uaecptr addr, uae_u32 size) { - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; return (addr + size) < allocated_gfxmem; } static uae_u8 REGPARAM2 *gfxmem_xlate (uaecptr addr) { - addr -= gfxmem_start & gfxmem_mask; + addr -= gfxmem_start; addr &= gfxmem_mask; return gfxmemory + addr; } @@ -2399,13 +2472,13 @@ int picasso_display_mode_index (uae_u32 { int i; for (i = 0; i < mode_count; i++) { - if (DisplayModes[i].res.width == x + if (DisplayModes[i].res.width == x && DisplayModes[i].res.height == y && DisplayModes[i].depth == d) - break; + break; } if (i == mode_count) - i = -1; + i = -1; return i; }