ShuriZma
/
fceux
mirror of https://github.com/TASEmulators/fceux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

State recorder config setup in work.

This commit is contained in:
harry 2023-03-11 20:45:13 -05:00
parent f87d746350
commit bb76573112
6 changed files with 114 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/drivers/Qt/StateRecorderConf.cpp
View File

@ -28,6 +28,7 @@
#include <QGridLayout>
#include <QSettings>
#include "Qt/fceuWrapper.h"
#include "Qt/StateRecorderConf.h"
#include "../../fceu.h"
@ -54,6 +55,10 @@ StateRecorderDialog_t::StateRecorderDialog_t(QWidget *parent)
snapSeconds = new QSpinBox();
historyDuration = new QSpinBox();
recorderEnable->setChecked( FCEU_StateRecorderIsEnabled() );
connect( recorderEnable, SIGNAL(stateChanged(int)), this, SLOT(enableChanged(int)) );
snapSeconds->setMinimum(0);
snapSeconds->setMaximum(60);
snapSeconds->setValue(3);
@ -64,6 +69,10 @@ StateRecorderDialog_t::StateRecorderDialog_t(QWidget *parent)
historyDuration->setMaximum(180);
historyDuration->setValue(15);
connect( snapSeconds, SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)) );
connect( snapMinutes, SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)) );
connect( historyDuration, SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)) );
frame = new QGroupBox(tr("Retain History For:"));
hbox = new QHBoxLayout();
@ -131,6 +140,9 @@ StateRecorderDialog_t::StateRecorderDialog_t(QWidget *parent)
closeButton->setIcon( style()->standardIcon( QStyle::SP_DialogCloseButton ) );
applyButton->setIcon( style()->standardIcon( QStyle::SP_DialogApplyButton ) );
connect(closeButton, SIGNAL(clicked(void)), this, SLOT(closeWindow(void)));
connect(applyButton, SIGNAL(clicked(void)), this, SLOT(applyChanges(void)));
hbox->addWidget(applyButton, 1);
hbox->addStretch(8);
hbox->addWidget(closeButton, 1);
@ -164,6 +176,26 @@ void StateRecorderDialog_t::closeWindow(void)
deleteLater();
}
//----------------------------------------------------------------------------
void StateRecorderDialog_t::applyChanges(void)
{
}
//----------------------------------------------------------------------------
void StateRecorderDialog_t::enableChanged(int val)
{
bool ena = val ? true : false;
FCEU_StateRecorderSetEnabled( ena );
g_config->setOption("SDL.StateRecorderEnable", ena);
g_config->save();
}
//----------------------------------------------------------------------------
void StateRecorderDialog_t::spinBoxValueChanged(int newValue)
{
recalcMemoryUsage();
}
//----------------------------------------------------------------------------
void StateRecorderDialog_t::recalcMemoryUsage(void)
{
char stmp[64];

4
src/drivers/Qt/StateRecorderConf.h
View File

@ -43,5 +43,7 @@ protected:
public slots:
void closeWindow(void);
private slots:
void applyChanges(void);
void spinBoxValueChanged(int newValue);
void enableChanged(int);
};

5
src/drivers/Qt/config.cpp
View File

@ -754,6 +754,11 @@ InitConfig()
config->addOption("loadstate", "SDL.AutoLoadState", INVALID_STATE);
config->addOption("savestate", "SDL.AutoSaveState", INVALID_STATE);
config->addOption("SDL.StateRecorderEnable", false);
config->addOption("SDL.StateRecorderHistoryDurationMin", 15);
config->addOption("SDL.StateRecorderTimeBetweenSnapsMin", 0);
config->addOption("SDL.StateRecorderTimeBetweenSnapsSec", 3);
//TODO implement this
config->addOption("periodicsaves", "SDL.PeriodicSaves", 0);

7
src/drivers/Qt/fceuWrapper.cpp
View File

@ -52,6 +52,7 @@
#include "../../fceu.h"
#include "../../cheat.h"
#include "../../movie.h"
#include "../../state.h"
#include "../../version.h"
#ifdef _S9XLUA_H
@ -972,6 +973,12 @@ int fceuWrapperInit( int argc, char *argv[] )
// load the hotkeys from the config life
setHotKeys();
// Initialize the State Recorder
bool srEnable = false;
g_config->getOption("SDL.StateRecorderEnable", &srEnable);
FCEU_StateRecorderSetEnabled( srEnable );
if (romIndex >= 0)
{
QFileInfo fi( argv[romIndex] );

63
src/state.cpp
View File

@ -1185,23 +1185,23 @@ void RedoLoadState()
//----------- Save State History ----------------
//-----------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------
static StateRecorderConfigData stateRecorderConfig;
class StateRecorder
{
public:
StateRecorder(void)
{
size_t ringBufSize = 60;
loadConfig( stateRecorderConfig );
for (size_t i=0; i<ringBufSize; i++)
for (int i=0; i<ringBufSize; i++)
{
EMUFILE_MEMORY *em = new EMUFILE_MEMORY( 0x10000 );
EMUFILE_MEMORY *em = new EMUFILE_MEMORY( 0x1000 );
ringBuf.push_back(em);
}
ringStart = ringHead = ringTail = 0;
frameCounter = 0;
framesPerSnap = 3 * 60;
compressionLevel = Z_NO_COMPRESSION;
lastState = ringHead;
loadIndexReset = false;
lastLoadFrame = 0;
@ -1216,6 +1216,35 @@ class StateRecorder
ringBuf.clear();
}
void loadConfig( StateRecorderConfigData &config )
{
if (config.timeBetweenSnapsMinutes < 0.0)
{
config.timeBetweenSnapsMinutes = 3.0f / 60.0f;
}
if (config.timeBetweenSnapsMinutes > config.historyDurationMinutes)
{
config.historyDurationMinutes = config.timeBetweenSnapsMinutes;
}
const double fhistMin = config.historyDurationMinutes;
const double fsnapMin = config.timeBetweenSnapsMinutes;
const double fnumSnaps = fhistMin / fsnapMin;
ringBufSize = static_cast<int>( fnumSnaps + 0.5f );
int32_t fps = FCEUI_GetDesiredFPS(); // Do >> 24 to get in Hz
double hz = ( ((double)fps) / 16777216.0 );
double framesPerSnapf = hz * fsnapMin * 60.0;
framesPerSnap = static_cast<unsigned int>( framesPerSnapf + 0.50 );
printf("ringBufSize:%i framesPerSnap:%i\n", ringBufSize, framesPerSnap );
compressionLevel = stateRecorderConfig.compressionLevel;
}
void update(void)
{
bool isPaused = FCEUI_EmulationPaused() ? true : false;
@ -1224,8 +1253,6 @@ class StateRecorder
if (!isPaused && loadIndexReset)
{
int ringBufSize = static_cast<int>( ringBuf.size() );
ringHead = (lastState + 1) % ringBufSize;
frameCounter = curFrame;
@ -1239,8 +1266,6 @@ class StateRecorder
if ( (frameCounter % framesPerSnap) == 0 )
{
int ringBufSize = static_cast<int>( ringBuf.size() );
EMUFILE_MEMORY *em = ringBuf[ ringHead ];
em->set_len(0);
@ -1263,8 +1288,6 @@ class StateRecorder
int loadStateRelativeToEnd( int numSnapsFromLatest )
{
int ringBufSize = static_cast<int>( ringBuf.size() );
if (numSnapsFromLatest < 0)
{
numSnapsFromLatest = 0;
@ -1280,8 +1303,6 @@ class StateRecorder
int loadStateByIndex( int snapIdx )
{
int ringBufSize = static_cast<int>( ringBuf.size() );
if (snapIdx < 0)
{
snapIdx = snapIdx + ringBufSize;
@ -1339,6 +1360,7 @@ class StateRecorder
int ringHead;
int ringTail;
int ringStart;
int ringBufSize;
int compressionLevel;
unsigned int frameCounter;
unsigned int framesPerSnap;
@ -1383,6 +1405,11 @@ bool FCEU_StateRecorderIsEnabled(void)
return StateRecorder::enabled;
}
void FCEU_StateRecorderSetEnabled(bool enabled)
{
StateRecorder::enabled = enabled;
}
bool FCEU_StateRecorderRunning(void)
{
return stateRecorder != nullptr;
@ -1401,3 +1428,13 @@ int FCEU_StateRecorderGetStateIndex(void)
{
return StateRecorder::lastState;
}
const StateRecorderConfigData& FCEU_StateRecorderGetConfigData(void)
{
return stateRecorderConfig;
}
int FCEU_StateRecorderSetConfigData(const StateRecorderConfigData &newConfig)
{
stateRecorderConfig = newConfig;
return 0;
}

17
src/state.h
View File

@ -79,10 +79,27 @@ bool CheckBackupSaveStateExist(); //Checks if backupsavestate exists
extern bool compressSavestates; //Whether or not to compress non-movie savestates (by default, yes)
struct StateRecorderConfigData
{
float historyDurationMinutes;
float timeBetweenSnapsMinutes;
int compressionLevel;
StateRecorderConfigData(void)
{
historyDurationMinutes = 15.0f;
timeBetweenSnapsMinutes = 3.0f / 60.0f;
compressionLevel = 0;
}
};
int FCEU_StateRecorderStart(void);
int FCEU_StateRecorderStop(void);
int FCEU_StateRecorderUpdate(void);
bool FCEU_StateRecorderRunning(void);
bool FCEU_StateRecorderIsEnabled(void);
void FCEU_StateRecorderSetEnabled(bool enabled);
int FCEU_StateRecorderGetStateIndex(void);
int FCEU_StateRecorderLoadState(int snapIndex);
int FCEU_StateRecorderSetConfigData(const StateRecorderConfigData &newConfig);
const StateRecorderConfigData& FCEU_StateRecorderGetConfigData(void);