/**
* TODO
*/
void NEXTMemory_MemorySnapShot_Capture(bool bSave)
{
MemorySnapShot_Store(&NEXTRamEnd, sizeof(NEXTRamEnd));
/* Only save/restore area of memory machine is set to, eg 1Mb */
MemorySnapShot_Store(NEXTRam, NEXTRamEnd);
}
/**
* Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
*/
void Floppy_MemorySnapShot_Capture(bool bSave)
{
int i;
/* If restoring then eject old drives first! */
if (!bSave)
Floppy_EjectBothDrives();
/* Save/Restore details */
for (i = 0; i < MAX_FLOPPYDRIVES; i++)
{
MemorySnapShot_Store(&EmulationDrives[i].bDiskInserted, sizeof(EmulationDrives[i].bDiskInserted));
MemorySnapShot_Store(&EmulationDrives[i].nImageBytes, sizeof(EmulationDrives[i].nImageBytes));
if (!bSave && EmulationDrives[i].bDiskInserted)
{
EmulationDrives[i].pBuffer = malloc(EmulationDrives[i].nImageBytes);
if (!EmulationDrives[i].pBuffer)
perror("Floppy_MemorySnapShot_Capture");
}
if (EmulationDrives[i].pBuffer)
MemorySnapShot_Store(EmulationDrives[i].pBuffer, EmulationDrives[i].nImageBytes);
MemorySnapShot_Store(EmulationDrives[i].sFileName, sizeof(EmulationDrives[i].sFileName));
MemorySnapShot_Store(&EmulationDrives[i].bContentsChanged,sizeof(EmulationDrives[i].bContentsChanged));
MemorySnapShot_Store(&EmulationDrives[i].bOKToSave,sizeof(EmulationDrives[i].bOKToSave));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState1,sizeof(EmulationDrives[i].TransitionState1));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState1_VBL,sizeof(EmulationDrives[i].TransitionState1_VBL));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState2,sizeof(EmulationDrives[i].TransitionState2));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState2_VBL,sizeof(EmulationDrives[i].TransitionState2_VBL));
}
}
/**
* Save/Restore snapshot of local variables ('MemorySnapShot_Store' handles type)
*/
void PSG_MemorySnapShot_Capture(bool bSave)
{
/* Save/Restore details */
MemorySnapShot_Store(&PSGRegisterSelect, sizeof(PSGRegisterSelect));
MemorySnapShot_Store(&PSGRegisterReadData, sizeof(PSGRegisterReadData));
MemorySnapShot_Store(PSGRegisters, sizeof(PSGRegisters));
MemorySnapShot_Store(&LastStrobe, sizeof(LastStrobe));
}
/**
* Save/Restore snapshot of local variables ('MemorySnapShot_Store' handles type)
*/
void Cycles_MemorySnapShot_Capture(bool bSave)
{
/* Save/Restore details */
MemorySnapShot_Store(&nCyclesMainCounter, sizeof(nCyclesMainCounter));
MemorySnapShot_Store(nCyclesCounter, sizeof(nCyclesCounter));
MemorySnapShot_Store(&CyclesGlobalClockCounter, sizeof(CyclesGlobalClockCounter));
MemorySnapShot_Store(&CurrentInstrCycles, sizeof(CurrentInstrCycles));
}
/**
* Open/Create snapshot file, and set flag so 'MemorySnapShot_Store' knows
* how to handle data.
*/
static bool MemorySnapShot_OpenFile(const char *pszFileName, bool bSave)
{
char VersionString[] = VERSION_STRING;
/* Set error */
bCaptureError = false;
/* after opening file, set bCaptureSave to indicate whether
* 'MemorySnapShot_Store' should load from or save to a file
*/
if (bSave)
{
if (!File_QueryOverwrite(pszFileName))
return false;
/* Save */
CaptureFile = MemorySnapShot_fopen(pszFileName, "wb");
if (!CaptureFile)
{
fprintf(stderr, "Failed to open save file '%s': %s\n",
pszFileName, strerror(errno));
bCaptureError = true;
return false;
}
bCaptureSave = true;
/* Store version string */
MemorySnapShot_Store(VersionString, sizeof(VersionString));
}
else
{
/* Restore */
CaptureFile = MemorySnapShot_fopen(pszFileName, "rb");
if (!CaptureFile)
{
fprintf(stderr, "Failed to open file '%s': %s\n",
pszFileName, strerror(errno));
bCaptureError = true;
return false;
}
bCaptureSave = false;
/* Restore version string */
MemorySnapShot_Store(VersionString, sizeof(VersionString));
/* Does match current version? */
if (strcasecmp(VersionString, VERSION_STRING))
{
/* No, inform user and error */
Log_AlertDlg(LOG_ERROR, "Unable to restore Hatari memory state. File\n"
"is compatible only with Hatari version %s.",
VersionString);
bCaptureError = true;
return false;
}
}
/* All OK */
return true;
}
/**
* Save/Restore snapshot of RAM / ROM variables
* ('MemorySnapShot_Store' handles type)
*/
void STMemory_MemorySnapShot_Capture(bool bSave)
{
MemorySnapShot_Store(&STRamEnd, sizeof(STRamEnd));
/* Only save/restore area of memory machine is set to, eg 1Mb */
MemorySnapShot_Store(STRam, STRamEnd);
/* And Cart/TOS/Hardware area */
MemorySnapShot_Store(&RomMem[0xE00000], 0x200000);
}
/**
* Save/Restore snapshot of CPU variables ('MemorySnapShot_Store' handles type)
*/
void DSP_MemorySnapShot_Capture(bool bSave)
{
#if ENABLE_DSP_EMU
if (!bSave)
DSP_Reset();
MemorySnapShot_Store(&bDspEnabled, sizeof(bDspEnabled));
MemorySnapShot_Store(&dsp_core, sizeof(dsp_core));
MemorySnapShot_Store(&save_cycles, sizeof(save_cycles));
#endif
}
/**
* Save/Restore snapshot of local variables ('MemorySnapShot_Store' handles type)
*/
void DmaSnd_MemorySnapShot_Capture(bool bSave)
{
/* Save/Restore details */
MemorySnapShot_Store(&nDmaSoundControl, sizeof(nDmaSoundControl));
MemorySnapShot_Store(&nDmaSoundMode, sizeof(nDmaSoundMode));
MemorySnapShot_Store(&nFrameStartAddr, sizeof(nFrameStartAddr));
MemorySnapShot_Store(&nFrameEndAddr, sizeof(nFrameEndAddr));
MemorySnapShot_Store(&FrameCounter, sizeof(FrameCounter));
MemorySnapShot_Store(&nFrameLen, sizeof(nFrameLen));
MemorySnapShot_Store(&nMicrowireData, sizeof(nMicrowireData));
MemorySnapShot_Store(&nMicrowireMask, sizeof(nMicrowireMask));
MemorySnapShot_Store(&nMwTransferSteps, sizeof(nMwTransferSteps));
}
/**
* Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
*/
void CycInt_MemorySnapShot_Capture(bool bSave)
{
int i,ID;
/* Save/Restore details */
for (i=0; i<MAX_INTERRUPTS; i++)
{
MemorySnapShot_Store(&InterruptHandlers[i].bUsed, sizeof(InterruptHandlers[i].bUsed));
MemorySnapShot_Store(&InterruptHandlers[i].Cycles, sizeof(InterruptHandlers[i].Cycles));
if (bSave)
{
/* Convert function to ID */
ID = CycInt_HandlerFunctionToID(InterruptHandlers[i].pFunction);
MemorySnapShot_Store(&ID, sizeof(int));
}
else
{
/* Convert ID to function */
MemorySnapShot_Store(&ID, sizeof(int));
InterruptHandlers[i].pFunction = CycInt_IDToHandlerFunction(ID);
}
}
MemorySnapShot_Store(&nCyclesOver, sizeof(nCyclesOver));
MemorySnapShot_Store(&PendingInterruptCount, sizeof(PendingInterruptCount));
if (bSave)
{
/* Convert function to ID */
ID = CycInt_HandlerFunctionToID(PendingInterruptFunction);
MemorySnapShot_Store(&ID, sizeof(int));
}
else
{
/* Convert ID to function */
MemorySnapShot_Store(&ID, sizeof(int));
PendingInterruptFunction = CycInt_IDToHandlerFunction(ID);
}
if (!bSave)
CycInt_SetNewInterrupt(); /* when restoring snapshot, compute current state after */
}
/**
* Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
*/
void Floppy_MemorySnapShot_Capture(bool bSave)
{
int i;
/* If restoring then eject old drives first! */
if (!bSave)
Floppy_EjectBothDrives();
/* Save/Restore details */
for (i = 0; i < MAX_FLOPPYDRIVES; i++)
{
MemorySnapShot_Store(&EmulationDrives[i].ImageType, sizeof(EmulationDrives[i].ImageType));
MemorySnapShot_Store(&EmulationDrives[i].bDiskInserted, sizeof(EmulationDrives[i].bDiskInserted));
MemorySnapShot_Store(&EmulationDrives[i].nImageBytes, sizeof(EmulationDrives[i].nImageBytes));
if (!bSave && EmulationDrives[i].bDiskInserted)
{
EmulationDrives[i].pBuffer = malloc(EmulationDrives[i].nImageBytes);
if (!EmulationDrives[i].pBuffer)
perror("Floppy_MemorySnapShot_Capture");
}
if (EmulationDrives[i].pBuffer)
MemorySnapShot_Store(EmulationDrives[i].pBuffer, EmulationDrives[i].nImageBytes);
MemorySnapShot_Store(EmulationDrives[i].sFileName, sizeof(EmulationDrives[i].sFileName));
MemorySnapShot_Store(&EmulationDrives[i].bContentsChanged,sizeof(EmulationDrives[i].bContentsChanged));
MemorySnapShot_Store(&EmulationDrives[i].bOKToSave,sizeof(EmulationDrives[i].bOKToSave));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState1,sizeof(EmulationDrives[i].TransitionState1));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState1_VBL,sizeof(EmulationDrives[i].TransitionState1_VBL));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState2,sizeof(EmulationDrives[i].TransitionState2));
MemorySnapShot_Store(&EmulationDrives[i].TransitionState2_VBL,sizeof(EmulationDrives[i].TransitionState2_VBL));
/* Because Floppy_EjectBothDrives() was called above before restoring (which cleared */
/* FDC_DRIVES[].DiskInserted that was restored just before), we must call FDC_InsertFloppy */
/* for each restored drive with an inserted disk to set FDC_DRIVES[].DiskInserted=true */
if ( !bSave && ( EmulationDrives[i].bDiskInserted ) )
FDC_InsertFloppy ( i );
}
}
/**
* Save/Restore snapshot of local variables ('MemorySnapShot_Store' handles type)
*/
void IoMem_MemorySnapShot_Capture(bool bSave)
{
/* Save/Restore details */
MemorySnapShot_Store(&falconBusMode, sizeof(falconBusMode));
}
/**
* Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type)
* We must take care of whether Hatari was compiled with IPF support of not
* when saving/restoring snapshots to avoid incompatibilies.
*/
void IPF_MemorySnapShot_Capture(bool bSave)
{
int StructSize;
int Drive;
if ( bSave ) /* Saving snapshot */
{
StructSize = sizeof ( IPF_State ); /* 0 if HAVE_CAPSIMAGE is not defined */
MemorySnapShot_Store(&StructSize, sizeof(StructSize));
fprintf ( stderr , "ipf save %d\n" , StructSize );
if ( StructSize > 0 )
MemorySnapShot_Store(&IPF_State, sizeof(IPF_State));
}
else /* Restoring snapshot */
{
MemorySnapShot_Store(&StructSize, sizeof(StructSize));
fprintf ( stderr , "ipf load %d\n" , StructSize );
if ( ( StructSize == 0 ) && ( sizeof ( IPF_State ) > 0 ) )
{
Log_AlertDlg(LOG_ERROR, "This memory snapshot doesn't include IPF data but this version of Hatari was built with IPF support");
return; /* Continue restoring the rest of the memory snapshot */
}
else if ( ( StructSize > 0 ) && ( sizeof ( IPF_State ) == 0 ) )
{
Log_AlertDlg(LOG_ERROR, "This memory snapshot includes IPF data but this version of Hatari was not built with IPF support");
MemorySnapShot_Skip( StructSize ); /* Ignore the IPF data */
return; /* Continue restoring the rest of the memory snapshot */
}
else if ( ( StructSize > 0 ) && ( StructSize != sizeof ( IPF_State ) ) )
{
Log_AlertDlg(LOG_ERROR, "This memory snapshot includes IPF data different from the ones handled in this version of Hatari");
MemorySnapShot_Skip( StructSize ); /* Ignore the IPF data */
return; /* Continue restoring the rest of the memory snapshot */
}
if ( StructSize > 0 )
{
MemorySnapShot_Store(&IPF_State, sizeof(IPF_State));
#ifdef HAVE_CAPSIMAGE
/* For IPF structures, we need to update some pointers in Fdc/Drive/CapsImage */
/* drive : PUBYTE trackbuf, PUDWORD timebuf */
/* fdc : PCAPSDRIVE driveprc, PCAPSDRIVE drive, CAPSFDCHOOK callback functions */
CAPSFdcInvalidateTrack ( &IPF_State.Fdc , 0 ); /* Invalidate buffered track data for drive 0 */
CAPSFdcInvalidateTrack ( &IPF_State.Fdc , 1 ); /* Invalidate buffered track data for drive 1 */
IPF_State.Fdc.drive = IPF_State.Drive; /* Connect drives array to the FDC */
if ( IPF_State.Fdc.driveprc != NULL ) /* Recompute active drive's pointer */
IPF_State.Fdc.driveprc = IPF_State.Fdc.drive + IPF_State.Fdc.driveact;
/* Set callback functions */
IPF_State.Fdc.cbirq = IPF_CallBack_Irq;
IPF_State.Fdc.cbdrq = IPF_CallBack_Drq;
IPF_State.Fdc.cbtrk = IPF_CallBack_Trk;
#endif
/* Call IPF_Insert to recompute IPF_State.CapsImage[ Drive ] */
for ( Drive=0 ; Drive < MAX_FLOPPYDRIVES ; Drive++ )
if ( EmulationDrives[Drive].ImageType == FLOPPY_IMAGE_TYPE_IPF )
if ( IPF_Insert ( Drive , EmulationDrives[Drive].pBuffer , EmulationDrives[Drive].nImageBytes ) == false )
{
Log_AlertDlg(LOG_ERROR, "Error restoring IPF image %s in drive %d" ,
EmulationDrives[Drive].sFileName , Drive );
return;
}
fprintf ( stderr , "ipf load ok\n" );
}
}
}
uae_u16 restore_u16(void)
{
uae_u16 data;
MemorySnapShot_Store(&data, 2);
return data;
}
uae_u32 restore_u32(void)
{
uae_u32 data;
MemorySnapShot_Store(&data, 4);
return data;
}
void save_u16(uae_u16 data)
{
MemorySnapShot_Store(&data, 2);
}
void save_u32(uae_u32 data)
{
MemorySnapShot_Store(&data, 4);
}
