--- uae/src/picasso96.c 2018/04/24 17:07:21 1.1.1.14 +++ 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) { @@ -527,7 +587,7 @@ static void do_blit (struct RenderInfo * 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)); + 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; @@ -633,7 +693,7 @@ static void wgfx_do_flushline (void) if (dstp == 0) goto out; - P96TRACE(("flushing %d\n", wgfx_y)); + // P96TRACE(("flushing %d\n", wgfx_y)); src = gfxmemory + wgfx_min; if (picasso_vidinfo.rgbformat == picasso96_state.RGBFormat) { @@ -705,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 { @@ -920,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 */ @@ -931,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 } @@ -1141,9 +1201,6 @@ uae_u32 picasso_SetPanning (void) init_picasso_screen (); - lastmx += oldxoff - picasso96_state.XOffset; - lastmy += oldyoff - picasso96_state.YOffset; - return 1; } @@ -1179,7 +1236,7 @@ static void do_xor8 (uae_u8 * ptr, long /* * InvertRect: - * + * * Inputs: * a0:struct BoardInfo *bi * a1:struct RenderInfo *ri @@ -1189,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. */ @@ -1596,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 @@ -1608,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 @@ -1912,7 +1969,7 @@ uae_u32 picasso_CalculateBytesPerRow (vo uae_u32 type = m68k_dreg (regs, 7); width = GetBytesPerPixel (type) * width; - P96TRACE (("CalculateBytesPerRow() = %d\n", width)); + P96TRACE (("CalculateBytesPerRow() = %d\n", width)); return width; } @@ -1922,7 +1979,7 @@ 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) @@ -1955,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 */ @@ -2140,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: @@ -2157,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) { @@ -2335,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); @@ -2344,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); @@ -2352,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]; } @@ -2360,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); @@ -2372,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); @@ -2383,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; @@ -2393,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; } @@ -2415,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; }