{

// RESET THE VIDEO MODE SWITCHES AND THE CHARACTER SET OFFSET

VideoResetState();

// LOAD THE LOGO

g_hLogoBitmap = LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_APPLEWIN) );

// 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 = GetFrameBufferWidth();

g_pFramebufferinfo->bmiHeader.biHeight = GetFrameBufferHeight();

g_pFramebufferinfo->bmiHeader.biPlanes = 1;

g_pFramebufferinfo->bmiHeader.biBitCount = 32;

g_pFramebufferinfo->bmiHeader.biCompression = BI_RGB;

g_pFramebufferinfo->bmiHeader.biClrUsed = 0;

videoCreateDIBSection();

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_uVideoMode = 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_uVideoMode = 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

DWORD totalmhz10[2] = {0,0}; // bVideoUpdate & !bVideoUpdate

for (UINT i=0; i<2; i++)

{

CpuSetupBenchmark();

milliseconds = GetTickCount();

while (GetTickCount() == milliseconds) ;

milliseconds = GetTickCount();

do {

CpuExecute(100000, i==0 ? true : false);

totalmhz10[i]++;

} 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, true);

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, true);

cycles -= executedcycles;

sg_Disk2Card.UpdateDriveState(executedcycles);

JoyUpdateButtonLatch(executedcycles);

}

}

if (cycle & 1)

FillMemory(mem+0x2000,0x2000,0xAA);

else

CopyMemory(mem+0x2000,mem+((cycle & 2) ? 0x4000 : 0x6000),0x2000);

VideoRedrawScreen();

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 (video update)\n")

TEXT("Pure CPU MHz:\t%u.%u%s (full-speed)\n\n")

TEXT("EXPECTED AVERAGE VIDEO GAME\n")

TEXT("PERFORMANCE: %u FPS"),

(unsigned)totalhiresfps,

(unsigned)totaltextfps,

(unsigned)(totalmhz10[0] / 10), (unsigned)(totalmhz10[0] % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")),

(unsigned)(totalmhz10[1] / 10), (unsigned)(totalmhz10[1] % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")),

(unsigned)realisticfps);

MessageBox(g_hFrameWindow,

outstr,

TEXT("Benchmarks"),

MB_ICONINFORMATION | MB_SETFOREGROUND);

{

CHOOSECOLOR cc;

ZeroMemory(&cc,sizeof(CHOOSECOLOR));

cc.lStructSize = sizeof(CHOOSECOLOR);

cc.hwndOwner = g_hFrameWindow;

cc.rgbResult = g_nMonochromeRGB;

cc.lpCustColors = customcolors + 1;

cc.Flags = CC_RGBINIT | CC_SOLIDCOLOR;

if (ChooseColor(&cc))

{

g_nMonochromeRGB = cc.rgbResult;

VideoReinitialize();

if ((g_nAppMode != MODE_LOGO) && (g_nAppMode != MODE_DEBUG))

{

VideoRedrawScreen();

}

Config_Save_Video();

}

// DESTROY BUFFERS

VirtualFree(g_pFramebufferinfo,0,MEM_RELEASE);

g_pFramebufferinfo = NULL;

// DESTROY FRAME BUFFER

DeleteDC(g_hDeviceDC);

DeleteObject(g_hDeviceBitmap);

g_hDeviceDC = (HDC)0;

g_hDeviceBitmap = (HBITMAP)0;

// DESTROY LOGO

if (g_hLogoBitmap) {

DeleteObject(g_hLogoBitmap);

g_hLogoBitmap = (HBITMAP)0;

}

{

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 );

{

int nLogoX = 0, nLogoY = 0;

int scale = GetViewportScale();

HDC hFrameDC = FrameGetDC();

// DRAW THE LOGO

SelectObject(hFrameDC, GetStockObject(NULL_PEN));

if (g_hLogoBitmap)

{

BITMAP bm;

if (GetObject(g_hLogoBitmap, sizeof(bm), &bm))

{

nLogoX = (g_nViewportCX - scale*bm.bmWidth )/2;

nLogoY = (g_nViewportCY - scale*bm.bmHeight)/2;

if( IsFullScreen() )

{

nLogoX += GetFullScreenOffsetX();

nLogoY += GetFullScreenOffsetY();

}

VideoDrawLogoBitmap( hFrameDC, nLogoX, nLogoY, bm.bmWidth, bm.bmHeight, scale );

}

}

// DRAW THE VERSION NUMBER

TCHAR sFontName[] = TEXT("Arial");

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,

sFontName );

SelectObject(hFrameDC,font);

SetTextAlign(hFrameDC,TA_RIGHT | TA_TOP);

SetBkMode(hFrameDC,TRANSPARENT);

char szVersion[ 64 ] = "";

sprintf( szVersion, "Version %s", VERSIONSTRING );

int xoff = GetFullScreenOffsetX(), yoff = GetFullScreenOffsetY();

#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

DeleteObject(font);

{

static DWORD dwFullSpeedStartTime = 0;

if (bInit)

{

// Just entered full-speed mode

dwFullSpeedStartTime = GetTickCount();

return;

}

DWORD dwFullSpeedDuration = GetTickCount() - dwFullSpeedStartTime;

if (dwFullSpeedDuration <= 16) // Only update after every realtime ~17ms of *continuous* full-speed

return;

dwFullSpeedStartTime += dwFullSpeedDuration;

//

#if 0

static BYTE text_main[1024*2] = {0}; // page1 & 2

static BYTE text_aux[1024*2] = {0}; // page1 & 2

static BYTE hgr_main[8192*2] = {0}; // page1 & 2

static BYTE hgr_aux[8192*2] = {0}; // page1 & 2

bool bRedraw = true; // Always redraw for bValid==false (ie. just entered full-speed mode)

if (bValid)

{

if ((g_uVideoMode&(VF_DHIRES|VF_HIRES|VF_TEXT|VF_MIXED)) == VF_HIRES)

{

// HIRES (not MIXED) - eg. AZTEC.DSK

if ((g_uVideoMode&VF_PAGE2) == 0)

bRedraw = memcmp(&hgr_main[0x0000], MemGetMainPtr(0x2000), 8192) != 0;

else

bRedraw = memcmp(&hgr_main[0x2000], MemGetMainPtr(0x4000), 8192) != 0;

}

else

{

bRedraw =

(memcmp(text_main, MemGetMainPtr(0x400), sizeof(text_main)) != 0) ||

(memcmp(text_aux, MemGetAuxPtr(0x400), sizeof(text_aux)) != 0) ||

(memcmp(hgr_main, MemGetMainPtr(0x2000), sizeof(hgr_main)) != 0) ||

(memcmp(hgr_aux, MemGetAuxPtr(0x2000), sizeof(hgr_aux)) != 0);

}

}

if (bRedraw)

VideoRedrawScreenAfterFullSpeed(dwCyclesThisFrame);

// Copy all video memory (+ screen holes)

memcpy(text_main, MemGetMainPtr(0x400), sizeof(text_main));

memcpy(text_aux, MemGetAuxPtr(0x400), sizeof(text_aux));

memcpy(hgr_main, MemGetMainPtr(0x2000), sizeof(hgr_main));

memcpy(hgr_aux, MemGetAuxPtr(0x2000), sizeof(hgr_aux));

bValid = true;

#else

VideoRedrawScreenAfterFullSpeed(dwCyclesThisFrame);

#endif

{

if (g_bVideoScannerNTSC)

{

NTSC_VideoClockResync(dwCyclesThisFrame);

}

else // PAL

{

_ASSERT(0);

g_nVideoClockVert = (uint16_t) (dwCyclesThisFrame / kHClocks) % kPALScanLines;

g_nVideoClockHorz = (uint16_t) (dwCyclesThisFrame % kHClocks);

}

VideoRedrawScreen(); // Better (no flicker) than using: NTSC_VideoReinitialize() or VideoReinitialize()

{

// NB. Can't rely on g_uVideoMode being non-zero (ie. so it can double up as a flag) since 'GR,PAGE1,non-mixed' mode == 0x00.

VideoRefreshScreen( g_uVideoMode, true );

{

int dx=0, dy=0;

if (g_eVideoType == VT_MONO_TV || g_eVideoType == VT_COLOR_TV)

{

// Adjust the src locations for the NTSC video modes

dy = -1;

}

if (bInvertY)

dy =- dy;

xSrc += dx;

ySrc += dy;

{

if (bRedrawWholeScreen || g_nAppMode == MODE_PAUSED)

{

// uVideoModeForWholeScreen set if:

// . MODE_DEBUG : always

// . MODE_RUNNING : called from VideoRedrawScreen(), eg. during full-speed

if (bRedrawWholeScreen)

NTSC_SetVideoMode( uRedrawWholeScreenVideoMode );

NTSC_VideoRedrawWholeScreen();

}

HDC hFrameDC = FrameGetDC();

if (hFrameDC)

{

int xSrc = GetFrameBufferBorderWidth();

int ySrc = GetFrameBufferBorderHeight();

VideoFrameBufferAdjust(xSrc, ySrc); // TC: Hacky-fix for GH#341

int xdest = IsFullScreen() ? GetFullScreenOffsetX() : 0;

int ydest = IsFullScreen() ? GetFullScreenOffsetY() : 0;

int wdest = g_nViewportCX;

int hdest = g_nViewportCY;

SetStretchBltMode(hFrameDC, COLORONCOLOR);

StretchBlt(

hFrameDC,

xdest, ydest,

wdest, hdest,

g_hDeviceDC,

xSrc, ySrc,

GetFrameBufferBorderlessWidth(), GetFrameBufferBorderlessHeight(),

SRCCOPY);

}

GdiFlush();

{

NTSC_VideoReinitialize( g_dwCyclesThisFrame, bInitVideoScannerAddress );

NTSC_VideoInitAppleType();

NTSC_SetVideoStyle();

NTSC_SetVideoTextMode( g_uVideoMode & VF_80COL ? 80 : 40 );

NTSC_SetVideoMode( g_uVideoMode ); // Pre-condition: g_nVideoClockHorz (derived from g_dwCyclesThisFrame)

{

g_nAltCharSetOffset = 0;

g_uVideoMode = VF_TEXT;

NTSC_SetVideoTextMode( 40 );

NTSC_SetVideoMode( g_uVideoMode );

RGB_ResetState();

{

address &= 0xFF;

switch (address)

{

case 0x00: g_uVideoMode &= ~VF_80STORE; break;

case 0x01: g_uVideoMode |= VF_80STORE; break;

case 0x0C: if (!IS_APPLE2){g_uVideoMode &= ~VF_80COL; NTSC_SetVideoTextMode(40);}; break;

case 0x0D: if (!IS_APPLE2){g_uVideoMode |= VF_80COL; NTSC_SetVideoTextMode(80);}; 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_uVideoMode &= ~VF_TEXT; break;

case 0x51: g_uVideoMode |= VF_TEXT; break;

case 0x52: g_uVideoMode &= ~VF_MIXED; break;

case 0x53: g_uVideoMode |= VF_MIXED; break;

case 0x54: g_uVideoMode &= ~VF_PAGE2; break;

case 0x55: g_uVideoMode |= VF_PAGE2; break;

case 0x56: g_uVideoMode &= ~VF_HIRES; break;

case 0x57: g_uVideoMode |= VF_HIRES; break;

case 0x5E: if (!IS_APPLE2) g_uVideoMode |= VF_DHIRES; break;

case 0x5F: if (!IS_APPLE2) g_uVideoMode &= ~VF_DHIRES; break;

}

if (!IS_APPLE2)

RGB_SetVideoMode(address);

NTSC_SetVideoMode( g_uVideoMode );

return MemReadFloatingBus(uExecutedCycles);

{

static const std::string name("Video");

return name;

{

YamlSaveHelper::Label state(yamlSaveHelper, "%s:\n", VideoGetSnapshotStructName().c_str());

yamlSaveHelper.SaveBool(SS_YAML_KEY_ALTCHARSET, g_nAltCharSetOffset ? true : false);

yamlSaveHelper.SaveHexUint32(SS_YAML_KEY_VIDEOMODE, g_uVideoMode);

yamlSaveHelper.SaveUint(SS_YAML_KEY_CYCLESTHISFRAME, g_dwCyclesThisFrame);

{

if (!yamlLoadHelper.GetSubMap(VideoGetSnapshotStructName()))

return;

g_nAltCharSetOffset = yamlLoadHelper.LoadBool(SS_YAML_KEY_ALTCHARSET) ? 256 : 0;

g_uVideoMode = yamlLoadHelper.LoadUint(SS_YAML_KEY_VIDEOMODE);

g_dwCyclesThisFrame = yamlLoadHelper.LoadUint(SS_YAML_KEY_CYCLESTHISFRAME);

yamlLoadHelper.PopMap();

{

// machine state switches

//

bool bHires = VideoGetSWHIRES() && !VideoGetSWTEXT();

bool bPage2 = VideoGetSWPAGE2();

bool b80Store = VideoGetSW80STORE();

// calculate video parameters according to display standard

//

const int kScanLines = g_bVideoScannerNTSC ? kNTSCScanLines : kPALScanLines;

const int kScanCycles = kScanLines * kHClocks;

_ASSERT(nCycles < kScanCycles);

nCycles %= kScanCycles;

// 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 -= kScanLines; // 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 (bHires && SW_MIXED && v_4 && v_2) // HIRES TIME signal (UTAIIe:5-7,P3)

{

bHires = false; // 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)

WORD nAddressH = 0; // build address from video scanner equations (UTAIIe:5-8,T5.1)

nAddressH |= h_0 << 0; // a0

nAddressH |= h_1 << 1; // a1

nAddressH |= h_2 << 2; // a2

nAddressH |= nSum << 3; // a3 - a6

if (!bHires)

{

// 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)

{

nAddressH |= 1 << 12; // Y: a12 (add $1000 to address!)

}

}

WORD nAddressV = 0;

nAddressV |= v_0 << 7; // a7

nAddressV |= v_1 << 8; // a8

nAddressV |= v_2 << 9; // a9

int p2a = !(bPage2 && !b80Store) ? 1 : 0;

int p2b = (bPage2 && !b80Store) ? 1 : 0;

WORD nAddressP = 0; // Page bits

if (bHires) // hires?

{

// Y: insert hires-only address bits

//

nAddressV |= v_A << 10; // a10

nAddressV |= v_B << 11; // a11

nAddressV |= v_C << 12; // a12

nAddressP |= p2a << 13; // a13

nAddressP |= p2b << 14; // a14

}

else

{

// N: insert text-only address bits

//

nAddressP |= p2a << 10; // a10

nAddressP |= p2b << 11; // a11

}

// VBL' = v_4' | v_3' = (v_4 & v_3)' (UTAIIe:5-10,#3)

if (videoScannerAddr == VS_PartialAddrH)

return nAddressH;

if (videoScannerAddr == VS_PartialAddrV)

return nAddressV;

return nAddressP | nAddressV | nAddressH;

{

// get video scanner position

int nCycles = CpuGetCyclesThisVideoFrame(uExecutedCycles);

// calculate video parameters according to display standard

const int kScanLines = g_bVideoScannerNTSC ? kNTSCScanLines : kPALScanLines;

const int kScanCycles = kScanLines * kHClocks;

nCycles %= kScanCycles;

// VBL'

return nCycles < kVDisplayableScanLines * kHClocks;

{

g_nLastScreenShot = 0;

g_pLastDiskImageName = pImageName;

{

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

{

bool bFileExists = false;

FILE *pFile = fopen( pFileName, "rt" );

if (pFile)

{

fclose( pFile );

bFileExists = true;

}

return bFileExists;

{

char sScreenShotFileName[ MAX_PATH ];

// 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( ScreenShotType, sScreenShotFileName );

g_nLastScreenShot++;

{

_ASSERT(pScreenshotFilename);

if (!pScreenshotFilename)

return;

VideoRedrawScreen();

Video_SaveScreenShot( SCREENSHOT_560x384, pScreenshotFilename );

{ // 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)