/* AppleWin : An Apple //e emulator for Windows Copyright (C) 1994-1996, Michael O'Brien Copyright (C) 1999-2001, Oliver Schmidt Copyright (C) 2002-2005, Tom Charlesworth Copyright (C) 2006-2010, Tom Charlesworth, Michael Pohoreski, Nick Westgate AppleWin is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. AppleWin is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with AppleWin; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* Description: Emulation of video modes * * Author: Various */ #include "StdAfx.h" #include "AppleWin.h" #include "CPU.h" #include "Frame.h" #include "Keyboard.h" #include "Memory.h" #include "Registry.h" #include "Video.h" #include "..\resource\resource.h" #include "Configuration\PropertySheet.h" #include "Debugger\Debugger_Color.h" // For NUM_DEBUG_COLORS #define HALF_PIXEL_SOLID 1 #define HALF_PIXEL_BLEED 0 #define COLORS_TWEAKED 1 /* reference: technote tn-iigs-063 "Master Color Values" Color Color Register LR HR DHR Master Color R,G,B Name Value # # # Value ---------------------------------------------------- Black 0 0 0,4 0 $0000 (0,0,0) -> (00,00,00) Windows (Magenta) Deep Red 1 1 1 $0D03 (D,0,3) -> (D0,00,30) Custom Dark Blue 2 2 8 $0009 (0,0,9) -> (00,00,80) Windows (Violet) Purple 3 3 2 9 $0D2D (D,2,D) -> (FF,00,FF) Windows Dark Green 4 4 4 $0072 (0,7,2) -> (00,80,00) Windows (Gray 1) Dark Gray 5 5 5 $0555 (5,5,5) -> (80,80,80) Windows (Blue) Medium Blue 6 6 6 C $022F (2,2,F) -> (00,00,FF) Windows (Cyan) Light Blue 7 7 D $06AF (6,A,F) -> (60,A0,FF) Custom Brown 8 8 2 $0850 (8,5,0) -> (80,50,00) Custom Orange 9 9 5 3 $0F60 (F,6,0) -> (FF,80,00) Custom (modified to match better with the other Hi-Res Colors) (Gray 2) Light Gray A A A $0AAA (A,A,A) -> (C0,C0,C0) Windows Pink B B B $0F98 (F,9,8) -> (FF,90,80) Custom (Green) Light Green C C 1 6 $01D0 (1,D,0) -> (00,FF,00) Windows Yellow D D 7 $0FF0 (F,F,0) -> (FF,FF,00) Windows (Aqua) Aquamarine E E E $04F9 (4,F,9) -> (40,FF,90) Custom White F F 3,7 F $0FFF (F,F,F) -> (FF,FF,FF) Windows LR: Lo-Res HR: Hi-Res DHR: Double Hi-Res */ #define FLASH_80_COL 1 // Bug #7238 #define HALF_SHIFT_DITHER 0 enum Color_Palette_Index_e { // The first 10 are the DEFAULT Windows colors (as it reserves 20 colors) BLACK = 0x00 // 0x00,0x00,0x00 , DARK_RED = 0x01 // 0x80,0x00,0x00 , DARK_GREEN = 0x02 // 0x00,0x80,0x00 (Half Green) , DARK_YELLOW = 0x03 // 0x80,0x80,0x00 , DARK_BLUE = 0x04 // 0x00,0x00,0x80 (Half Blue) , DARK_MAGENTA = 0x05 // 0x80,0x00,0x80 , DARK_CYAN = 0x06 // 0x00,0x80,0x80 , LIGHT_GRAY = 0x07 // 0xC0,0xC0,0xC0 , MONEY_GREEN = 0x08 // 0xC0,0xDC,0xC0 // not used , SKY_BLUE = 0x09 // 0xA6,0xCA,0xF0 // not used // Really need to have Quarter Green and Quarter Blue for Hi-Res // OUR CUSTOM COLORS -- the extra colors HGR mode can display // , DEEP_BLUE // Breaks TV Emulation Reference Test !?!? // Breaks the dam palette -- black monochrome TEXT output bug *sigh* , DEEP_RED , LIGHT_BLUE , BROWN , ORANGE , PINK , AQUA // CUSTOM HGR COLORS (don't change order) - For tv emulation HGR Video Mode , HGR_BLACK , HGR_WHITE , HGR_BLUE // HCOLOR=6 BLUE , $81 , HGR_RED // HCOLOR=5 ORANGE , $82 , HGR_GREEN // HCOLOR=1 GREEN , $01 , HGR_MAGENTA // HCOLOR=2 MAGENTA, $02 , HGR_GREY1 , HGR_GREY2 , HGR_YELLOW , HGR_AQUA , HGR_PURPLE , HGR_PINK // MONOCHROME // NOTE: 50% is assumed to come after 100% luminance !!! See: V_CreateLookup_MonoHiRes() // User customizable , MONOCHROME_CUSTOM // 100% luminance , MONOCHROME_CUSTOM_50 // 50% luminance // Pre-set "Monochromes" , MONOCHROME_AMBER // , MONOCHROME_AMBER_50 // BUG - something trashing our palette entry !!! , MONOCHROME_GREEN // , MONOCHROME_GREEN_50 // BUG - something trashing our palette entry !!! , DEBUG_COLORS_START , DEBUG_COLORS_END = DEBUG_COLORS_START + NUM_DEBUG_COLORS // DD Full Screen Palette ?!?! // , LOGO_COLORS_START // , LOGO_COLORS_END = LOGO_COLORS_START + 128 , NUM_COLOR_PALETTE // The last 10 are the DEFAULT Windows colors (as it reserves 20 colors) , CREAM = 0xF6 , MEDIUM_GRAY = 0xF7 , DARK_GRAY = 0xF8 , RED = 0xF9 , GREEN = 0xFA , YELLOW = 0xFB , BLUE = 0xFC , MAGENTA = 0xFD , CYAN = 0xFE , WHITE = 0xFF }; // __ Map HGR color index to Palette index enum ColorMapping { CM_Magenta , CM_Blue , CM_Green , CM_Orange , CM_Black , CM_White , NUM_COLOR_MAPPING }; const BYTE HiresToPalIndex[ NUM_COLOR_MAPPING ] = { HGR_MAGENTA , HGR_BLUE , HGR_GREEN , HGR_RED , HGR_BLACK , HGR_WHITE }; const BYTE LoresResColors[16] = { // BLACK, DEEP_RED, DARK_BLUE, MAGENTA, // DARK_GREEN,DARK_GRAY,BLUE, LIGHT_BLUE, // BROWN, ORANGE, LIGHT_GRAY,PINK, // GREEN, YELLOW, AQUA, WHITE BLACK, DEEP_RED, DARK_BLUE, MAGENTA, DARK_GREEN,DARK_GRAY,BLUE, LIGHT_BLUE, BROWN, ORANGE, LIGHT_GRAY,PINK, GREEN, YELLOW, AQUA, HGR_WHITE }; const BYTE DoubleHiresPalIndex[16] = { // BLACK, DARK_BLUE, DARK_GREEN,BLUE, // BROWN, LIGHT_GRAY,GREEN, AQUA, // DEEP_RED,MAGENTA, DARK_GRAY, LIGHT_BLUE, // ORANGE, PINK, YELLOW, WHITE BLACK, DARK_BLUE, DARK_GREEN,BLUE, BROWN, LIGHT_GRAY, GREEN, AQUA, DEEP_RED,MAGENTA, DARK_GRAY, LIGHT_BLUE, ORANGE, PINK, YELLOW, HGR_WHITE }; const int SRCOFFS_40COL = 0; // 0 const int SRCOFFS_IIPLUS = (SRCOFFS_40COL + 256); // 256 const int SRCOFFS_80COL = (SRCOFFS_IIPLUS + 256); // 512 const int SRCOFFS_LORES = (SRCOFFS_80COL + 128); // 640 const int SRCOFFS_HIRES = (SRCOFFS_LORES + 16); // 656 const int SRCOFFS_DHIRES = (SRCOFFS_HIRES + 512); // 1168 const int SRCOFFS_TOTAL = (SRCOFFS_DHIRES + 2560); // 3278 #define SW_80COL (g_bVideoMode & VF_80COL) #define SW_DHIRES (g_bVideoMode & VF_DHIRES) #define SW_HIRES (g_bVideoMode & VF_HIRES) #define SW_MASK2 (g_bVideoMode & VF_MASK2) #define SW_MIXED (g_bVideoMode & VF_MIXED) #define SW_PAGE2 (g_bVideoMode & VF_PAGE2) #define SW_TEXT (g_bVideoMode & VF_TEXT) #define SETSOURCEPIXEL(x,y,c) g_aSourceStartofLine[(y)][(x)] = (c) #define SETFRAMECOLOR(i,r,g,b) g_pFramebufferinfo->bmiColors[i].rgbRed = r; \ g_pFramebufferinfo->bmiColors[i].rgbGreen = g; \ g_pFramebufferinfo->bmiColors[i].rgbBlue = b; \ g_pFramebufferinfo->bmiColors[i].rgbReserved = PC_NOCOLLAPSE; #define HGR_MATRIX_YOFFSET 2 // For tv emulation HGR Video Mode // video scanner constants int const kHBurstClock = 53; // clock when Color Burst starts int const kHBurstClocks = 4; // clocks per Color Burst duration int const kHClock0State = 0x18; // H[543210] = 011000 int const kHClocks = 65; // clocks per horizontal scan (including HBL) int const kHPEClock = 40; // clock when HPE (horizontal preset enable) goes low int const kHPresetClock = 41; // clock when H state presets int const kHSyncClock = 49; // clock when HSync starts int const kHSyncClocks = 4; // clocks per HSync duration int const kNTSCScanLines = 262; // total scan lines including VBL (NTSC) int const kNTSCVSyncLine = 224; // line when VSync starts (NTSC) int const kPALScanLines = 312; // total scan lines including VBL (PAL) int const kPALVSyncLine = 264; // line when VSync starts (PAL) int const kVLine0State = 0x100; // V[543210CBA] = 100000000 int const kVPresetLine = 256; // line when V state presets int const kVSyncLines = 4; // lines per VSync duration static BYTE celldirty[40][32]; // [TC: 27/06/2014] NB. No longer used! // NUM_COLOR_PALETTE static COLORREF customcolors[256]; // MONOCHROME is last custom color static HBITMAP g_hDeviceBitmap; static HDC g_hDeviceDC; LPBYTE g_pFramebufferbits = NULL; // last drawn frame static LPBITMAPINFO g_pFramebufferinfo = NULL; static LPBYTE g_aFrameBufferOffset[FRAMEBUFFER_H]; // array of pointers to start of each scanline static LPBYTE g_pHiresBank1; static LPBYTE g_pHiresBank0; HBITMAP g_hLogoBitmap; static HPALETTE g_hPalette; static HBITMAP g_hSourceBitmap; static LPBYTE g_pSourcePixels; static LPBITMAPINFO g_pSourceHeader; const int MAX_SOURCE_Y = 512; static LPBYTE g_aSourceStartofLine[ MAX_SOURCE_Y ]; static LPBYTE g_pTextBank1; // Aux static LPBYTE g_pTextBank0; // Main // For tv emulation HGR Video Mode // 2 extra scan lines on bottom? static BYTE hgrpixelmatrix[FRAMEBUFFER_W/2][FRAMEBUFFER_H/2 + 2 * HGR_MATRIX_YOFFSET]; static BYTE colormixbuffer[6]; static WORD colormixmap[6][6][6]; // int g_nAltCharSetOffset = 0; // alternate character set bool g_bVideoDisplayPage2 = 0; /*bool*/ UINT g_VideoForceFullRedraw = 1; static LPBYTE framebufferaddr = (LPBYTE)0; static LONG g_nFrameBufferPitch = 0; BOOL g_bGraphicsMode = 0; static BOOL hasrefreshed = 0; static DWORD lastpageflip = 0; COLORREF monochrome = RGB(0xC0,0xC0,0xC0); static BOOL rebuiltsource = 0; static LPBYTE vidlastmem = NULL; int g_bVideoMode = VF_TEXT; DWORD g_eVideoType = VT_COLOR_TVEMU; DWORD g_uHalfScanLines = true; // drop 50% scan lines for a more authentic look static bool g_bTextFlashState = false; static bool g_bTextFlashFlag = false; static bool bVideoScannerNTSC = true; // NTSC video scanning (or PAL) //------------------------------------- // Video consts: const UINT nVBlStop_NTSC = 21; const UINT nVBlStop_PAL = 29; // NOTE: KEEP IN SYNC: VideoType_e g_aVideoChoices g_apVideoModeDesc TCHAR g_aVideoChoices[] = TEXT("Monochrome (Custom Luminance)\0") TEXT("Color (Standard)\0") TEXT("Color (Text Optimized)\0") TEXT("Color (TV emulation)\0") TEXT("Monochrome (Amber)\0") TEXT("Monochrome (Green)\0") TEXT("Monochrome (White)\0") ; // AppleWin 1.19.4 VT_COLOR_AUTHENTIC -> VT_COLOR_HALFPIXEL -> VT_COLOR_STANDARD "Color Half-Pixel Authentic // NOTE: KEEP IN SYNC: VideoType_e g_aVideoChoices g_apVideoModeDesc // The window title will be set to this. char *g_apVideoModeDesc[ NUM_VIDEO_MODES ] = { "Monochrome (Custom)" , "Standard" , "Text Optimized" , "TV" , "Amber" , "Green" , "White" }; // Prototypes (Private) _____________________________________________ void V_CreateLookup_DoubleHires (); void V_CreateLookup_Hires (); // Old "Full-Pixel" support only: STANDARD, TEXT_OPTIMIZED, TVEMU void V_CreateLookup_HiResHalfPixel_Authentic (); // New "Half_Pixel" support: STANDARD, TEXT_OPTIMIZED void V_CreateLookup_HiresHalfShiftFull (); void V_CreateLookup_Lores (); void V_CreateLookup_Text (HDC dc); // Monochrome Full-Pixel Support void V_CreateLookup_MonoDoubleHiRes (); void V_CreateLookup_MonoHiRes (); void V_CreateLookup_MonoLoRes (); void V_CreateLookup_MonoText (HDC dc); // Monochrome Half-Pixel Support void V_CreateLookup_MonoHiResHalfPixel_Real (); bool g_bDisplayPrintScreenFileName = false; bool g_bShowPrintScreenWarningDialog = true; void Util_MakeScreenShotFileName( char *pFinalFileName_ ); bool Util_TestScreenShotFileName( const char *pFileName ); // true = 280x192 // false = 560x384 void Video_SaveScreenShot( const char *pScreenShotFileName ); void Video_MakeScreenShot( FILE *pFile ); int GetMonochromeIndex(); void V_CreateIdentityPalette (); void V_CreateDIBSections (); HBRUSH V_CreateCustomBrush (COLORREF nColor); /** Our BitBlit() / VRAM_Copy() @param dx Dst X @param dy Dst Y @param w Width (same for src & dst) @param h Height (same for src & dst) @param sx Src X @param sy Src Y // =========================================================================== */ static inline void CopySource8(int dx, int dy, int w, int h, int sx, int sy) { LPBYTE pDst = g_aFrameBufferOffset[ dy ] + dx; LPBYTE pSrc = g_aSourceStartofLine[ sy ] + sx; int nBytes; while (h--) { nBytes = w; // If not multiple of 3 bytes, copy first 3 bytes, so the next copy is 4-byte aligned. while (nBytes & 3) { --nBytes; if (g_uHalfScanLines && !(h & 1)) *(pDst+nBytes) = 0; // 50% Half Scan Line clears every odd scanline (and SHIFT+PrintScreen saves only the even rows) else *(pDst+nBytes) = *(pSrc+nBytes); } // Copy 4 bytes at a time while (nBytes) { nBytes -= 4; if (g_uHalfScanLines && !(h & 1)) *(LPDWORD)(pDst+nBytes) = 0; // 50% Half Scan Line clears every odd scanline (and SHIFT+PrintScreen saves only the even rows) else *(LPDWORD)(pDst+nBytes) = *(LPDWORD)(pSrc+nBytes); } pDst -= g_nFrameBufferPitch; pSrc -= SRCOFFS_TOTAL; } } static void CopySource(int dx, int dy, int w, int h, int sx, int sy) { if (!g_bIsFullScreen || !GetFullScreen32Bit()) { CopySource8(dx,dy,w,h,sx,sy); return; } UINT32* pDst = (UINT32*) (g_aFrameBufferOffset[ dy ] + dx*sizeof(UINT32)); LPBYTE pSrc = g_aSourceStartofLine[ sy ] + sx; int nBytes; while (h--) { nBytes = w; while (nBytes) { --nBytes; if (g_uHalfScanLines && !(h & 1)) { // 50% Half Scan Line clears every odd scanline (and SHIFT+PrintScreen saves only the even rows) *(pDst+nBytes) = 0; } else { const RGBQUAD& rRGB = g_pFramebufferinfo->bmiColors[ *(pSrc+nBytes) ]; const UINT32 rgb = (((UINT32)rRGB.rgbRed)<<16) | (((UINT32)rRGB.rgbGreen)<<8) | ((UINT32)rRGB.rgbBlue); *(pDst+nBytes) = rgb; } } pDst -= g_nFrameBufferPitch / sizeof(UINT32); pSrc -= SRCOFFS_TOTAL; } } //=========================================================================== void CreateFrameOffsetTable (LPBYTE addr, LONG pitch) { if ((framebufferaddr == addr) && (g_nFrameBufferPitch == pitch)) return; framebufferaddr = addr; g_nFrameBufferPitch = pitch; // CREATE THE OFFSET TABLE FOR EACH SCAN LINE IN THE FRAME BUFFER for (int y = 0; y < FRAMEBUFFER_H; y++) g_aFrameBufferOffset[y] = framebufferaddr + g_nFrameBufferPitch*((FRAMEBUFFER_H-1)-y); } //=========================================================================== void VideoInitialize () { // CREATE A BUFFER FOR AN IMAGE OF THE LAST DRAWN MEMORY vidlastmem = (LPBYTE)VirtualAlloc(NULL,0x10000,MEM_COMMIT,PAGE_READWRITE); ZeroMemory(vidlastmem,0x10000); // LOAD THE LOGO g_hLogoBitmap = (HBITMAP)LoadImage(g_hInstance, MAKEINTRESOURCE(IDB_APPLEWIN), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION); // CREATE A BITMAPINFO STRUCTURE FOR THE FRAME BUFFER g_pFramebufferinfo = (LPBITMAPINFO)VirtualAlloc( NULL, sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD), MEM_COMMIT, PAGE_READWRITE); ZeroMemory(g_pFramebufferinfo,sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)); g_pFramebufferinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); g_pFramebufferinfo->bmiHeader.biWidth = FRAMEBUFFER_W; g_pFramebufferinfo->bmiHeader.biHeight = FRAMEBUFFER_H; g_pFramebufferinfo->bmiHeader.biPlanes = 1; g_pFramebufferinfo->bmiHeader.biBitCount = 8; g_pFramebufferinfo->bmiHeader.biClrUsed = 256; // CREATE A BITMAPINFO STRUCTURE FOR THE SOURCE IMAGE g_pSourceHeader = (LPBITMAPINFO)VirtualAlloc( NULL, sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD), MEM_COMMIT, PAGE_READWRITE); ZeroMemory(g_pSourceHeader,sizeof(BITMAPINFOHEADER)); g_pSourceHeader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); g_pSourceHeader->bmiHeader.biWidth = SRCOFFS_TOTAL; g_pSourceHeader->bmiHeader.biHeight = 512; g_pSourceHeader->bmiHeader.biPlanes = 1; g_pSourceHeader->bmiHeader.biBitCount = 8; g_pSourceHeader->bmiHeader.biClrUsed = 256; // VideoReinitialize() ... except we set the frame buffer palette.... V_CreateIdentityPalette(); //RGB() -> none //PALETTERGB() -> PC_EXPLICIT //??? RGB() -> PC_NOCOLLAPSE for( int iColor = 0; iColor < NUM_COLOR_PALETTE; iColor++ ) customcolors[ iColor ] = ((DWORD)PC_EXPLICIT << 24) | RGB( g_pFramebufferinfo->bmiColors[iColor].rgbRed, g_pFramebufferinfo->bmiColors[iColor].rgbGreen, g_pFramebufferinfo->bmiColors[iColor].rgbBlue ); // CREATE THE FRAME BUFFER DIB SECTION AND DEVICE CONTEXT, // CREATE THE SOURCE IMAGE DIB SECTION AND DRAW INTO THE SOURCE BIT BUFFER V_CreateDIBSections(); // RESET THE VIDEO MODE SWITCHES AND THE CHARACTER SET OFFSET VideoResetState(); } //=========================================================================== int GetMonochromeIndex() { int iMonochrome; switch (g_eVideoType) { case VT_MONO_AMBER : iMonochrome = MONOCHROME_AMBER ; break; case VT_MONO_GREEN : iMonochrome = MONOCHROME_GREEN ; break; case VT_MONO_WHITE : iMonochrome = HGR_WHITE ; break; default : iMonochrome = MONOCHROME_CUSTOM; break; // caller will use MONOCHROME_CUSTOM MONOCHROME_CUSTOM_50 ! } return iMonochrome; } //=========================================================================== void V_CreateIdentityPalette () { if (g_hPalette) { DeleteObject(g_hPalette); } g_hPalette = (HPALETTE)0; SETFRAMECOLOR(BLACK, 0x00,0x00,0x00); // 0 SETFRAMECOLOR(DARK_RED, 0x80,0x00,0x00); // 1 // used by TV SETFRAMECOLOR(DARK_GREEN, 0x00,0x80,0x00); // 2 SETFRAMECOLOR(DARK_YELLOW, 0x80,0x80,0x00); // 3 SETFRAMECOLOR(DARK_BLUE, 0x00,0x00,0x80); // 4 SETFRAMECOLOR(DARK_MAGENTA,0x80,0x00,0x80); // 5 SETFRAMECOLOR(DARK_CYAN, 0x00,0x80,0x80); // 6 SETFRAMECOLOR(LIGHT_GRAY, 0xC0,0xC0,0xC0); // 7 // GR: COLOR=10 SETFRAMECOLOR(MONEY_GREEN, 0xC0,0xDC,0xC0); // 8 // not used SETFRAMECOLOR(SKY_BLUE, 0xA6,0xCA,0xF0); // 9 // not used // SET FRAME BUFFER TABLE ENTRIES TO CUSTOM COLORS #if COLORS_TWEAKED SETFRAMECOLOR(DARK_RED, 0x9D,0x09,0x66); // 1 // Linards Tweaked SETFRAMECOLOR(DARK_GREEN, 0x00,0x76,0x1A); // 2 // Linards Tweaked SETFRAMECOLOR(DARK_BLUE, 0x2A,0x2A,0xE5); // 4 // Linards Tweaked SETFRAMECOLOR(DEEP_RED, 0x9D,0x09,0x66); // 0xD0,0x00,0x30 -> Linards Tweaked 0x9D,0x09,0x66 SETFRAMECOLOR(LIGHT_BLUE,0xAA,0xAA,0xFF); // 0x60,0xA0,0xFF -> Linards Tweaked 0xAA,0xAA,0xFF SETFRAMECOLOR(BROWN, 0x55,0x55,0x00); // 0x80,0x50,0x00 -> Linards Tweaked 0x55,0x55,0x00 SETFRAMECOLOR(ORANGE, 0xF2,0x5E,0x00); // 0xFF,0x80,0x00 -> Linards Tweaked 0xF2,0x5E,0x00 SETFRAMECOLOR(PINK, 0xFF,0x89,0xE5); // 0xFF,0x90,0x80 -> Linards Tweaked 0xFF,0x89,0xE5 SETFRAMECOLOR(AQUA, 0x62,0xF6,0x99); // 0x40,0xFF,0x90 -> Linards Tweaked 0x62,0xF6,0x99 SETFRAMECOLOR(HGR_BLACK, 0x00,0x00,0x00); // For TV emulation HGR Video Mode SETFRAMECOLOR(HGR_WHITE, 0xFF,0xFF,0xFE); // BUG: PALETTE COLLAPSE! NOT white!? Win32 collapses the palette if you have duplicate colors! SETFRAMECOLOR(HGR_BLUE, 0x0D,0xA1,0xFF); // 0x00,0x80,0xFF -> Linards Tweaked 0x0D,0xA1,0xFF SETFRAMECOLOR(HGR_RED, 0xF2,0x5E,0x00); // 0xF0,0x50,0x00 -> Linards Tweaked 0xF2,0x5E,0x00 SETFRAMECOLOR(HGR_GREEN, 0x38,0xCB,0x00); // 0x20,0xC0,0x00 -> Linards Tweaked 0x38,0xCB,0x00 SETFRAMECOLOR(HGR_MAGENTA,0xC7,0x34,0xFF); // 0xA0,0x00,0xFF -> Linards Tweaked 0xC7,0x34,0xFF SETFRAMECOLOR(HGR_GREY1, 0x80,0x80,0x80); SETFRAMECOLOR(HGR_GREY2, 0x80,0x80,0x80); SETFRAMECOLOR(HGR_YELLOW, 0x9E,0x9E,0x00); // 0xD0,0xB0,0x10 -> 0x9E,0x9E,0x00 SETFRAMECOLOR(HGR_AQUA, 0x00,0xCD,0x4A); // 0x20,0xB0,0xB0 -> 0x00,0xCD,0x4A SETFRAMECOLOR(HGR_PURPLE, 0x61,0x61,0xFF); // 0x60,0x50,0xE0 -> 0x61,0x61,0xFF SETFRAMECOLOR(HGR_PINK, 0xFF,0x32,0xB5); // 0xD0,0x40,0xA0 -> 0xFF,0x32,0xB5 #else SETFRAMECOLOR(DEEP_RED, 0xD0,0x00,0x30); // 0xD0,0x00,0x30 SETFRAMECOLOR(LIGHT_BLUE,0x60,0xA0,0xFF); // 0x60,0xA0,0xFF SETFRAMECOLOR(BROWN, 0x80,0x50,0x00); // 0x80,0x50,0x00 SETFRAMECOLOR(ORANGE, 0xFF,0x80,0x00); // 0xFF,0x80,0x00 SETFRAMECOLOR(PINK, 0xFF,0x90,0x80); // 0xFF,0x90,0x80 SETFRAMECOLOR(AQUA, 0x40,0xFF,0x90); // 0x40,0xFF,0x90 SETFRAMECOLOR(HGR_BLACK, 0x00,0x00,0x00); // For TV emulation HGR Video Mode SETFRAMECOLOR(HGR_WHITE, 0xFF,0xFF,0xFE); // BUG: PALETTE COLLAPSE! NOT white!? Win32 collapses the palette if you have duplicate colors! SETFRAMECOLOR(HGR_BLUE, 0x00,0x80,0xFF); // 0x00,0x80,0xFF SETFRAMECOLOR(HGR_RED, 0xF0,0x50,0x00); // 0xF0,0x50,0x00 SETFRAMECOLOR(HGR_GREEN, 0x20,0xC0,0x00); // 0x20,0xC0,0x00 SETFRAMECOLOR(HGR_MAGENTA,0xA0,0x00,0xFF); // 0xA0,0x00,0xFF SETFRAMECOLOR(HGR_GREY1, 0x80,0x80,0x80); SETFRAMECOLOR(HGR_GREY2, 0x80,0x80,0x80); SETFRAMECOLOR(HGR_YELLOW, 0xD0,0xB0,0x10); // 0xD0,0xB0,0x10 SETFRAMECOLOR(HGR_AQUA, 0x20,0xB0,0xB0); // 0x20,0xB0,0xB0 SETFRAMECOLOR(HGR_PURPLE, 0x60,0x50,0xE0); // 0x60,0x50,0xE0 SETFRAMECOLOR(HGR_PINK, 0xD0,0x40,0xA0); // 0xD0,0x40,0xA0 #endif SETFRAMECOLOR( MONOCHROME_CUSTOM , GetRValue(monochrome) , GetGValue(monochrome) , GetBValue(monochrome) ); SETFRAMECOLOR( MONOCHROME_CUSTOM_50 , ((GetRValue(monochrome)/2) & 0xFF) , ((GetGValue(monochrome)/2) & 0xFF) , ((GetBValue(monochrome)/2) & 0xFF) ); // SEE: V_CreateLookup_MonoText SETFRAMECOLOR( MONOCHROME_AMBER , 0xFF,0x80,0x01); // Used for Monochrome Hi-Res graphics not text! SETFRAMECOLOR( MONOCHROME_GREEN , 0x00,0xC0,0x01); // Used for Monochrome Hi-Res graphics not text! // BUG PALETTE COLLAPSE: WTF?? Soon as we set 0xFF,0xFF,0xFF we lose text colors?!?! // Windows is collapsing the palette!!! //SETFRAMECOLOR( MONOCHROME_WHITE , 0xFE,0xFE,0xFE); // Used for Monochrome Hi-Res graphics not text! #if COLORS_TWEAKED SETFRAMECOLOR(CREAM, 0xFF,0xFB,0xF0); // F6 SETFRAMECOLOR(MEDIUM_GRAY, 0xA0,0xA0,0xA4); // F7 SETFRAMECOLOR(DARK_GRAY, 0x80,0x80,0x80); // F8 SETFRAMECOLOR(RED, 0xFF,0x00,0x00); // F9 SETFRAMECOLOR(GREEN, 0x38,0xCB,0x00); // FA Linards Tweaked SETFRAMECOLOR(YELLOW, 0xD5,0xD5,0x1A); // FB Linards Tweaked SETFRAMECOLOR(BLUE, 0x0D,0xA1,0xFF); // FC Linards Tweaked SETFRAMECOLOR(MAGENTA, 0xC7,0x34,0xFF); // FD Linards Tweaked SETFRAMECOLOR(CYAN, 0x00,0xFF,0xFF); // FE SETFRAMECOLOR(WHITE, 0xFF,0xFF,0xFF); // FF #else SETFRAMECOLOR(CREAM, 0xFF,0xFB,0xF0); // F6 SETFRAMECOLOR(MEDIUM_GRAY, 0xA0,0xA0,0xA4); // F7 SETFRAMECOLOR(DARK_GRAY, 0x80,0x80,0x80); // F8 SETFRAMECOLOR(RED, 0xFF,0x00,0x00); // F9 SETFRAMECOLOR(GREEN, 0x00,0xFF,0x00); // FA SETFRAMECOLOR(YELLOW, 0xFF,0xFF,0x00); // FB SETFRAMECOLOR(BLUE, 0x00,0x00,0xFF); // FC SETFRAMECOLOR(MAGENTA, 0xFF,0x00,0xFF); // FD SETFRAMECOLOR(CYAN, 0x00,0xFF,0xFF); // FE SETFRAMECOLOR(WHITE, 0xFF,0xFF,0xFF); // FF #endif // IF WE ARE IN A PALETTIZED VIDEO MODE, CREATE AN IDENTITY PALETTE HWND window = GetDesktopWindow(); HDC dc = GetDC(window); // int GetDeviceCaps( HDC, nIndex ); int colors = GetDeviceCaps(dc,SIZEPALETTE); // 16/24/32bpp = 0 int system = GetDeviceCaps(dc,NUMCOLORS); // 16/24/32bpp = -1 #if 0 // DD Full Screen Palette // Full Screen Debug Colors BYTE *pTmp; pTmp = ((BYTE*)g_pFramebufferinfo) + sizeof(BITMAPINFOHEADER); pTmp += (DEBUG_COLORS_START * 4); Debug_UpdatePalette( pTmp ); // GET THE PALETTE ENTRIES OF THE LOGO RGBQUAD aLogoPalette[256]; ZeroMemory(aLogoPalette,sizeof(aLogoPalette)); if (g_hLogoBitmap) { BYTE *pSrc = NULL; BITMAP bmp; PBITMAPINFO pbmi; // WORD cClrBits; // Retrieve the bitmap color format, width, and height. if (GetObject(g_hLogoBitmap, sizeof(BITMAP), (LPSTR)&bmp)) { pSrc = (BYTE*) pbmi->bmiColors; // Logo uses 128 colors pTmp = ((BYTE*)g_pFramebufferinfo) + sizeof(BITMAPINFOHEADER); pTmp += (LOGO_COLORS_START * 4); int iPal = 0; for( iPal = 0; iPal < 128; iPal++ ) { *pTmp++ = *pSrc++; *pTmp++ = *pSrc++; *pTmp++ = *pSrc++; *pTmp++ = *pSrc++; } } } #endif int bRasterPalette = (GetDeviceCaps(dc,RASTERCAPS) & RC_PALETTE); if (bRasterPalette && (colors <= 256)) { // GET THE PALETTE ENTRIES OF THE LOGO RGBQUAD aLogoPalette[256]; ZeroMemory(aLogoPalette,sizeof(aLogoPalette)); if (g_hLogoBitmap) { HDC memdc = CreateCompatibleDC(dc); SelectObject(memdc,g_hLogoBitmap); GetDIBColorTable(memdc,0,colors,aLogoPalette); DeleteDC(memdc); } // CREATE A PALETTE ENTRY ARRAY LOGPALETTE *paldata = (LOGPALETTE *)VirtualAlloc( NULL, sizeof(LOGPALETTE) + 256*sizeof(PALETTEENTRY), MEM_COMMIT, PAGE_READWRITE ); paldata->palVersion = 0x300; paldata->palNumEntries = colors; GetSystemPaletteEntries(dc,0,colors,paldata->palPalEntry); // FILL IN THE PALETTE ENTRIES int paletteindex = 0; int logoindex = 0; int halftoneindex = 0; // COPY THE SYSTEM PALETTE ENTRIES AT THE BEGINNING OF THE PALETTE for (; paletteindex < system/2; paletteindex++) paldata->palPalEntry[paletteindex].peFlags = 0; // FILL IN THE MIDDLE PORTION OF THE PALETTE WITH OUR OWN COLORS for (int ourindex = DEEP_RED; ourindex <= NUM_COLOR_PALETTE; ourindex++) { paldata->palPalEntry[paletteindex].peRed = g_pFramebufferinfo->bmiColors[ourindex].rgbRed; paldata->palPalEntry[paletteindex].peGreen = g_pFramebufferinfo->bmiColors[ourindex].rgbGreen; paldata->palPalEntry[paletteindex].peBlue = g_pFramebufferinfo->bmiColors[ourindex].rgbBlue; paldata->palPalEntry[paletteindex].peFlags = PC_NOCOLLAPSE; paletteindex++; } for (; paletteindex < colors-system/2; paletteindex++) { // IF THIS PALETTE ENTRY IS NEEDED FOR THE LOGO, COPY IN THE LOGO COLOR if (aLogoPalette[logoindex].rgbRed && aLogoPalette[logoindex].rgbGreen && aLogoPalette[logoindex].rgbBlue) { paldata->palPalEntry[paletteindex].peRed = aLogoPalette[logoindex].rgbRed; paldata->palPalEntry[paletteindex].peGreen = aLogoPalette[logoindex].rgbGreen; paldata->palPalEntry[paletteindex].peBlue = aLogoPalette[logoindex].rgbBlue; } // OTHERWISE, ADD A HALFTONING COLOR, SO THAT OTHER APPLICATIONS // RUNNING IN THE BACKGROUND WILL HAVE SOME REASONABLE COLORS TO USE else { static BYTE halftonetable[6] = {32,64,96,160,192,224}; paldata->palPalEntry[paletteindex].peRed = halftonetable[halftoneindex % 6]; paldata->palPalEntry[paletteindex].peGreen = halftonetable[halftoneindex/6 % 6]; paldata->palPalEntry[paletteindex].peBlue = halftonetable[halftoneindex/36 % 6]; ++halftoneindex; } ++logoindex; paldata->palPalEntry[paletteindex].peFlags = PC_NOCOLLAPSE; } // COPY THE SYSTEM PALETTE ENTRIES AT THE END OF THE PALETTE for (; paletteindex < colors; paletteindex++) paldata->palPalEntry[paletteindex].peFlags = 0; // FILL THE FRAME BUFFER TABLE WITH COLORS FROM OUR PALETTE for (int iPal = 0; iPal < colors; iPal++) { g_pFramebufferinfo->bmiColors[ iPal ].rgbRed = paldata->palPalEntry[ iPal ].peRed; g_pFramebufferinfo->bmiColors[ iPal ].rgbGreen = paldata->palPalEntry[ iPal ].peGreen; g_pFramebufferinfo->bmiColors[ iPal ].rgbBlue = paldata->palPalEntry[ iPal ].peBlue; } // CREATE THE PALETTE g_hPalette = CreatePalette(paldata); VirtualFree(paldata,0,MEM_RELEASE); } ReleaseDC(window,dc); } //=========================================================================== void V_CreateLookup_MonoText (HDC hDstDC) { static HBITMAP hCharBitmap[4]; HDC hSrcDC = CreateCompatibleDC(hDstDC); hCharBitmap[0] = LoadBitmap(g_hInstance,TEXT("CHARSET40")); hCharBitmap[1] = LoadBitmap(g_hInstance,TEXT("CHARSET82")); hCharBitmap[2] = LoadBitmap(g_hInstance,TEXT("CHARSET8C")); // FIXME: Pravets 8M probably has the same charset as Pravets 8C hCharBitmap[3] = LoadBitmap(g_hInstance,TEXT("CHARSET8C")); HBRUSH hBrush; switch (g_eVideoType) { case VT_MONO_AMBER: hBrush = CreateSolidBrush(RGB(0xFF,0x80,0x00)); break; case VT_MONO_GREEN: hBrush = CreateSolidBrush(RGB(0x00,0xC0,0x00)); break; case VT_MONO_WHITE: hBrush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF)); break; default : hBrush = CreateSolidBrush(monochrome); break; } SelectObject(hSrcDC,hCharBitmap[g_nCharsetType]); SelectObject(hDstDC,hBrush); // TODO: Update with APPLE_FONT_Y_ values BitBlt( hDstDC,SRCOFFS_40COL ,0,256,512,hSrcDC,0, 0,MERGECOPY); BitBlt( hDstDC,SRCOFFS_IIPLUS,0,256,256,hSrcDC,0,512,MERGECOPY); StretchBlt(hDstDC,SRCOFFS_80COL ,0,128,512,hSrcDC,0, 0,256,512,MERGECOPY); SelectObject(hDstDC,GetStockObject(NULL_BRUSH)); DeleteObject(hBrush); DeleteDC(hSrcDC); DeleteObject(hCharBitmap); } //=========================================================================== void V_CreateDIBSections () { CopyMemory(g_pSourceHeader->bmiColors,g_pFramebufferinfo->bmiColors,256*sizeof(RGBQUAD)); // CREATE THE DEVICE CONTEXT HWND window = GetDesktopWindow(); HDC dc = GetDC(window); if (g_hDeviceDC) { DeleteDC(g_hDeviceDC); } g_hDeviceDC = CreateCompatibleDC(dc); // CREATE THE FRAME BUFFER DIB SECTION if (g_hDeviceBitmap) DeleteObject(g_hDeviceBitmap); g_hDeviceBitmap = CreateDIBSection( dc, g_pFramebufferinfo, DIB_RGB_COLORS, (LPVOID *)&g_pFramebufferbits,0,0 ); SelectObject(g_hDeviceDC,g_hDeviceBitmap); // CREATE THE SOURCE IMAGE DIB SECTION HDC sourcedc = CreateCompatibleDC(dc); ReleaseDC(window,dc); if (g_hSourceBitmap) DeleteObject(g_hSourceBitmap); g_hSourceBitmap = CreateDIBSection( sourcedc, g_pSourceHeader, DIB_RGB_COLORS, (LPVOID *)&g_pSourcePixels,0,0 ); SelectObject(sourcedc,g_hSourceBitmap); // CREATE THE OFFSET TABLE FOR EACH SCAN LINE IN THE SOURCE IMAGE for (int y = 0; y < MAX_SOURCE_Y; y++) g_aSourceStartofLine[ y ] = g_pSourcePixels + SRCOFFS_TOTAL*((MAX_SOURCE_Y-1) - y); // DRAW THE SOURCE IMAGE INTO THE SOURCE BIT BUFFER ZeroMemory(g_pSourcePixels,SRCOFFS_TOTAL*512); // 32 bytes/pixel * 16 colors = 512 bytes/row // First monochrome mode is seperate from others if ((g_eVideoType >= VT_COLOR_STANDARD) && (g_eVideoType < VT_MONO_AMBER)) { V_CreateLookup_Text(sourcedc); V_CreateLookup_Lores(); if ( g_eVideoType == VT_COLOR_TVEMU ) V_CreateLookup_Hires(); else V_CreateLookup_HiResHalfPixel_Authentic(); V_CreateLookup_DoubleHires(); } else { V_CreateLookup_MonoText(sourcedc); V_CreateLookup_MonoLoRes(); switch (g_eVideoType) { case VT_MONO_AMBER : /* intentional fall-thru */ case VT_MONO_GREEN : /* intentional fall-thru */ case VT_MONO_WHITE : /* intentional fall-thru */ case VT_MONO_HALFPIXEL_REAL : V_CreateLookup_MonoHiResHalfPixel_Real() ; break; default: V_CreateLookup_MonoHiRes(); break; } V_CreateLookup_MonoDoubleHiRes(); } DeleteDC(sourcedc); } //=========================================================================== void V_CreateLookup_DoubleHires () { #define OFFSET 3 #define SIZE 10 for (int column = 0; column < 256; column++) { int coloffs = SIZE * column; for (unsigned byteval = 0; byteval < 256; byteval++) { int color[SIZE]; ZeroMemory(color,sizeof(color)); unsigned pattern = MAKEWORD(byteval,column); int pixel; for (pixel = 1; pixel < 15; pixel++) { if (pattern & (1 << pixel)) { int pixelcolor = 1 << ((pixel-OFFSET) & 3); if ((pixel >= OFFSET+2) && (pixel < SIZE+OFFSET+2) && (pattern & (0x7 << (pixel-4)))) color[pixel-(OFFSET+2)] |= pixelcolor; if ((pixel >= OFFSET+1) && (pixel < SIZE+OFFSET+1) && (pattern & (0xF << (pixel-4)))) color[pixel-(OFFSET+1)] |= pixelcolor; if ((pixel >= OFFSET+0) && (pixel < SIZE+OFFSET+0)) color[pixel-(OFFSET+0)] |= pixelcolor; if ((pixel >= OFFSET-1) && (pixel < SIZE+OFFSET-1) && (pattern & (0xF << (pixel+1)))) color[pixel-(OFFSET-1)] |= pixelcolor; if ((pixel >= OFFSET-2) && (pixel < SIZE+OFFSET-2) && (pattern & (0x7 << (pixel+2)))) color[pixel-(OFFSET-2)] |= pixelcolor; } } if (g_eVideoType == VT_COLOR_TEXT_OPTIMIZED) { // Activate for fringe reduction on white HGR text - drawback: loss of color mix patterns in HGR Video Mode. for (pixel = 0; pixel < 13; pixel++) { if ((pattern & (0xF << pixel)) == (unsigned)(0xF << pixel)) for (int pos = pixel; pos < pixel + 4; pos++) if (pos >= OFFSET && pos < SIZE+OFFSET) color[pos-OFFSET] = 15; } } int y = byteval << 1; for (int x = 0; x < SIZE; x++) { SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y ,DoubleHiresPalIndex[ color[x] ]); SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y+1,DoubleHiresPalIndex[ color[x] ]); } } } #undef SIZE #undef OFFSET } //=========================================================================== void V_CreateLookup_Hires () { int iMonochrome = GetMonochromeIndex(); // BYTE colorval[6] = {MAGENTA,BLUE,GREEN,ORANGE,BLACK,WHITE}; // BYTE colorval[6] = {HGR_MAGENTA,HGR_BLUE,HGR_GREEN,HGR_RED,HGR_BLACK,HGR_WHITE}; for (int iColumn = 0; iColumn < 16; iColumn++) { int coloffs = iColumn << 5; for (unsigned iByte = 0; iByte < 256; iByte++) { int aPixels[11]; aPixels[ 0] = iColumn & 4; aPixels[ 1] = iColumn & 8; aPixels[ 9] = iColumn & 1; aPixels[10] = iColumn & 2; int nBitMask = 1; int iPixel; for (iPixel = 2; iPixel < 9; iPixel++) { aPixels[iPixel] = ((iByte & nBitMask) != 0); nBitMask <<= 1; } int hibit = ((iByte & 0x80) != 0); int x = 0; int y = iByte << 1; while (x < 28) { int adj = (x >= 14) << 1; int odd = (x >= 14); for (iPixel = 2; iPixel < 9; iPixel++) { int color = CM_Black; if (aPixels[iPixel]) { if (aPixels[iPixel-1] || aPixels[iPixel+1]) color = CM_White; else color = ((odd ^ (iPixel&1)) << 1) | hibit; } else if (aPixels[iPixel-1] && aPixels[iPixel+1]) { // Activate fringe reduction on white HGR text - drawback: loss of color mix patterns in HGR video mode. // VT_COLOR_STANDARD = Fill in colors in between white pixels // VT_COLOR_TVEMU = Fill in colors in between white pixels (Post Processing will mix/merge colors) // VT_COLOR_TEXT_OPTIMIZED --> !(aPixels[iPixel-2] && aPixels[iPixel+2]) = Don't fill in colors in between white if ((g_eVideoType == VT_COLOR_TVEMU) || !(aPixels[iPixel-2] && aPixels[iPixel+2]) ) color = ((odd ^ !(iPixel&1)) << 1) | hibit; // No white HGR text optimization } //if (g_eVideoType == VT_MONO_AUTHENTIC) { // int nMonoColor = (color != CM_Black) ? iMonochrome : BLACK; // SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj ,y , nMonoColor); // buggy // SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj+1,y , nMonoColor); // buggy // SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj ,y+1,BLACK); // BL // SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj+1,y+1,BLACK); // BR //} else { // Colors - Top/Bottom Left/Right // cTL cTR // cBL cBR SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj ,y ,HiresToPalIndex[color]); // cTL SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj+1,y ,HiresToPalIndex[color]); // cTR SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj ,y+1,HiresToPalIndex[color]); // cBL SETSOURCEPIXEL(SRCOFFS_HIRES+coloffs+x+adj+1,y+1,HiresToPalIndex[color]); // cBR } x += 2; } } } } } //=========================================================================== void V_CreateLookup_Lores () { for (int color = 0; color < 16; color++) for (int x = 0; x < 16; x++) for (int y = 0; y < 16; y++) SETSOURCEPIXEL(SRCOFFS_LORES+x,(color << 4)+y,LoresResColors[color]); } //=========================================================================== void V_CreateLookup_MonoDoubleHiRes () { int iMonochrome = GetMonochromeIndex(); for (int column = 0; column < 256; column++) { int coloffs = 10 * column; for (unsigned byteval = 0; byteval < 256; byteval++) { unsigned pattern = MAKEWORD(byteval,column); int y = byteval << 1; for (int x = 0; x < 10; x++) { BYTE colorval = pattern & (1 << (x+3)) ? iMonochrome : BLACK; #if 0 if (g_eVideoType == VT_MONO_AUTHENTIC) { SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y ,colorval); SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y+1,BLACK); } else #endif { SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y ,colorval); SETSOURCEPIXEL(SRCOFFS_DHIRES+coloffs+x,y+1,colorval); } } } } } //=========================================================================== void V_CreateLookup_MonoHiRes () { const int iMonochrome = GetMonochromeIndex(); for (int column = 0; column < 512; column += 16) { for (int y = 0; y < 512; y += 2) // optimization: Byte=0..FF, Row=Byte*2 { unsigned val = (y >> 1); // iByte = (y / 2) for (int x = 0; x < 16; x += 2) // 8 pixels { BYTE colorval = (val & 1) ? iMonochrome : BLACK; val >>= 1; SETSOURCEPIXEL(SRCOFFS_HIRES+column+x ,y ,colorval); SETSOURCEPIXEL(SRCOFFS_HIRES+column+x+1,y ,colorval); { SETSOURCEPIXEL(SRCOFFS_HIRES+column+x ,y+1,colorval); SETSOURCEPIXEL(SRCOFFS_HIRES+column+x+1,y+1,colorval); } } } } } //=========================================================================== void V_CreateLookup_HiResHalfPixel_Authentic () // Colors are solid (100% coverage) { // 2-bits from previous byte, 2-bits from next byte = 2^4 = 16 total permutations for (int iColumn = 0; iColumn < 16; iColumn++) { int offsetx = iColumn << 5; // every column is 32 bytes wide -- 7 apple pixels = 14 pixels + 2 pad + 14 pixels + 2 pad for (unsigned iByte = 0; iByte < 256; iByte++) { int aPixels[11]; // c2 c1 b7 b6 b5 b4 b3 b2 b1 b0 c8 c4 /* aPixel[i] A 9|8 7 6 5 4 3 2|1 0 Z W|b b b b b b b|X Y ----+-------------+---- prev| existing |next bits| hi-res byte |bits Legend: XYZW = iColumn in binary b = Bytes in binary */ // aPixel[] = 48bbbbbbbb12, where b = iByte in binary, # is bit-n of column aPixels[ 0] = iColumn & 4; // previous byte, 2nd last pixel aPixels[ 1] = iColumn & 8; // previous byte, last pixel aPixels[ 9] = iColumn & 1; // next byte, first pixel aPixels[10] = iColumn & 2; // next byte, second pixel // Convert raw pixel Byte value to binary and stuff into bit array of pixels on off int nBitMask = 1; int iPixel; for (iPixel = 2; iPixel < 9; iPixel++) { aPixels[iPixel] = ((iByte & nBitMask) != 0); nBitMask <<= 1; } int hibit = (iByte >> 7) & 1; // ((iByte & 0x80) != 0); int x = 0; int y = iByte << 1; /* Test cases 81 blue 2000:D5 AA D5 AA 82 orange 2800:AA D5 AA D5 FF white bleed "thru" 3000:7F 80 7F 80 3800:FF 80 FF 80 2028:80 7F 80 7F 2828:80 FF 80 FF Edge Case for Half Luminance ! 2000:C4 00 // Green HalfLumBlue 2400:C4 80 // Green Green Edge Case for Color Bleed ! 2000:40 00 2400:40 80 */ // Fixup missing pixels that normally have been scan-line shifted -- Apple "half-pixel" -- but cross 14-pixel boundaries. if( hibit ) { if ( aPixels[1] ) // preceeding pixel on? #if 0 // Optimization: Doesn't seem to matter if we ignore the 2 pixels of the next byte for (iPixel = 0; iPixel < 9; iPixel++) // NOTE: You MUST start with the preceding 2 pixels !!! if (aPixels[iPixel]) // pixel on #endif { if (aPixels[2] || aPixels[0]) // White if pixel from previous byte and first pixel of this byte is on { SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y , HGR_WHITE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y+1, HGR_WHITE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y , HGR_WHITE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y+1, HGR_WHITE ); } else { // Optimization: odd = (iPixel & 1); if (!odd) case is same as if(odd) !!! // Reference: Gumball - Gumball Machine SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y , HGR_RED ); // left half of orange pixels SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y+1, HGR_RED ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y , HGR_BLUE ); // right half of blue pixels 4, 11, 18, ... SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y+1, HGR_BLUE ); } } #if HALF_PIXEL_SOLID // Test Patterns // 81 blue // 2000:D5 AA D5 AA -> 2001:AA D5 should not have black gap, should be blue // 82 orange // 2800:AA D5 AA D5 // Game: Elite -- Loading Logo // 2444:BB F7 -> 2000:BB F7 // Should not have orange in-between gap -- Elite "Firebird" Logo // -> 2400:00 BB F7 // Should not have blue in-between gap ) // 21D0:C0 00 -> HalfLumBlue // 25D0:C0 D0 88 -> Blue black orange black orange // 29D0:C0 90 88 -> Blue black orange // Game: Ultima 4 -- Ultima 4 Logo - bottom half of screen has a "mini-game" / demo -- far right has tree and blue border // 2176:2A AB green black_gap white blue_border // Should have black gap between green and white else if ( aPixels[0] ) // prev prev pixel on { // Game: Gumball // 218E:AA 97 => 2000: A9 87 orange_white // Should have no gap between orange and white // 229A:AB A9 87 -> 2000: 00 A9 87 white orange black blue_white // Should have no gap between blue and white // 2001:BB F7 white blue white (Gumball Intermission) // Torture Half-Pixel HGR Tests: This is a real bitch to solve -- we really need to check: // if (hibit_prev_byte && !aPixels[iPixel-3] && aPixels[iPixel-2] && !aPixels[iPixel] && hibit_this_byte) then set first half-pixel of this byte to either blue or orange // 2000:A9 87 halfblack blue black black orange black orange black // 2400:BB F7 halfblack white white black white white white halfblack // or // 2000:A0 83 orange should "bleed" thru // 2400:B0 83 should have black gap if ( aPixels[2] ) #if HALF_PIXEL_BLEED // No Half-Pixel Bleed if ( aPixels[3] ) { SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y , DARK_BLUE ); // Gumball: 229A: AB A9 87 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y+1, DARK_BLUE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y , BROWN ); // half luminance red Elite: 2444: BB F7 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y+1, BROWN ); // half luminance red Gumball: 218E: AA 97 } else { SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y , HGR_BLUE ); // 2000:D5 AA D5 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y+1, HGR_BLUE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y , HGR_RED ); // 2000: AA D5 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y+1, HGR_RED ); } #else if ((g_eVideoType == VT_COLOR_STANDARD) || ( !aPixels[3] )) { // "Text optimized" IF this pixel on, and adjacent right pixel off, then colorize first half-pixel of this byte SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y , HGR_BLUE ); // 2000:D5 AA D5 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+0 ,y+1, HGR_BLUE ); SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y , HGR_RED ); // 2000: AA D5 SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+16,y+1, HGR_RED ); } #endif // HALF_PIXEL_BLEED } #endif // HALF_PIXEL_SOLID } x += hibit; while (x < 28) { int adj = (x >= 14) << 1; // Adjust start of 7 last pixels to be 16-byte aligned! int odd = (x >= 14); for (iPixel = 2; iPixel < 9; iPixel++) { int color = CM_Black; if (aPixels[iPixel]) // pixel on { color = CM_White; if (aPixels[iPixel-1] || aPixels[iPixel+1]) // adjacent pixels are always white color = CM_White; else color = ((odd ^ (iPixel&1)) << 1) | hibit; // map raw color to our hi-res colors } #if HALF_PIXEL_SOLID else if (aPixels[iPixel-1] && aPixels[iPixel+1]) // IF prev_pixel && next_pixel THEN { // Activate fringe reduction on white HGR text - drawback: loss of color mix patterns in HGR video mode. if ( (g_eVideoType == VT_COLOR_STANDARD) // Fill in colors in between white pixels || (g_eVideoType == VT_COLOR_TVEMU) // Fill in colors in between white pixels (Post Processing will mix/merge colors) || !(aPixels[iPixel-2] && aPixels[iPixel+2]) ) // VT_COLOR_TEXT_OPTIMIZED -> Don't fill in colors in between white { // Test Pattern: Ultima 4 Logo - Castle // 3AC8: 36 5B 6D 36 color = ((odd ^ !(iPixel&1)) << 1) | hibit; // No white HGR text optimization } } #endif // Colors - Top/Bottom Left/Right // cTL cTR // cBL cBR SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+adj ,y ,HiresToPalIndex[color]); // cTL SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+adj+1,y ,HiresToPalIndex[color]); // cTR SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+adj ,y+1,HiresToPalIndex[color]); // cBL SETSOURCEPIXEL(SRCOFFS_HIRES+offsetx+x+adj+1,y+1,HiresToPalIndex[color]); // cBR x += 2; } } } } } //=========================================================================== void V_CreateLookup_MonoHiResHalfPixel_Real () { int iMono = GetMonochromeIndex(); for (int iColumn = 0; iColumn < 16; iColumn++) { int offset = iColumn << 5; // every column is 32 bytes wide for (unsigned iByte = 0; iByte < 256; iByte++) { int aPixels[11]; // c2 c1 b7 b6 b5 b4 b3 b2 b1 b0 c8 c4 aPixels[ 0] = iColumn & 4; aPixels[ 1] = iColumn & 8; aPixels[ 9] = iColumn & 1; aPixels[10] = iColumn & 2; int nBitMask = 1; int iPixel; for (iPixel = 2; iPixel < 9; iPixel++) { aPixels[iPixel] = ((iByte & nBitMask) != 0); nBitMask <<= 1; } int hibit = (iByte >> 7) & 1; // ((iByte & 0x80) != 0); int x = 0; int y = iByte << 1; // Fixup missing pixels that normally have been scan-line shifted -- Apple "half-pixel" -- but cross 14-pixel boundaries. if( hibit ) { /* Test Cases // Games Archon Logo Gumball (at Machine) // Applesoft HGR:HCOLOR=5:HPLOT 0,0 TO 279,0 // Blue // Orange CALL-151 C050 C052 C057 2000:D0 80 00 2800:80 D0 00 */ if ( aPixels[1] ) // preceeding pixel on? { SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x ,y ,iMono); // first 7 HGR_BLUE SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x ,y+1,iMono); // first 7 SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+16,y ,iMono); // second 7 HGR_RED SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+16,y+1,iMono); // second 7 } } while (x < 28) { int adj = (x >= 14) << 1; // Adjust start of 7 last pixels to be 16-byte aligned! int odd = (x >= 14); for (iPixel = 2; iPixel < 9; iPixel++) { int color = aPixels[iPixel] ? iMono : HGR_BLACK; // Colors - Top/Bottom Left/Right SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+adj +hibit,y ,color); // TL SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+adj+1+hibit,y ,color); // BL SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+adj +hibit,y+1,color); // BL SETSOURCEPIXEL(SRCOFFS_HIRES+offset+x+adj+1+hibit,y+1,color); // BR x += 2; } } } } } //=========================================================================== void V_CreateLookup_MonoLoRes () { int iMonochrome = GetMonochromeIndex(); for (int color = 0; color < 16; color++) { for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { BYTE colorval = (color >> (x & 3) & 1) ? iMonochrome : BLACK; #if 0 if (g_eVideoType == VT_MONO_AUTHENTIC) { if (y & 1) SETSOURCEPIXEL(SRCOFFS_LORES+x,(color << 4)+y,BLACK); else SETSOURCEPIXEL(SRCOFFS_LORES+x,(color << 4)+y,colorval); } else #endif { SETSOURCEPIXEL(SRCOFFS_LORES+x,(color << 4)+y,colorval); } } } } } // google: CreateDIBPatternBrushPt // http://209.85.141.104/search?q=cache:mB3htrQGW8kJ:bookfire.net/wince/wince-programming-ms-press2/source/prowice/ch02e.htm struct BRUSHBMP { BITMAPINFOHEADER bmi; COLORREF dwPal[2]; BYTE bBits[64]; }; HBRUSH V_CreateCustomBrush(COLORREF nColor) { BRUSHBMP brbmp; BYTE *pBytes; int i; //DWORD dwBits[6][2] = //{ // {0x000000ff,0x00000000}, // HS_HORIZONTAL 0 /* ----- */ // {0x10101010,0x10101010}, // HS_VERTICAL 1 /* ||||| */ // {0x01020408,0x10204080}, // HS_FDIAGONAL 2 /* \\\\\ */ // {0x80402010,0x08040201}, // HS_BDIAGONAL 3 /* ///// */ // {0x101010ff,0x10101010}, // HS_CROSS 4 /* +++++ */ // {0x81422418,0x18244281}, // HS_DIAGCROSS 5 /* xxxxx */ //}; // if ((HatchStyle < 0) || (HatchStyle > 6)) // return 0; int HatchStyle = 0; DWORD dwBits[1][2] = { // {0xff00ff00,0xff00ff00} // every other scan line {0xFFFFFFFF,0xFFFFFFFF} }; memset (&brbmp, 0, sizeof (brbmp)); brbmp.bmi.biSize = sizeof (BITMAPINFOHEADER); brbmp.bmi.biWidth = 8; brbmp.bmi.biHeight = 8; brbmp.bmi.biPlanes = 1; brbmp.bmi.biBitCount = 1; brbmp.bmi.biClrUsed = 2; brbmp.bmi.biClrImportant = 2; // Initialize the palette of the bitmap. brbmp.dwPal[0] = PALETTERGB(0x00,0x00,0x00); brbmp.dwPal[1] = PALETTERGB( (BYTE)((nColor >> 16) & 0xff), (BYTE)((nColor >> 8) & 0xff), (BYTE)((nColor >> 0) & 0xff)); // Write the hatch data to the bitmap. pBytes = (BYTE *)&dwBits[HatchStyle]; for (i = 0; i < 8; i++) brbmp.bBits[i*4] = *pBytes++; // Return the handle of the brush created. return CreateDIBPatternBrushPt (&brbmp, DIB_RGB_COLORS); } //=========================================================================== void V_CreateLookup_Text (HDC dc) { HDC memdc = CreateCompatibleDC(dc); static HBITMAP hCharBitmap[4]; //The charset is set below hCharBitmap[0] = LoadBitmap(g_hInstance,TEXT("CHARSET40")); hCharBitmap[1] = LoadBitmap(g_hInstance,TEXT("CHARSET82")); hCharBitmap[2] = LoadBitmap(g_hInstance,TEXT("CHARSET8C")); // FIXME: Pravets 8M probably has the same charset as Pravets 8C hCharBitmap[3] = LoadBitmap(g_hInstance,TEXT("CHARSET8C")); SelectObject(memdc,hCharBitmap[g_nCharsetType]); BitBlt( dc // hdcDest ,SRCOFFS_40COL ,0 // nXDest, nYDest ,256 ,512 // nWidth, nHeight ,memdc // hdcSrc ,0 ,0 // nXSrc, nYSrc ,SRCCOPY ); // dwRop // Chars for Apple ][ BitBlt(dc,SRCOFFS_IIPLUS,0,256,256,memdc,0,512,SRCCOPY); // Chars for 80 col mode StretchBlt(dc,SRCOFFS_80COL,0,128,512,memdc,0,0,256,512,SRCCOPY); DeleteDC(memdc); DeleteObject(hCharBitmap); } //=========================================================================== void SetLastDrawnImage () { memcpy(vidlastmem+0x400,g_pTextBank0,0x400); if (SW_HIRES) memcpy(vidlastmem+0x2000,g_pHiresBank0,0x2000); if (SW_DHIRES && SW_HIRES) memcpy(vidlastmem,g_pHiresBank1,0x2000); else if (SW_80COL) // Don't test for !SW_HIRES, as some 80-col text routines have SW_HIRES set (Bug #8300) memcpy(vidlastmem,g_pTextBank1,0x400); int loop; for (loop = 0; loop < 256; loop++) { *(memdirty+loop) &= ~2; } } //=========================================================================== static inline int GetOriginal2EOffset(BYTE ch) { // No mousetext for original IIe return !IsOriginal2E() || !g_nAltCharSetOffset || (ch<0x40) || (ch>0x5F) ? 0 : -g_nAltCharSetOffset; } bool Update40ColCell (int x, int y, int xpixel, int ypixel, int offset) { BYTE ch = *(g_pTextBank0+offset); bool bCharChanged = (ch != *(vidlastmem+offset+0x400) || g_VideoForceFullRedraw); // FLASHing chars: // - FLASHing if:Alt Char Set is OFF && 0x40<=char<=0x7F // - The inverse of this char is located at: char+0x40 bool bCharFlashing = (g_nAltCharSetOffset == 0) && (ch >= 0x40) && (ch <= 0x7F); if(bCharChanged || (bCharFlashing && g_bTextFlashFlag)) { bool bInvert = bCharFlashing ? g_bTextFlashState : false; CopySource(xpixel,ypixel, APPLE_FONT_WIDTH, APPLE_FONT_HEIGHT, (IS_APPLE2 ? SRCOFFS_IIPLUS : SRCOFFS_40COL) + ((ch & 0x0F) << 4), (ch & 0xF0) + g_nAltCharSetOffset + GetOriginal2EOffset(ch) + (bInvert ? 0x40 : 0x00)); return true; } return false; } inline bool _Update80ColumnCell( BYTE c, const int xPixel, const int yPixel, bool bCharFlashing ) { bool bInvert = bCharFlashing ? g_bTextFlashState : false; CopySource( xPixel, yPixel, (APPLE_FONT_WIDTH / 2), APPLE_FONT_HEIGHT, SRCOFFS_80COL + ((c & 0x0F) << 3), (c & 0xF0) + g_nAltCharSetOffset + GetOriginal2EOffset(c) + (bInvert ? 0x40 : 0x00)); return true; } //=========================================================================== bool Update80ColCell (int x, int y, int xpixel, int ypixel, int offset) { bool bDirty = false; #if FLASH_80_COL BYTE c1 = *(g_pTextBank1 + offset); // aux BYTE c0 = *(g_pTextBank0 + offset); // main bool bC1Changed = (c1 != *(vidlastmem + offset + 0) || g_VideoForceFullRedraw); bool bC0Changed = (c0 != *(vidlastmem + offset + 0x400) || g_VideoForceFullRedraw); bool bC1Flashing = (g_nAltCharSetOffset == 0) && (c1 >= 0x40) && (c1 <= 0x7F); bool bC0Flashing = (g_nAltCharSetOffset == 0) && (c0 >= 0x40) && (c0 <= 0x7F); if (bC1Changed || (bC1Flashing && g_bTextFlashFlag)) bDirty = _Update80ColumnCell( c1, xpixel, ypixel, bC1Flashing ); if (bC0Changed || (bC0Flashing && g_bTextFlashFlag)) bDirty |= _Update80ColumnCell( c0, xpixel + 7, ypixel, bC0Flashing ); #else BYTE auxval = *(g_pTextBank1 + offset); // aux BYTE mainval = *(g_pTextBank0 + offset); // main if ((auxval != *(vidlastmem+offset)) || (mainval != *(vidlastmem+offset+0x400)) || g_VideoForceFullRedraw) { CopySource(xpixel,ypixel, (APPLE_FONT_WIDTH / 2), APPLE_FONT_HEIGHT, SRCOFFS_80COL + ((auxval & 15)<<3), ((auxval>>4)<<4) + g_nAltCharSetOffset); CopySource(xpixel+7,ypixel, (APPLE_FONT_WIDTH / 2), APPLE_FONT_HEIGHT, SRCOFFS_80COL + ((mainval & 15)<<3), ((mainval>>4)<<4) + g_nAltCharSetOffset ); bDirty = true; } #endif return bDirty; } //=========================================================================== bool UpdateDHiResCell (int x, int y, int xpixel, int ypixel, int offset) { bool bDirty = false; int yoffset = 0; while (yoffset < 0x2000) { BYTE byteval1 = (x > 0) ? *(g_pHiresBank0+offset+yoffset-1) : 0; BYTE byteval2 = *(g_pHiresBank1 +offset+yoffset); BYTE byteval3 = *(g_pHiresBank0+offset+yoffset); BYTE byteval4 = (x < 39) ? *(g_pHiresBank1 +offset+yoffset+1) : 0; if ((byteval2 != *(vidlastmem+offset+yoffset)) || (byteval3 != *(vidlastmem+offset+yoffset+0x2000)) || ((x > 0) && ((byteval1 & 0x70) != (*(vidlastmem+offset+yoffset+0x1FFF) & 0x70))) || ((x < 39) && ((byteval4 & 0x07) != (*(vidlastmem+offset+yoffset+ 1) & 0x07))) || g_VideoForceFullRedraw) { DWORD dwordval = (byteval1 & 0x70) | ((byteval2 & 0x7F) << 7) | ((byteval3 & 0x7F) << 14) | ((byteval4 & 0x07) << 21); #define PIXEL 0 #define COLOR ((xpixel + PIXEL) & 3) #define VALUE (dwordval >> (4 + PIXEL - COLOR)) CopySource(xpixel+PIXEL,ypixel+(yoffset >> 9),7,2, SRCOFFS_DHIRES+10*HIBYTE(VALUE)+COLOR,LOBYTE(VALUE)<<1); #undef PIXEL #define PIXEL 7 CopySource(xpixel+PIXEL,ypixel+(yoffset >> 9),7,2, SRCOFFS_DHIRES+10*HIBYTE(VALUE)+COLOR,LOBYTE(VALUE)<<1); #undef PIXEL #undef COLOR #undef VALUE bDirty = true; } yoffset += 0x400; } return bDirty; } /* Color Reference Tests: 2000:D5 AA D5 AA D5 AA // blue blue blue 2400:AA D5 2A 55 55 2A //+ red green magenta // //= grey aqua purple 2C00:AA D5 AA D5 2A 55 // red red green 3000:2A 55 55 2A 55 2A //+ green magenta magenta // //= yellow pink grey */ //=========================================================================== BYTE MixColors(BYTE c1, BYTE c2) { // For tv emulation HGR Video Mode #define COMBINATION(c1,c2,ref1,ref2) (((c1)==(ref1)&&(c2)==(ref2)) || ((c1)==(ref2)&&(c2)==(ref1))) if (c1 == c2) return c1; if (COMBINATION(c1,c2,HGR_BLUE,HGR_RED)) return HGR_GREY1; else if (COMBINATION(c1,c2,HGR_GREEN,HGR_MAGENTA)) return HGR_GREY2; else if (COMBINATION(c1,c2,HGR_RED,HGR_GREEN)) return HGR_YELLOW; else if (COMBINATION(c1,c2,HGR_BLUE,HGR_GREEN)) return HGR_AQUA; else if (COMBINATION(c1,c2,HGR_BLUE,HGR_MAGENTA)) return HGR_PURPLE; else if (COMBINATION(c1,c2,HGR_RED,HGR_MAGENTA)) return HGR_PINK; else return MONOCHROME_CUSTOM; // visible failure indicator #undef COMBINATION } //=========================================================================== void CreateColorMixMap() { // For tv emulation HGR Video Mode #define FROM_NEIGHBOUR 0x00 int t,m,b; BYTE cTop, cMid, cBot; WORD mixTop, mixBot; #define MIX_THRESHOLD 0x12 // bottom 2 HGR colors for (t=0; t<6; t++) for (m=0; m<6; m++) for (b=0; b<6; b++) { cTop = t | 0x10; cMid = m | 0x10; cBot = b | 0x10; if (cMid < MIX_THRESHOLD) { mixTop = mixBot = cMid; } else { if (cTop < MIX_THRESHOLD) { mixTop = FROM_NEIGHBOUR; } else { mixTop = MixColors(cMid,cTop); } if (cBot < MIX_THRESHOLD) { mixBot = FROM_NEIGHBOUR; } else { mixBot = MixColors(cMid,cBot); } if (mixTop == FROM_NEIGHBOUR && mixBot != FROM_NEIGHBOUR) { mixTop = mixBot; } else if (mixBot == FROM_NEIGHBOUR && mixTop != FROM_NEIGHBOUR) { mixBot = mixTop; } else if (mixBot == FROM_NEIGHBOUR && mixTop == FROM_NEIGHBOUR) { mixBot = mixTop = cMid; } } colormixmap[t][m][b] = (mixTop << 8) | mixBot; } #undef FROM_NEIGHBOUR } //=========================================================================== void __stdcall MixColorsVertical(int matx, int maty) { // For tv emulation HGR Video Mode WORD twoHalfPixel; int bot1idx, bot2idx; if (SW_MIXED && maty > 159) { if (maty < 161) { bot1idx = hgrpixelmatrix[matx][maty+1] & 0x0F; bot2idx = 0; } else { bot1idx = bot2idx = 0; } } else { bot1idx = hgrpixelmatrix[matx][maty+1] & 0x0F; bot2idx = hgrpixelmatrix[matx][maty+2] & 0x0F; } twoHalfPixel = colormixmap[hgrpixelmatrix[matx][maty-2] & 0x0F] [hgrpixelmatrix[matx][maty-1] & 0x0F] [hgrpixelmatrix[matx][maty ] & 0x0F]; colormixbuffer[0] = (twoHalfPixel & 0xFF00) >> 8; colormixbuffer[1] = twoHalfPixel & 0x00FF; twoHalfPixel = colormixmap[hgrpixelmatrix[matx][maty-1] & 0x0F] [hgrpixelmatrix[matx][maty ] & 0x0F] [bot1idx]; colormixbuffer[2] = (twoHalfPixel & 0xFF00) >> 8; colormixbuffer[3] = twoHalfPixel & 0x00FF; twoHalfPixel = colormixmap[hgrpixelmatrix[matx][maty ] & 0x0F] [bot1idx] [bot2idx]; colormixbuffer[4] = (twoHalfPixel & 0xFF00) >> 8; colormixbuffer[5] = twoHalfPixel & 0x00FF; } //=========================================================================== static inline void __stdcall CopyMixedSource8(int x, int y, int sourcex, int sourcey) { // For tv emulation HGR Video Mode const BYTE* const currsourceptr = g_aSourceStartofLine[sourcey]+sourcex; BYTE* const currdestptr = g_aFrameBufferOffset[y*2] + (x*2); const int matx = x; const int maty = HGR_MATRIX_YOFFSET + y; const int hgrlinesabove = (y > 0) ? 1 : 0; const int hgrlinesbelow = SW_MIXED ? ((y < 159)? 1:0) : ((y < 191)? 1:0); const int istart = 2 - (hgrlinesabove*2); const int iend = 3 + (hgrlinesbelow*2); // transfer 7 pixels (i.e. the visible part of an apple hgr-byte) from row to pixelmatrix for (int count = 0, bufxoffset = 0; count < 7; count++, bufxoffset += 2) { hgrpixelmatrix[matx+count][maty] = *(currsourceptr+bufxoffset); // color mixing between adjacent scanlines at current x position MixColorsVertical(matx+count, maty); // transfer up to 6 mixed (half-)pixels of current column to framebuffer BYTE* currptr = currdestptr+bufxoffset; if (hgrlinesabove) currptr += g_nFrameBufferPitch * 2; for (int i = istart; i <= iend; currptr -= g_nFrameBufferPitch, i++) { if (g_uHalfScanLines && (i & 1)) *currptr = *(currptr+1) = 0; // 50% Half Scan Line clears every odd scanline (and SHIFT+PrintScreen saves only the even rows) else *currptr = *(currptr+1) = colormixbuffer[i]; } } } // For tv emulation HGR Video Mode static void __stdcall CopyMixedSource(int x, int y, int sourcex, int sourcey) { if (!g_bIsFullScreen || !GetFullScreen32Bit()) { CopyMixedSource8(x,y,sourcex,sourcey); return; } const BYTE* const currsourceptr = g_aSourceStartofLine[sourcey]+sourcex; UINT32* const currdestptr = (UINT32*) (g_aFrameBufferOffset[ y*2 ] + (x*2)*sizeof(UINT32)); const int matx = x; const int maty = HGR_MATRIX_YOFFSET + y; const int hgrlinesabove = (y > 0) ? 1 : 0; const int hgrlinesbelow = SW_MIXED ? ((y < 159)? 1:0) : ((y < 191)? 1:0); const int istart = 2 - (hgrlinesabove*2); const int iend = 3 + (hgrlinesbelow*2); // transfer 7 pixels (i.e. the visible part of an apple hgr-byte) from row to pixelmatrix for (int count = 0, bufxoffset = 0; count < 7; count++, bufxoffset += 2) { hgrpixelmatrix[matx+count][maty] = *(currsourceptr+bufxoffset); // color mixing between adjacent scanlines at current x position MixColorsVertical(matx+count, maty); // transfer up to 6 mixed (half-)pixels of current column to framebuffer UINT32* currptr = currdestptr+bufxoffset; if (hgrlinesabove) currptr += (g_nFrameBufferPitch / sizeof(UINT32)) * 2; for (int i = istart; i <= iend; currptr -= g_nFrameBufferPitch/sizeof(UINT32), i++) { if (g_uHalfScanLines && (i & 1)) { // 50% Half Scan Line clears every odd scanline (and SHIFT+PrintScreen saves only the even rows) *currptr = *(currptr+1) = 0; } else { const RGBQUAD& rRGB = g_pFramebufferinfo->bmiColors[ colormixbuffer[i] ]; const UINT32 rgb = (((UINT32)rRGB.rgbRed)<<16) | (((UINT32)rRGB.rgbGreen)<<8) | ((UINT32)rRGB.rgbBlue); *currptr = *(currptr+1) = rgb; } } } } //=========================================================================== bool UpdateHiResCell (int x, int y, int xpixel, int ypixel, int offset) { bool bDirty = false; int yoffset = 0; while (yoffset < 0x2000) { #if 0 // TRACE_VIDEO static char sText[ 256 ]; sprintf(sText, "x: %3d y: %3d xpix: %3d ypix: %3d offset: %04X \n" , x, y, xpixel, ypixel, offset, yoffset ); OutputDebugString("sText"); #endif BYTE byteval1 = (x > 0) ? *(g_pHiresBank0+offset+yoffset-1) : 0; BYTE byteval2 = *(g_pHiresBank0+offset+yoffset ); BYTE byteval3 = (x < 39) ? *(g_pHiresBank0+offset+yoffset+1) : 0; if ((byteval2 != *(vidlastmem+offset+yoffset+0x2000)) || ((x > 0) && ((byteval1 & 0x60) != (*(vidlastmem+offset+yoffset+0x1FFF) & 0x60))) || ((x < 39) && ((byteval3 & 0x03) != (*(vidlastmem+offset+yoffset+0x2001) & 0x03))) || g_VideoForceFullRedraw) { #define COLOFFS (((byteval1 & 0x60) << 2) | \ ((byteval3 & 0x03) << 5)) if (g_eVideoType == VT_COLOR_TVEMU) { CopyMixedSource( xpixel >> 1, (ypixel+(yoffset >> 9)) >> 1, SRCOFFS_HIRES+COLOFFS+((x & 1) << 4), (((int)byteval2) << 1) ); } else { CopySource( xpixel,ypixel+(yoffset >> 9), 14,2, // 2x upscale: 280x192 -> 560x384 SRCOFFS_HIRES+COLOFFS+((x & 1) << 4), (((int)byteval2) << 1) ); } #undef COLOFFS bDirty = true; } yoffset += 0x400; } return bDirty; } //=========================================================================== bool UpdateLoResCell (int x, int y, int xpixel, int ypixel, int offset) { BYTE val = *(g_pTextBank0+offset); if ((val != *(vidlastmem+offset+0x400)) || g_VideoForceFullRedraw) { CopySource(xpixel,ypixel, 14,8, SRCOFFS_LORES+((x & 1) << 1),((val & 0xF) << 4)); CopySource(xpixel,ypixel+8, 14,8, SRCOFFS_LORES+((x & 1) << 1),(val & 0xF0)); return true; } return false; } //=========================================================================== #define ROL_NIB(x) ( (((x)<<1)&0xF) | (((x)>>3)&1) ) bool UpdateDLoResCell (int x, int y, int xpixel, int ypixel, int offset) { BYTE auxval = *(g_pTextBank1 + offset); BYTE mainval = *(g_pTextBank0 + offset); if ( (auxval != *(vidlastmem+offset)) || (mainval != *(vidlastmem+offset+0x400)) || g_VideoForceFullRedraw ) { const BYTE auxval_h = auxval >> 4; const BYTE auxval_l = auxval & 0xF; auxval = (ROL_NIB(auxval_h)<<4) | ROL_NIB(auxval_l); // Fix Bug #14879 CopySource( xpixel,ypixel , 7,8,SRCOFFS_LORES+((x & 1) << 1),((auxval & 0xF) << 4)); CopySource( xpixel,ypixel+8, 7,8,SRCOFFS_LORES+((x & 1) << 1),(auxval & 0xF0)); // CopySource( xpixel+7,ypixel , 7,8, SRCOFFS_LORES+((x & 1) << 1),((mainval & 0xF) << 4)); CopySource( xpixel+7,ypixel+8, 7,8, SRCOFFS_LORES+((x & 1) << 1),(mainval & 0xF0)); return true; } return false; } // // ----- ALL GLOBALLY ACCESSIBLE FUNCTIONS ARE BELOW THIS LINE ----- // //=========================================================================== BOOL VideoApparentlyDirty () { if (SW_MIXED || g_VideoForceFullRedraw) return 1; DWORD address = (SW_HIRES && !SW_TEXT) ? (0x20 << (int)g_bVideoDisplayPage2) : (0x04 << (int)g_bVideoDisplayPage2); DWORD length = (SW_HIRES && !SW_TEXT) ? 0x20 : 0x4; while (length--) if (*(memdirty+(address++)) & 2) return 1; // bool bCharFlashing = false; // Scan visible text page for any flashing chars if((SW_TEXT || SW_MIXED) && (g_nAltCharSetOffset == 0)) { BYTE* pnMemText = MemGetMainPtr(0x400 << (int)g_bVideoDisplayPage2); // Scan 8 long-lines of 120 chars (at 128 char offsets): // . Skip 8-char holes in TEXT for(UINT y=0; y<8; y++) { for(UINT x=0; x<40*3; x++) { BYTE ch = pnMemText[y*128+x]; if((ch >= 0x40) && (ch <= 0x7F)) { bCharFlashing = true; break; } } } } if(bCharFlashing) return 1; return 0; } //=========================================================================== void VideoBenchmark () { Sleep(500); // PREPARE TWO DIFFERENT FRAME BUFFERS, EACH OF WHICH HAVE HALF OF THE // BYTES SET TO 0x14 AND THE OTHER HALF SET TO 0xAA int loop; LPDWORD mem32 = (LPDWORD)mem; for (loop = 4096; loop < 6144; loop++) *(mem32+loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0x14141414 : 0xAAAAAAAA; for (loop = 6144; loop < 8192; loop++) *(mem32+loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0xAAAAAAAA : 0x14141414; // SEE HOW MANY TEXT FRAMES PER SECOND WE CAN PRODUCE WITH NOTHING ELSE // GOING ON, CHANGING HALF OF THE BYTES IN THE VIDEO BUFFER EACH FRAME TO // SIMULATE THE ACTIVITY OF AN AVERAGE GAME DWORD totaltextfps = 0; g_bVideoMode = VF_TEXT; FillMemory(mem+0x400,0x400,0x14); VideoRedrawScreen(); DWORD milliseconds = GetTickCount(); while (GetTickCount() == milliseconds) ; milliseconds = GetTickCount(); DWORD cycle = 0; do { if (cycle & 1) FillMemory(mem+0x400,0x400,0x14); else CopyMemory(mem+0x400,mem+((cycle & 2) ? 0x4000 : 0x6000),0x400); VideoRefreshScreen(); if (cycle++ >= 3) cycle = 0; totaltextfps++; } while (GetTickCount() - milliseconds < 1000); // SEE HOW MANY HIRES FRAMES PER SECOND WE CAN PRODUCE WITH NOTHING ELSE // GOING ON, CHANGING HALF OF THE BYTES IN THE VIDEO BUFFER EACH FRAME TO // SIMULATE THE ACTIVITY OF AN AVERAGE GAME DWORD totalhiresfps = 0; g_bVideoMode = VF_HIRES; FillMemory(mem+0x2000,0x2000,0x14); VideoRedrawScreen(); milliseconds = GetTickCount(); while (GetTickCount() == milliseconds) ; milliseconds = GetTickCount(); cycle = 0; do { if (cycle & 1) FillMemory(mem+0x2000,0x2000,0x14); else CopyMemory(mem+0x2000,mem+((cycle & 2) ? 0x4000 : 0x6000),0x2000); VideoRefreshScreen(); if (cycle++ >= 3) cycle = 0; totalhiresfps++; } while (GetTickCount() - milliseconds < 1000); // DETERMINE HOW MANY 65C02 CLOCK CYCLES WE CAN EMULATE PER SECOND WITH // NOTHING ELSE GOING ON CpuSetupBenchmark(); DWORD totalmhz10 = 0; milliseconds = GetTickCount(); while (GetTickCount() == milliseconds) ; milliseconds = GetTickCount(); cycle = 0; do { CpuExecute(100000); totalmhz10++; } while (GetTickCount() - milliseconds < 1000); // IF THE PROGRAM COUNTER IS NOT IN THE EXPECTED RANGE AT THE END OF THE // CPU BENCHMARK, REPORT AN ERROR AND OPTIONALLY TRACK IT DOWN if ((regs.pc < 0x300) || (regs.pc > 0x400)) if (MessageBox(g_hFrameWindow, TEXT("The emulator has detected a problem while running ") TEXT("the CPU benchmark. Would you like to gather more ") TEXT("information?"), TEXT("Benchmarks"), MB_ICONQUESTION | MB_YESNO | MB_SETFOREGROUND) == IDYES) { BOOL error = 0; WORD lastpc = 0x300; int loop = 0; while ((loop < 10000) && !error) { CpuSetupBenchmark(); CpuExecute(loop); if ((regs.pc < 0x300) || (regs.pc > 0x400)) error = 1; else { lastpc = regs.pc; ++loop; } } if (error) { TCHAR outstr[256]; wsprintf(outstr, TEXT("The emulator experienced an error %u clock cycles ") TEXT("into the CPU benchmark. Prior to the error, the ") TEXT("program counter was at $%04X. After the error, it ") TEXT("had jumped to $%04X."), (unsigned)loop, (unsigned)lastpc, (unsigned)regs.pc); MessageBox(g_hFrameWindow, outstr, TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND); } else MessageBox(g_hFrameWindow, TEXT("The emulator was unable to locate the exact ") TEXT("point of the error. This probably means that ") TEXT("the problem is external to the emulator, ") TEXT("happening asynchronously, such as a problem in ") TEXT("a timer interrupt handler."), TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND); } // DO A REALISTIC TEST OF HOW MANY FRAMES PER SECOND WE CAN PRODUCE // WITH FULL EMULATION OF THE CPU, JOYSTICK, AND DISK HAPPENING AT // THE SAME TIME DWORD realisticfps = 0; FillMemory(mem+0x2000,0x2000,0xAA); VideoRedrawScreen(); milliseconds = GetTickCount(); while (GetTickCount() == milliseconds) ; milliseconds = GetTickCount(); cycle = 0; do { if (realisticfps < 10) { int cycles = 100000; while (cycles > 0) { DWORD executedcycles = CpuExecute(103); cycles -= executedcycles; DiskUpdatePosition(executedcycles); JoyUpdatePosition(); } } if (cycle & 1) FillMemory(mem+0x2000,0x2000,0xAA); else CopyMemory(mem+0x2000,mem+((cycle & 2) ? 0x4000 : 0x6000),0x2000); VideoRefreshScreen(); if (cycle++ >= 3) cycle = 0; realisticfps++; } while (GetTickCount() - milliseconds < 1000); // DISPLAY THE RESULTS VideoDisplayLogo(); TCHAR outstr[256]; wsprintf(outstr, TEXT("Pure Video FPS:\t%u hires, %u text\n") TEXT("Pure CPU MHz:\t%u.%u%s\n\n") TEXT("EXPECTED AVERAGE VIDEO GAME\n") TEXT("PERFORMANCE: %u FPS"), (unsigned)totalhiresfps, (unsigned)totaltextfps, (unsigned)(totalmhz10/10), (unsigned)(totalmhz10 % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")), (unsigned)realisticfps); MessageBox(g_hFrameWindow, outstr, TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND); } //=========================================================================== BYTE VideoCheckMode (WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles) { address &= 0xFF; if (address == 0x7F) return MemReadFloatingBus(SW_DHIRES != 0, uExecutedCycles); else { BOOL result = 0; switch (address) { case 0x1A: result = SW_TEXT; break; case 0x1B: result = SW_MIXED; break; case 0x1D: result = SW_HIRES; break; case 0x1E: result = g_nAltCharSetOffset; break; case 0x1F: result = SW_80COL; break; case 0x7F: result = SW_DHIRES; break; } return KeybGetKeycode() | (result ? 0x80 : 0); } } //=========================================================================== // Check if we should call VideoRefreshScreen() based on unexpected page // - Only called from 2 places in main ContinueExecution() loop void VideoCheckPage(BOOL force) { const bool bUnexpectedPage = (g_bVideoDisplayPage2 != (SW_PAGE2 != 0)); //_ASSERT(!bUnexpectedPage); // [TC] Q: When does this happen? A: EG. When page-flipping && Scroll-Lock is pressed if (bUnexpectedPage && // Unexpected page && (force || (emulmsec-lastpageflip > 500))) // force || >500ms since last flip { g_bVideoDisplayPage2 = (SW_PAGE2 != 0); VideoRefreshScreen(); hasrefreshed = 1; lastpageflip = emulmsec; } } //=========================================================================== /* // Drol expects = 80 68DE A5 02 LDX #02 68E0 AD 50 C0 LDA TXTCLR 68E3 C9 80 CMP #80 68E5 D0 F7 BNE $68DE 6957 A5 02 LDX #02 6959 AD 50 C0 LDA TXTCLR 695C C9 80 CMP #80 695E D0 F7 BNE $68DE 69D3 A5 02 LDX #02 69D5 AD 50 C0 LDA TXTCLR 69D8 C9 80 CMP #80 69DA D0 F7 BNE $68DE // Karateka expects < 80 07DE AD 19 C0 LDA RDVBLBAR 07E1 30 FB BMI $7DE 77A1 AD 19 C0 LDA RDVBLBAR 77A4 30 FB BMI $7DE // Gumball expects non-zero low-nibble on VBL BBB5 A5 60 LDA $60 BBB7 4D 50 C0 EOR TXTCLR BBBA 85 60 STA $60 BBBC 29 0F AND #$0F BBBE F0 F5 BEQ $BBB5 BBC0 C9 0F CMP #$0F BBC2 F0 F1 BEQ $BBB5 // Diversi-Dial (DD4.DSK or DIAL.DSK) F822 LDA RDVBLBAR F825 EOR #$3C BMI $F82A RTS F82A LDA $F825+1 EOR #$80 STA $F825+1 BMI $F86A ... F86A RTS */ BYTE VideoCheckVbl (WORD, WORD, BYTE, BYTE, ULONG uExecutedCycles) { bool bVblBar = false; VideoGetScannerAddress(&bVblBar, uExecutedCycles); BYTE r = KeybGetKeycode(); return (r & ~0x80) | ((bVblBar) ? 0x80 : 0); } //=========================================================================== void VideoChooseColor () { CHOOSECOLOR cc; ZeroMemory(&cc,sizeof(CHOOSECOLOR)); cc.lStructSize = sizeof(CHOOSECOLOR); cc.hwndOwner = g_hFrameWindow; cc.rgbResult = monochrome; cc.lpCustColors = customcolors + 1; cc.Flags = CC_RGBINIT | CC_SOLIDCOLOR; if (ChooseColor(&cc)) { monochrome = cc.rgbResult; VideoReinitialize(); if ((g_nAppMode != MODE_LOGO) && (g_nAppMode != MODE_DEBUG)) { VideoRedrawScreen(); } Config_Save_Video(); } } //=========================================================================== void VideoDestroy () { // DESTROY BUFFERS VirtualFree(g_pFramebufferinfo,0,MEM_RELEASE); VirtualFree(g_pSourceHeader ,0,MEM_RELEASE); VirtualFree(vidlastmem ,0,MEM_RELEASE); g_pFramebufferinfo = NULL; g_pSourceHeader = NULL; vidlastmem = NULL; // DESTROY FRAME BUFFER DeleteDC(g_hDeviceDC); DeleteObject(g_hDeviceBitmap); g_hDeviceDC = (HDC)0; g_hDeviceBitmap = (HBITMAP)0; // DESTROY SOURCE IMAGE DeleteObject(g_hSourceBitmap); g_hSourceBitmap = (HBITMAP)0; // DESTROY LOGO if (g_hLogoBitmap) { DeleteObject(g_hLogoBitmap); g_hLogoBitmap = (HBITMAP)0; } // DESTROY PALETTE if (g_hPalette) { DeleteObject(g_hPalette); g_hPalette = (HPALETTE)0; } } //=========================================================================== void VideoDrawLogoBitmap(HDC hDstDC, int xoff, int yoff, int srcw, int srch, int scale) { HDC hSrcDC = CreateCompatibleDC( hDstDC ); SelectObject( hSrcDC, g_hLogoBitmap ); StretchBlt( hDstDC, // hdcDest xoff, yoff, // nXDest, nYDest scale * srcw, scale * srch, // nWidth, nHeight hSrcDC, // hdcSrc 0, 0, // nXSrc, nYSrc srcw, srch, SRCCOPY // dwRop ); DeleteObject( hSrcDC ); } //=========================================================================== void VideoDisplayLogo () { int xoff = 0, yoff = 0, scale = 0; HDC hFrameDC = FrameGetDC(); // DRAW THE LOGO HBRUSH brush = CreateSolidBrush(PALETTERGB(0x70,0x30,0xE0)); SelectObject(hFrameDC, brush); SelectObject(hFrameDC, GetStockObject(NULL_PEN)); int nViewportCX, nViewportCY; GetViewportCXCY(nViewportCX, nViewportCY); Rectangle(hFrameDC, 0, 0, nViewportCX+1, nViewportCY+1); if (g_hLogoBitmap) { BITMAP bm; if (GetObject(g_hLogoBitmap, sizeof(bm), &bm)) { scale = nViewportCX / bm.bmWidth; if (nViewportCY / bm.bmHeight < scale) scale = nViewportCY / bm.bmHeight; if (scale > 0) { if (nViewportCX > bm.bmWidth) xoff = (nViewportCX - (scale * bm.bmWidth)) / 2; if (nViewportCY > bm.bmHeight) yoff = (nViewportCY - (scale * bm.bmHeight)) / 2; VideoDrawLogoBitmap( hFrameDC, xoff, yoff, bm.bmWidth, bm.bmHeight, scale ); } } } // DRAW THE VERSION NUMBER HFONT font = CreateFont(-20,0,0,0,FW_NORMAL,0,0,0,ANSI_CHARSET, OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY, VARIABLE_PITCH | 4 | FF_SWISS, TEXT("Arial")); SelectObject(hFrameDC,font); SetTextAlign(hFrameDC,TA_RIGHT | TA_TOP); SetBkMode(hFrameDC,TRANSPARENT); char szVersion[ 64 ] = ""; sprintf( szVersion, "Version %s", VERSIONSTRING ); #define DRAWVERSION(x,y,c) \ SetTextColor(hFrameDC,c); \ TextOut(hFrameDC, \ scale*540+x+xoff,scale*358+y+yoff, \ szVersion, \ strlen(szVersion)); if (GetDeviceCaps(hFrameDC,PLANES) * GetDeviceCaps(hFrameDC,BITSPIXEL) <= 4) { DRAWVERSION( 2, 2,RGB(0x00,0x00,0x00)); DRAWVERSION( 1, 1,RGB(0x00,0x00,0x00)); DRAWVERSION( 0, 0,RGB(0xFF,0x00,0xFF)); } else { DRAWVERSION( 1, 1,PALETTERGB(0x30,0x30,0x70)); DRAWVERSION(-1,-1,PALETTERGB(0xC0,0x70,0xE0)); DRAWVERSION( 0, 0,PALETTERGB(0x70,0x30,0xE0)); } #if _DEBUG sprintf( szVersion, "DEBUG" ); DRAWVERSION( 2, -358*scale,RGB(0x00,0x00,0x00)); DRAWVERSION( 1, -357*scale,RGB(0x00,0x00,0x00)); DRAWVERSION( 0, -356*scale,RGB(0xFF,0x00,0xFF)); #endif #undef DRAWVERSION FrameReleaseDC(); DeleteObject(brush); DeleteObject(font); } //=========================================================================== BOOL VideoHasRefreshed () { BOOL result = hasrefreshed; hasrefreshed = 0; return result; } //=========================================================================== void VideoRealizePalette(HDC dc) { #if 0 if( g_bIsFullScreen ) { if( !g_pDDPal ) { PALETTEENTRY aPal[256]; BYTE *pSrc = ((BYTE*)g_pFramebufferinfo) + sizeof(BITMAPINFOHEADER); BYTE *pDst = ((BYTE*)aPal); int iPal; for(iPal = 0; iPal < 256; iPal++ ) { *(pDst + 0) = *(pSrc + 2); // BGR -> RGB *(pDst + 1) = *(pSrc + 1); *(pDst + 2) = *(pSrc + 0); *(pDst + 3) = 0; pDst += 4; pSrc += 4; } if (g_pDD->CreatePalette(DDPCAPS_8BIT, aPal, &g_pDDPal, NULL) != DD_OK) { g_pDDPal = NULL; } } if (g_pDDPal) { g_pDDPrimarySurface->SetPalette(g_pDDPal); // this sets the palette for the primary surface } } else { if (g_hPalette) { SelectPalette(dc,g_hPalette,0); RealizePalette(dc); } } #endif if (g_hPalette) { SelectPalette(dc,g_hPalette,0); RealizePalette(dc); } } //=========================================================================== // Called by DrawFrameWindow() when in fullscreen mode (eg. after WM_PAINT msg) VideoUpdateFuncPtr_t VideoRedrawScreen (UINT n) { g_VideoForceFullRedraw = n; return VideoRefreshScreen(); } VideoUpdateFuncPtr_t VideoRedrawScreen () { g_VideoForceFullRedraw = 1; return VideoRefreshScreen(); } //=========================================================================== void _Video_Dirty() { ZeroMemory(celldirty,40*32); } //=========================================================================== void _Video_SetupBanks( bool bBank2 ) { g_pHiresBank1 = MemGetAuxPtr (0x2000 << (int)bBank2); g_pHiresBank0 = MemGetMainPtr(0x2000 << (int)bBank2); g_pTextBank1 = MemGetAuxPtr (0x400 << (int)bBank2); g_pTextBank0 = MemGetMainPtr(0x400 << (int)bBank2); } //=========================================================================== // NB. Can get "big" 1000+ms times: these occur during disk loading when the emulator is at full-speed. //#define DEBUG_REFRESH_TIMINGS #if defined(_DEBUG) && defined(DEBUG_REFRESH_TIMINGS) static void DebugRefresh(char uDebugFlag) { static DWORD uLastRefreshTime = 0; const DWORD uTimeBetweenRefreshes = uLastRefreshTime ? emulmsec - uLastRefreshTime : 0; uLastRefreshTime = emulmsec; if (!uTimeBetweenRefreshes) return; // 1st time in func char szStr[100]; sprintf(szStr, "Time between refreshes = %d ms %c\n", uTimeBetweenRefreshes, (uDebugFlag==0)?' ':uDebugFlag); OutputDebugString(szStr); } #endif VideoUpdateFuncPtr_t VideoRefreshScreen () { #if defined(_DEBUG) && defined(DEBUG_REFRESH_TIMINGS) DebugRefresh(0); #endif // CHECK EACH CELL FOR CHANGED BYTES. REDRAW PIXELS FOR THE CHANGED BYTES // IN THE FRAME BUFFER. MARK CELLS IN WHICH REDRAWING HAS TAKEN PLACE AS // DIRTY. _Video_Dirty(); _Video_SetupBanks( g_bVideoDisplayPage2 ); VideoUpdateFuncPtr_t pfUpdate = SW_TEXT ? SW_80COL ? Update80ColCell : Update40ColCell : SW_HIRES ? (SW_DHIRES && SW_80COL) ? UpdateDHiResCell : UpdateHiResCell : (SW_DHIRES && SW_80COL) ? UpdateDLoResCell : UpdateLoResCell; bool bMixed = (SW_MIXED) ? true : false; _Video_RedrawScreen( pfUpdate, bMixed ); //g_VideoForceFullRedraw = 0; if (g_VideoForceFullRedraw) --g_VideoForceFullRedraw; return pfUpdate; } //=========================================================================== void _Video_RedrawScreen( VideoUpdateFuncPtr_t pfUpdate, bool bMixed ) { LPBYTE pDstFrameBufferBits = 0; LONG pitch = 0; HDC hFrameDC = FrameGetVideoDC(&pDstFrameBufferBits,&pitch); CreateFrameOffsetTable(pDstFrameBufferBits,pitch); // ptr to start of each scanline BOOL anydirty = 0; int y = 0; int ypixel = 0; while (y < 20) { int offset = ((y & 7) << 7) + ((y >> 3) * 40); int x = 0; int xpixel = 0; while (x < 40) { anydirty |= celldirty[x][y] = pfUpdate(x,y,xpixel,ypixel,offset+x); ++x; xpixel += 14; } ++y; ypixel += 16; } if( bMixed ) { pfUpdate = SW_80COL ? Update80ColCell : Update40ColCell; } while (y < 24) { int offset = ((y & 7) << 7) + ((y >> 3) * 40); int x = 0; int xpixel = 0; while (x < 40) { anydirty |= celldirty[x][y] = pfUpdate(x,y,xpixel,ypixel,offset+x); ++x; xpixel += 14; } ++y; ypixel += 16; } // Clear this flag after TEXT screen has been updated g_bTextFlashFlag = false; #if 1 // New simpified code: // . Oliver Schmidt gets a flickering mouse cursor with this code if (hFrameDC && anydirty) { int nViewportCX, nViewportCY; GetViewportCXCY(nViewportCX, nViewportCY); StretchBlt(hFrameDC, 0 ,0, nViewportCX, nViewportCY, g_hDeviceDC, 0, 0, FRAMEBUFFER_W, FRAMEBUFFER_H, SRCCOPY); GdiFlush(); } #else // Original code: if (!hFrameDC || !anydirty) { FrameReleaseVideoDC(); SetLastDrawnImage(); g_VideoForceFullRedraw = 0; return; } // COPY DIRTY CELLS FROM THE DEVICE DEPENDENT BITMAP ONTO THE SCREEN // IN LONG HORIZONTAL RECTANGLES BOOL remainingdirty = 0; y = 0; ypixel = 0; while (y < 24) { int start = -1; int startx = 0; int x = 0; int xpixel = 0; while (x < 40) { if ((x == 39) && celldirty[x][y]) if (start >= 0) { xpixel += 14; celldirty[x][y] = 0; } else remainingdirty = 1; if ((start >= 0) && !celldirty[x][y]) { if ((x - startx > 1) || ((x == 39) && (xpixel == FRAMEBUFFER_W))) { int height = 1; while ((y+height < 24) && celldirty[startx][y+height] && celldirty[x-1][y+height] && celldirty[(startx+x-1) >> 1][y+height]) height++; BitBlt(hFrameDC,start,ypixel,xpixel-start,height << 4, g_hDeviceDC,start,ypixel,SRCCOPY); while (height--) { int loop = startx; while (loop < x+(xpixel == FRAMEBUFFER_W)) celldirty[loop++][y+height] = 0; } start = -1; } else remainingdirty = 1; start = -1; } else if ((start == -1) && celldirty[x][y] && (x < 39)) { start = xpixel; startx = x; } x++; xpixel += 14; } y++; ypixel += 16; } // COPY ANY REMAINING DIRTY CELLS FROM THE DEVICE DEPENDENT BITMAP // ONTO THE SCREEN IN VERTICAL RECTANGLES if (remainingdirty) { int x = 0; int xpixel = 0; while (x < 40) { int start = -1; int y = 0; int ypixel = 0; while (y < 24) { if ((y == 23) && celldirty[x][y]) { if (start == -1) start = ypixel; ypixel += 16; celldirty[x][y] = 0; } if ((start >= 0) && !celldirty[x][y]) { BitBlt(hFrameDC,xpixel,start,14,ypixel-start, g_hDeviceDC,xpixel,start,SRCCOPY); start = -1; } else if ((start == -1) && celldirty[x][y]) start = ypixel; y++; ypixel += 16; } x++; xpixel += 14; } } GdiFlush(); #endif FrameReleaseVideoDC(); SetLastDrawnImage(); } //=========================================================================== void VideoReinitialize () { V_CreateIdentityPalette(); V_CreateDIBSections(); } //=========================================================================== void VideoResetState () { g_nAltCharSetOffset = 0; g_bVideoDisplayPage2 = 0; g_bVideoMode = VF_TEXT; g_VideoForceFullRedraw = 1; #if 0 // Debug HGR2 without having to exec 6502 code g_bVideoDisplayPage2 = 1; g_bVideoMode = VF_TEXT | VF_HIRES; #endif } //=========================================================================== BYTE VideoSetMode (WORD, WORD address, BYTE write, BYTE, ULONG uExecutedCycles) { address &= 0xFF; DWORD oldpage2 = SW_PAGE2; int oldvalue = g_nAltCharSetOffset+(int)(g_bVideoMode & ~(VF_MASK2 | VF_PAGE2)); switch (address) { case 0x00: g_bVideoMode &= ~VF_MASK2; break; case 0x01: g_bVideoMode |= VF_MASK2; break; case 0x0C: if (!IS_APPLE2) g_bVideoMode &= ~VF_80COL; break; case 0x0D: if (!IS_APPLE2) g_bVideoMode |= VF_80COL; break; case 0x0E: if (!IS_APPLE2) g_nAltCharSetOffset = 0; break; // Alternate char set off case 0x0F: if (!IS_APPLE2) g_nAltCharSetOffset = 256; break; // Alternate char set on case 0x50: g_bVideoMode &= ~VF_TEXT; break; case 0x51: g_bVideoMode |= VF_TEXT; break; case 0x52: g_bVideoMode &= ~VF_MIXED; break; case 0x53: g_bVideoMode |= VF_MIXED; break; case 0x54: g_bVideoMode &= ~VF_PAGE2; break; case 0x55: g_bVideoMode |= VF_PAGE2; break; case 0x56: g_bVideoMode &= ~VF_HIRES; break; case 0x57: g_bVideoMode |= VF_HIRES; break; case 0x5E: if (!IS_APPLE2) g_bVideoMode |= VF_DHIRES; break; case 0x5F: if (!IS_APPLE2) g_bVideoMode &= ~VF_DHIRES; break; } if (SW_MASK2) g_bVideoMode &= ~VF_PAGE2; if (oldvalue != g_nAltCharSetOffset+(int)(g_bVideoMode & ~(VF_MASK2 | VF_PAGE2))) { g_bGraphicsMode = !SW_TEXT; g_VideoForceFullRedraw = 1; } if (g_bFullSpeed && oldpage2 && !SW_PAGE2) { static DWORD lasttime = 0; DWORD currtime = GetTickCount(); if (currtime-lasttime >= 20) lasttime = currtime; else oldpage2 = SW_PAGE2; } if (oldpage2 != SW_PAGE2) { g_bVideoDisplayPage2 = (SW_PAGE2 != 0); if (!g_VideoForceFullRedraw) { #if 1 VideoRefreshScreen(); hasrefreshed = 1; #else g_VideoForceFullRedraw = 1; // GH#129,GH204: Defer the redraw until the main ContinueExecution() loop (TODO: What effect does this have on other games?) #endif } lastpageflip = emulmsec; } return MemReadFloatingBus(uExecutedCycles); } //=========================================================================== // Called at 60Hz (every 16.666ms) void VideoUpdateFlash() { static UINT nTextFlashCnt = 0; // Flash rate: // . NTSC : 60/16 ~= 4Hz // . PAL : 50/16 ~= 3Hz nTextFlashCnt = (nTextFlashCnt+1) & 0xf; // BUG: In unthrottled CPU mode, flash rate should not be affected if(nTextFlashCnt == 0) { g_bTextFlashState = !g_bTextFlashState; // Redraw any FLASHing chars if any text showing. NB. No FLASH g_nAppMode for 80 cols if ((SW_TEXT || SW_MIXED) ) // && !SW_80COL) // FIX: FLASH 80-Column g_bTextFlashFlag = true; } } //=========================================================================== bool VideoGetSW80COL() { return SW_80COL ? true : false; } //=========================================================================== DWORD VideoGetSnapshot(SS_IO_Video* pSS) { pSS->bAltCharSet = !(g_nAltCharSetOffset == 0); pSS->dwVidMode = g_bVideoMode; return 0; } //=========================================================================== DWORD VideoSetSnapshot(SS_IO_Video* pSS) { g_nAltCharSetOffset = !pSS->bAltCharSet ? 0 : 256; g_bVideoMode = pSS->dwVidMode; // g_bGraphicsMode = !SW_TEXT; g_bVideoDisplayPage2 = (SW_PAGE2 != 0); return 0; } //=========================================================================== // // References to Jim Sather's books are given as eg: // UTAIIe:5-7,P3 (Understanding the Apple IIe, chapter 5, page 7, Paragraph 3) // WORD VideoGetScannerAddress(bool* pbVblBar_OUT, const DWORD uExecutedCycles) { // get video scanner position // int nCycles = CpuGetCyclesThisVideoFrame(uExecutedCycles); // machine state switches // int nHires = (SW_HIRES && !SW_TEXT) ? 1 : 0; int nPage2 = (SW_PAGE2) ? 1 : 0; int n80Store = (MemGet80Store()) ? 1 : 0; // calculate video parameters according to display standard // int nScanLines = bVideoScannerNTSC ? kNTSCScanLines : kPALScanLines; int nVSyncLine = bVideoScannerNTSC ? kNTSCVSyncLine : kPALVSyncLine; int nScanCycles = nScanLines * kHClocks; // calculate horizontal scanning state // int nHClock = (nCycles + kHPEClock) % kHClocks; // which horizontal scanning clock int nHState = kHClock0State + nHClock; // H state bits if (nHClock >= kHPresetClock) // check for horizontal preset { nHState -= 1; // correct for state preset (two 0 states) } int h_0 = (nHState >> 0) & 1; // get horizontal state bits int h_1 = (nHState >> 1) & 1; int h_2 = (nHState >> 2) & 1; int h_3 = (nHState >> 3) & 1; int h_4 = (nHState >> 4) & 1; int h_5 = (nHState >> 5) & 1; // calculate vertical scanning state // int nVLine = nCycles / kHClocks; // which vertical scanning line int nVState = kVLine0State + nVLine; // V state bits if ((nVLine >= kVPresetLine)) // check for previous vertical state preset { nVState -= nScanLines; // compensate for preset } int v_A = (nVState >> 0) & 1; // get vertical state bits int v_B = (nVState >> 1) & 1; int v_C = (nVState >> 2) & 1; int v_0 = (nVState >> 3) & 1; int v_1 = (nVState >> 4) & 1; int v_2 = (nVState >> 5) & 1; int v_3 = (nVState >> 6) & 1; int v_4 = (nVState >> 7) & 1; int v_5 = (nVState >> 8) & 1; // calculate scanning memory address // if (nHires && SW_MIXED && v_4 && v_2) // HIRES TIME signal (UTAIIe:5-7,P3) { nHires = 0; // address is in text memory for mixed hires } int nAddend0 = 0x0D; // 1 1 0 1 int nAddend1 = (h_5 << 2) | (h_4 << 1) | (h_3 << 0); int nAddend2 = (v_4 << 3) | (v_3 << 2) | (v_4 << 1) | (v_3 << 0); int nSum = (nAddend0 + nAddend1 + nAddend2) & 0x0F; // SUM (UTAIIe:5-9) int nAddress = 0; // build address from video scanner equations (UTAIIe:5-8,T5.1) nAddress |= h_0 << 0; // a0 nAddress |= h_1 << 1; // a1 nAddress |= h_2 << 2; // a2 nAddress |= nSum << 3; // a3 - a6 nAddress |= v_0 << 7; // a7 nAddress |= v_1 << 8; // a8 nAddress |= v_2 << 9; // a9 int p2a = !(nPage2 && !n80Store); int p2b = nPage2 && !n80Store; if (nHires) // hires? { // Y: insert hires-only address bits // nAddress |= v_A << 10; // a10 nAddress |= v_B << 11; // a11 nAddress |= v_C << 12; // a12 nAddress |= p2a << 13; // a13 nAddress |= p2b << 14; // a14 } else { // N: insert text-only address bits // nAddress |= p2a << 10; // a10 nAddress |= p2b << 11; // a11 // Apple ][ (not //e) and HBL? // if (IS_APPLE2 && // Apple II only (UTAIIe:I-4,#5) !h_5 && (!h_4 || !h_3)) // HBL (UTAIIe:8-10,F8.5) { nAddress |= 1 << 12; // Y: a12 (add $1000 to address!) } } // update VBL' state // if (pbVblBar_OUT != NULL) { *pbVblBar_OUT = !v_4 || !v_3; // VBL' = (v_4 & v_3)' (UTAIIe:5-10,#3) } return static_cast(nAddress); } //=========================================================================== // Derived from VideoGetScannerAddress() bool VideoGetVbl(const DWORD uExecutedCycles) { // get video scanner position // int nCycles = CpuGetCyclesThisVideoFrame(uExecutedCycles); // calculate video parameters according to display standard // int nScanLines = bVideoScannerNTSC ? kNTSCScanLines : kPALScanLines; // calculate vertical scanning state // int nVLine = nCycles / kHClocks; // which vertical scanning line int nVState = kVLine0State + nVLine; // V state bits if ((nVLine >= kVPresetLine)) // check for previous vertical state preset { nVState -= nScanLines; // compensate for preset } int v_3 = (nVState >> 6) & 1; int v_4 = (nVState >> 7) & 1; // update VBL' state // if (v_4 & v_3) // VBL? { return false; // Y: VBL' is false } else { return true; // N: VBL' is true } } //=========================================================================== #define SCREENSHOT_BMP 1 #define SCREENSHOT_TGA 0 // alias for nSuffixScreenShotFileName static int g_nLastScreenShot = 0; const int nMaxScreenShot = 999999999; static int g_iScreenshotType; static char *g_pLastDiskImageName = NULL; //const int nMaxScreenShot = 2; //=========================================================================== void Video_ResetScreenshotCounter( char *pImageName ) { g_nLastScreenShot = 0; g_pLastDiskImageName = pImageName; } //=========================================================================== void Util_MakeScreenShotFileName( char *pFinalFileName_ ) { char sPrefixScreenShotFileName[ 256 ] = "AppleWin_ScreenShot"; // TODO: g_sScreenshotDir char *pPrefixFileName = g_pLastDiskImageName ? g_pLastDiskImageName : sPrefixScreenShotFileName; #if SCREENSHOT_BMP sprintf( pFinalFileName_, "%s_%09d.bmp", pPrefixFileName, g_nLastScreenShot ); #endif #if SCREENSHOT_TGA sprintf( pFinalFileName_, "%s%09d.tga", pPrefixFileName, g_nLastScreenShot ); #endif } // Returns TRUE if file exists, else FALSE //=========================================================================== bool Util_TestScreenShotFileName( const char *pFileName ) { bool bFileExists = false; FILE *pFile = fopen( pFileName, "rt" ); if (pFile) { fclose( pFile ); bFileExists = true; } return bFileExists; } //=========================================================================== void Video_TakeScreenShot( int iScreenShotType ) { char sScreenShotFileName[ MAX_PATH ]; g_iScreenshotType = iScreenShotType; // find last screenshot filename so we don't overwrite the existing user ones bool bExists = true; while( bExists ) { if (g_nLastScreenShot > nMaxScreenShot) // Holy Crap! User has maxed the number of screenshots!? { sprintf( sScreenShotFileName, "You have more then %d screenshot filenames! They will no longer be saved.\n\nEither move some of your screenshots or increase the maximum in video.cpp\n", nMaxScreenShot ); MessageBox( g_hFrameWindow, sScreenShotFileName, "Warning", MB_OK ); g_nLastScreenShot = 0; return; } Util_MakeScreenShotFileName( sScreenShotFileName ); bExists = Util_TestScreenShotFileName( sScreenShotFileName ); if( !bExists ) { break; } g_nLastScreenShot++; } Video_SaveScreenShot( sScreenShotFileName ); g_nLastScreenShot++; } typedef char int8; typedef short int16; typedef int int32; typedef unsigned char u8; typedef signed short s16; /// turn of MSVC struct member padding #pragma pack(push,1) struct bgra_t { u8 b; u8 g; u8 r; u8 a; // reserved on Win32 }; struct WinBmpHeader_t { // BITMAPFILEHEADER // Addr Size char nCookie[2] ; // 0x00 0x02 BM int32 nSizeFile ; // 0x02 0x04 0 = ignore int16 nReserved1 ; // 0x06 0x02 int16 nReserved2 ; // 0x08 0x02 int32 nOffsetData ; // 0x0A 0x04 // == 0x0D (14) // BITMAPINFOHEADER int32 nStructSize ; // 0x0E 0x04 biSize int32 nWidthPixels ; // 0x12 0x04 biWidth int32 nHeightPixels ; // 0x16 0x04 biHeight int16 nPlanes ; // 0x1A 0x02 biPlanes int16 nBitsPerPixel ; // 0x1C 0x02 biBitCount int32 nCompression ; // 0x1E 0x04 biCompression 0 = BI_RGB int32 nSizeImage ; // 0x22 0x04 0 = ignore int32 nXPelsPerMeter ; // 0x26 0x04 int32 nYPelsPerMeter ; // 0x2A 0x04 int32 nPaletteColors ; // 0x2E 0x04 int32 nImportantColors; // 0x32 0x04 // == 0x28 (40) // RGBQUAD // pixelmap }; #pragma pack(pop) WinBmpHeader_t g_tBmpHeader; #if SCREENSHOT_TGA enum TargaImageType_e { TARGA_RGB = 2 }; struct TargaHeader_t { // Addr Bytes u8 nIdBytes ; // 00 01 size of ID field that follows 18 byte header (0 usually) u8 bHasPalette ; // 01 01 u8 iImageType ; // 02 01 type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed s16 iPaletteFirstColor ; // 03 02 s16 nPaletteColors ; // 05 02 u8 nPaletteBitsPerEntry ; // 07 01 number of bits per palette entry 15,16,24,32 s16 nOriginX ; // 08 02 image x origin s16 nOriginY ; // 0A 02 image y origin s16 nWidthPixels ; // 0C 02 s16 nHeightPixels ; // 0E 02 u8 nBitsPerPixel ; // 10 01 image bits per pixel 8,16,24,32 u8 iDescriptor ; // 11 01 image descriptor bits (vh flip bits) // pixel data... u8 aPixelData[1] ; // rgb }; TargaHeader_t g_tTargaHeader; #endif // SCREENSHOT_TGA //=========================================================================== void Video_MakeScreenShot(FILE *pFile) { #if SCREENSHOT_BMP g_tBmpHeader.nCookie[ 0 ] = 'B'; // 0x42 g_tBmpHeader.nCookie[ 1 ] = 'M'; // 0x4d g_tBmpHeader.nSizeFile = 0; g_tBmpHeader.nReserved1 = 0; g_tBmpHeader.nReserved2 = 0; g_tBmpHeader.nOffsetData = sizeof(WinBmpHeader_t) + (256 * sizeof(bgra_t)); g_tBmpHeader.nStructSize = 0x28; // sizeof( WinBmpHeader_t ); g_tBmpHeader.nWidthPixels = g_iScreenshotType ? FRAMEBUFFER_W/2 :FRAMEBUFFER_W; g_tBmpHeader.nHeightPixels = g_iScreenshotType ? FRAMEBUFFER_H/2 : FRAMEBUFFER_H; g_tBmpHeader.nPlanes = 1; g_tBmpHeader.nBitsPerPixel = 8; g_tBmpHeader.nCompression = BI_RGB; g_tBmpHeader.nSizeImage = 0; g_tBmpHeader.nXPelsPerMeter = 0; g_tBmpHeader.nYPelsPerMeter = 0; g_tBmpHeader.nPaletteColors = 256; g_tBmpHeader.nImportantColors = 0; // char sText[256]; // sprintf( sText, "sizeof: BITMAPFILEHEADER = %d\n", sizeof(BITMAPFILEHEADER) ); // = 14 // MessageBox( g_hFrameWindow, sText, "Info 1", MB_OK ); // sprintf( sText, "sizeof: BITMAPINFOHEADER = %d\n", sizeof(BITMAPINFOHEADER) ); // = 40 // MessageBox( g_hFrameWindow, sText, "Info 2", MB_OK ); char sIfSizeZeroOrUnknown_BadWinBmpHeaderPackingSize[ sizeof( WinBmpHeader_t ) == (14 + 40) ]; sIfSizeZeroOrUnknown_BadWinBmpHeaderPackingSize; // Write Header int nLen; fwrite( &g_tBmpHeader, sizeof( g_tBmpHeader ), 1, pFile ); // Write Palette Data u8 *pSrc = ((u8*)g_pFramebufferinfo) + sizeof(BITMAPINFOHEADER); nLen = g_tBmpHeader.nPaletteColors * sizeof(bgra_t); // RGBQUAD fwrite( pSrc, nLen, 1, pFile ); pSrc += nLen; // Write Pixel Data // No need to use GetDibBits() since we already have http://msdn.microsoft.com/en-us/library/ms532334.aspx // @reference: "Storing an Image" http://msdn.microsoft.com/en-us/library/ms532340(VS.85).aspx pSrc = ((u8*)g_pFramebufferbits); nLen = g_tBmpHeader.nWidthPixels * g_tBmpHeader.nHeightPixels * g_tBmpHeader.nBitsPerPixel / 8; if( g_iScreenshotType == SCREENSHOT_280x192 ) { pSrc += FRAMEBUFFER_W; // Start on odd scanline (otherwise for 50% scanline mode get an all black image!) u8 aScanLine[ 280 ]; u8 *pDst; // 50% Half Scan Line clears every odd scanline. // SHIFT+PrintScreen saves only the even rows. // NOTE: Keep in sync with _Video_RedrawScreen() & Video_MakeScreenShot() for( int y = 0; y < FRAMEBUFFER_H/2; y++ ) { pDst = aScanLine; for( int x = 0; x < FRAMEBUFFER_W/2; x++ ) { *pDst++ = pSrc[1]; // correction for left edge loss of scaled scanline [Bill Buckel, B#18928] pSrc += 2; // skip odd pixels } fwrite( aScanLine, FRAMEBUFFER_W/2, 1, pFile ); pSrc += FRAMEBUFFER_W; // scan lines doubled - skip odd ones } } else { fwrite( pSrc, nLen, 1, pFile ); } #endif // SCREENSHOT_BMP #if SCREENSHOT_TGA TargaHeader_t *pHeader = &g_tTargaHeader; memset( (void*)pHeader, 0, sizeof( TargaHeader_t ) ); pHeader->iImageType = TARGA_RGB; pHeader->nWidthPixels = FRAMEBUFFER_W; pHeader->nHeightPixels = FRAMEBUFFER_H; pHeader->nBitsPerPixel = 24; #endif // SCREENSHOT_TGA } //=========================================================================== void Video_SaveScreenShot( const char *pScreenShotFileName ) { FILE *pFile = fopen( pScreenShotFileName, "wb" ); if( pFile ) { Video_MakeScreenShot( pFile ); fclose( pFile ); } if( g_bDisplayPrintScreenFileName ) { MessageBox( g_hFrameWindow, pScreenShotFileName, "Screen Captured", MB_OK ); } } //=========================================================================== void Config_Load_Video() { REGLOAD(TEXT(REGVALUE_VIDEO_MODE ),&g_eVideoType); REGLOAD(TEXT(REGVALUE_VIDEO_HALF_SCAN_LINES),&g_uHalfScanLines); REGLOAD(TEXT(REGVALUE_VIDEO_MONO_COLOR ),&monochrome); if (g_eVideoType >= NUM_VIDEO_MODES) g_eVideoType = VT_COLOR_STANDARD; // Old default: VT_COLOR_TVEMU } void Config_Save_Video() { REGSAVE(TEXT(REGVALUE_VIDEO_MODE ),g_eVideoType); REGSAVE(TEXT(REGVALUE_VIDEO_HALF_SCAN_LINES),g_uHalfScanLines); REGSAVE(TEXT(REGVALUE_VIDEO_MONO_COLOR ),monochrome); }