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

Make code a little more concise; should have done this in the last commit.

This commit is contained in:
Stephen Anthony 2022-06-05 11:10:44 -02:30
parent b1dfa60def
commit f8e1ebac82
1 changed files with 27 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/emucore/tia/frame-manager/JitterEmulation.cxx
View File

@ -16,6 +16,11 @@
//============================================================================
#include <cmath>
using std::abs;
using std::max;
using std::min;
using std::pow;
using std::round;
#include "JitterEmulation.hxx"
@ -37,24 +42,24 @@ void JitterEmulation::setSensitivity(Int32 sensitivity)
myLastFrameScanlines = myLastFrameVsyncCycles = myUnstableCount = myJitter = 0;
mySensitivity = BSPF::clamp(sensitivity, MIN_SENSITIVITY, MAX_SENSITIVITY);
const float factor = std::pow(static_cast<float>(mySensitivity - MIN_SENSITIVITY) / (MAX_SENSITIVITY - MIN_SENSITIVITY), 1.5);
const float factor = pow(static_cast<float>(mySensitivity - MIN_SENSITIVITY) / (MAX_SENSITIVITY - MIN_SENSITIVITY), 1.5);
myScanlineDelta = std::round(MAX_SCANLINE_DELTA - (MAX_SCANLINE_DELTA - MIN_SCANLINE_DELTA) * factor);
myVsyncCycles = std::round(MIN_VSYNC_CYCLES + (MAX_VSYNC_CYCLES - MIN_VSYNC_CYCLES) * factor);
myVsyncDelta1 = std::round(MAX_VSYNC_DELTA_1 - (MAX_VSYNC_DELTA_1 - MIN_VSYNC_DELTA_1) * factor);
myScanlineDelta = round(MAX_SCANLINE_DELTA - (MAX_SCANLINE_DELTA - MIN_SCANLINE_DELTA) * factor);
myVsyncCycles = round(MIN_VSYNC_CYCLES + (MAX_VSYNC_CYCLES - MIN_VSYNC_CYCLES) * factor);
myVsyncDelta1 = round(MAX_VSYNC_DELTA_1 - (MAX_VSYNC_DELTA_1 - MIN_VSYNC_DELTA_1) * factor);
#ifdef VSYNC_LINE_JITTER
myVsyncDelta2 = std::round(MIN_VSYNC_DELTA_2 + (MAX_VSYNC_DELTA_2 - MIN_VSYNC_DELTA_2) * factor);
myVsyncDelta2 = round(MIN_VSYNC_DELTA_2 + (MAX_VSYNC_DELTA_2 - MIN_VSYNC_DELTA_2) * factor);
#endif
myUnstableFrames = std::round(MAX_UNSTABLE_FRAMES - (MAX_UNSTABLE_FRAMES - MIN_UNSTABLE_FRAMES) * factor);
myJitterLines = std::round(MIN_JITTER_LINES + (MAX_JITTER_LINES - MIN_JITTER_LINES) * factor);
myVsyncLines = std::round(MIN_VSYNC_LINES + (MAX_VSYNC_LINES - MIN_VSYNC_LINES) * factor);
myUnstableFrames = round(MAX_UNSTABLE_FRAMES - (MAX_UNSTABLE_FRAMES - MIN_UNSTABLE_FRAMES) * factor);
myJitterLines = round(MIN_JITTER_LINES + (MAX_JITTER_LINES - MIN_JITTER_LINES) * factor);
myVsyncLines = round(MIN_VSYNC_LINES + (MAX_VSYNC_LINES - MIN_VSYNC_LINES) * factor);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void JitterEmulation::frameComplete(Int32 scanlineCount, Int32 vsyncCycles)
{
#ifdef DEBUG_BUILD
const int vsyncLines = std::round((vsyncCycles - 2) / 76.0);
const int vsyncLines = round((vsyncCycles - 2) / 76.0);
cerr << "TV jitter " << myJitter << " - " << scanlineCount << ", " << vsyncCycles << ", " << vsyncLines << endl;
#endif
@ -63,11 +68,11 @@ void JitterEmulation::frameComplete(Int32 scanlineCount, Int32 vsyncCycles)
const bool vsyncCyclesStable = vsyncCycles >= myVsyncCycles;
// Handle inconsistency of vsync cycles and around half lines
#ifdef VSYNC_LINE_JITTER
const Int32 minLines = std::round((vsyncCycles - 2 - myVsyncDelta2) / 76.0);
const Int32 maxLines = std::round((vsyncCycles - 2 + myVsyncDelta2) / 76.0);
const Int32 minLastLines = std::round((myLastFrameVsyncCycles - 2 - myVsyncDelta2) / 76.0);
const Int32 maxLastLines = std::round((myLastFrameVsyncCycles - 2 + myVsyncDelta2) / 76.0);
const bool vsyncLinesStable = std::abs(vsyncCycles - myLastFrameVsyncCycles) < myVsyncDelta1
const Int32 minLines = round((vsyncCycles - 2 - myVsyncDelta2) / 76.0);
const Int32 maxLines = round((vsyncCycles - 2 + myVsyncDelta2) / 76.0);
const Int32 minLastLines = round((myLastFrameVsyncCycles - 2 - myVsyncDelta2) / 76.0);
const Int32 maxLastLines = round((myLastFrameVsyncCycles - 2 + myVsyncDelta2) / 76.0);
const bool vsyncLinesStable = abs(vsyncCycles - myLastFrameVsyncCycles) < myVsyncDelta1
&& minLines == maxLastLines && maxLines == minLastLines;
#else
const bool vsyncLinesStable = abs(vsyncCycles - myLastFrameVsyncCycles) < myVsyncDelta1;
@ -85,14 +90,14 @@ void JitterEmulation::frameComplete(Int32 scanlineCount, Int32 vsyncCycles)
&& abs(myJitter) < static_cast<Int32>(myRandom.next() % myJitterLines))
{
// Repeated invalid frames cause randomly repeated jitter
myJitter = std::max(std::min(scanlineDifference, myJitterLines), -myYStart);
myJitter = max(min(scanlineDifference, myJitterLines), -myYStart);
}
}
if(!vsyncCyclesStable)
{
// If VSYNC length is too low, the frame rolls permanently down, speed depending on missing cycles
const Int32 jitter = std::max(
std::min<Int32>(std::round(scanlineCount * (1 - static_cast<float>(vsyncCycles) / myVsyncCycles)),
const Int32 jitter = max(
min<Int32>(round(scanlineCount * (1 - static_cast<float>(vsyncCycles) / myVsyncCycles)),
myJitterLines),
myJitterRecovery + 1); // Roll at least one scanline
@ -109,7 +114,7 @@ void JitterEmulation::frameComplete(Int32 scanlineCount, Int32 vsyncCycles)
myJitter += vsyncCycles > myLastFrameVsyncCycles ? myVsyncLines : -myVsyncLines;
#endif
}
myJitter = std::max(myJitter, -myYStart);
myJitter = max(myJitter, -myYStart);
}
}
else
@ -118,9 +123,9 @@ void JitterEmulation::frameComplete(Int32 scanlineCount, Int32 vsyncCycles)
// Only recover during stable frames
if(myJitter > 0)
myJitter = std::max(myJitter - myJitterRecovery, 0);
myJitter = max(myJitter - myJitterRecovery, 0);
else if(myJitter < 0)
myJitter = std::min(myJitter + myJitterRecovery, 0);
myJitter = min(myJitter + myJitterRecovery, 0);
}
myLastFrameScanlines = scanlineCount;
@ -142,7 +147,7 @@ bool JitterEmulation::save(Serializer& out) const
}
catch(...)
{
cerr << "ERROR: JitterEmulation::save" << std::endl;
cerr << "ERROR: JitterEmulation::save" << endl;
return false;
}
@ -165,7 +170,7 @@ bool JitterEmulation::load(Serializer& in)
}
catch (...)
{
cerr << "ERROR: JitterEmulation::load" << std::endl;
cerr << "ERROR: JitterEmulation::load" << endl;
return false;
}