public override GGPOErrorCode AdvanceFrame()
{
sync.IncrementFrame();
currentInput.Erase();
Log($"End of frame({sync.FrameCount})...");
if (isRollingBack)
{
return(GGPOErrorCode.OK);
}
int frame = sync.FrameCount;
// Hold onto the current frame in our queue of saved states. We'll need
// the checksum later to verify that our replay of the same frame got the
// same results.
var info = new SavedInfo
{
frame = frame,
input = lastInput,
buffer = sync.GetLastSavedFrame().buffer,
checksum = sync.GetLastSavedFrame().checksum,
};
savedFrames.Push(info);
if (frame - lastVerified == checkDistance)
{
// We've gone far enough ahead and should now start replaying frames.
// Load the last verified frame and set the rollback flag to true.
sync.LoadFrame(lastVerified);
isRollingBack = true;
while (!savedFrames.IsEmpty)
{
callbacks.AdvanceFrame();
// Verify that the checksumn of this frame is the same as the one in our
// list.
info = savedFrames.Front();
savedFrames.Pop();
if (info.frame != sync.FrameCount)
{
RaiseSyncError($"Frame number {info.frame} does not match saved frame number {frame}");
}
int checksum = sync.GetLastSavedFrame().checksum;
if (info.checksum != checksum)
{
LogSaveStates(info);
RaiseSyncError($"Checksum for frame {frame} does not match saved ({checksum} != {info.checksum})");
}
Log($"Checksum {checksum:D8} for frame {info.frame} matches.");
}
lastVerified = frame;
isRollingBack = false;
}
return(GGPOErrorCode.OK);
}
private RingBuffer <int> BuildBuffer()
{
var buffer = new RingBuffer <int>(BufferSize);
for (var i = BufferSize / 2; i < BufferSize; i++)
{
buffer.Push(i);
}
for (var i = 0; i < BufferSize / 2; i++)
{
buffer.Push(i);
}
return(buffer);
}
private void ShowFpsHistogram(int framesRenderedInPastSecond, float currentFrameTime)
{
_pastFps.Push(currentFrameTime);
_pastFps.ToArray(_fpsArray);
fpsHistogramMaterial.SetFloatArray("_FpsArray", _fpsArray);
fpsHistogramMaterial.SetFloat("_CurrentFPS", (float)framesRenderedInPastSecond);
}
public sealed override void SendMessage(IMessage pM)
{
if ((_messages.TryPeek(out IMessage m) && m.Type != pM.Type) || _messages.IsEmpty)
{
_messages.Push(pM);
base.SendMessage(pM);
}
}
public void PushSample(float sample)
{
sample = Math.Abs(sample);
while (indices.Count > 0 && GetSample(indices.Head) <= sample)
{
indices.Pop();
}
while (indices.Count > 0 && indices.Tail <= sampleCount - windowSize)
{
indices.PopBack();
}
indices.Push(sampleCount++);
buffer.Push(sample);
}
public void PushSample(float sample)
{
maxWindow.PushSample(sample);
if (buffer.IsFull && buffer.PopBack())
{
nonSilentSamples--;
}
bool nextNonSilent = maxWindow.GetLevel() >= levelThreshold;
buffer.Push(nextNonSilent);
if (nextNonSilent)
{
nonSilentSamples++;
}
}
public void SendInput(ref GameInput input)
{
if (currentState == State.Running)
{
// Check to see if this is a good time to adjust for the rift...
timeSync.AdvanceFrame(ref input, localFrameAdvantage, remoteFrameAdvantage);
// Save this input packet
//
// XXX: This queue may fill up for spectators who do not ack input packets in a timely
// manner.When this happens, we can either resize the queue(ug) or disconnect them
// (better, but still ug). For the meantime, make this queue really big to decrease
// the odds of this happening...
pendingOutput.Push(input);
}
SendPendingOutput();
}
protected void SendMessage(NetworkMessage msg)
{
LogMsg("send", msg);
packetsSent++;
lastSendTime = Utility.GetCurrentTime();
bytesSent += Utility.GetMessageSize(msg);
msg.Magic = magicNumber;
msg.SequenceNumber = nextSendSequence++;
lock (queueLock)
{
sendQueue.Push(new QueueEntry
{
queueTime = Utility.GetCurrentTime(),
destAddress = udpEndpoint,
message = msg,
});
}
PumpSendQueue();
}
public void NormalFencePerfTest()
{
long numberOfItems = 10000000;
ManualResetEvent evt = new ManualResetEvent(false);
RingBuffer<long> buffer = new RingBuffer<long>(1000);
Thread producer = new Thread(() =>
{
evt.WaitOne();
long count = 0;
while (count < numberOfItems)
{
bool wasPushed = buffer.Push(1);
if (wasPushed)
{
count++;
}
}
});
Thread consumer = new Thread(() =>
{
evt.WaitOne();
long count = 0;
while (count < numberOfItems)
{
long popped = 0;
bool wasPopped = buffer.Pop(ref popped);
if (wasPopped)
{
count += popped;
}
}
});
producer.Start();
consumer.Start();
Thread.Sleep(1000);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
evt.Set();
producer.Join();
consumer.Join();
stopwatch.Stop();
Console.WriteLine(string.Format("Total time taken: {0}ms", stopwatch.ElapsedMilliseconds));
}
public void NormalFencePerfTest()
{
long numberOfItems = 10000000;
ManualResetEvent evt = new ManualResetEvent(false);
RingBuffer <long> buffer = new RingBuffer <long>(1000);
Thread producer = new Thread(() =>
{
evt.WaitOne();
long count = 0;
while (count < numberOfItems)
{
bool wasPushed = buffer.Push(1);
if (wasPushed)
{
count++;
}
}
});
Thread consumer = new Thread(() =>
{
evt.WaitOne();
long count = 0;
while (count < numberOfItems)
{
long popped = 0;
bool wasPopped = buffer.Pop(ref popped);
if (wasPopped)
{
count += popped;
}
}
});
producer.Start();
consumer.Start();
Thread.Sleep(1000);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
evt.Set();
producer.Join();
consumer.Join();
stopwatch.Stop();
Console.WriteLine(string.Format("Total time taken: {0}ms", stopwatch.ElapsedMilliseconds));
}
public void Write(byte value)
{
windowBuffer.Push(value);
++OutputSize;
}
private void handleValue(Int16 amplitude)
{
amplitude = FirstPassFilter(amplitude);
previousValues.Push(amplitude);
// correct clipping at 255 or -256 using a parabola to synthesize the lost peak/vally
if (previousValues[BUFFER - 16] == 255 || previousValues[BUFFER - 16] == -256)
{
int weightedPrevious = previousValues[BUFFER - 16 - 1];
int divisor = 0;
int iterations = 0;
for (; iterations < 6; iterations++)
{
divisor += (iterations * 2);
weightedPrevious += previousValues[BUFFER - 16 - 1] + (previousValues[BUFFER - 16] - previousValues[BUFFER - 16 - 1]);
// break if we go out of range early
if (previousValues[BUFFER - 16] == 255 && previousValues[BUFFER - 16 + 1 + iterations] >= 255)
{
break;
}
if (previousValues[BUFFER - 16] == -256 && previousValues[BUFFER - 16 + 1 + iterations] <= -256)
{
break;
}
}
if (iterations > 2)
{
float a = (float)(previousValues[BUFFER - 16 + 1 + iterations] - weightedPrevious) / (float)divisor;
float b = (float)(previousValues[BUFFER - 16] - previousValues[BUFFER - 16 - 1]) - a;
float c = (float)previousValues[BUFFER - 16 - 1];
for (int v13 = iterations, v9Index = 16 - 1, x = 2; v13 > 3; v13--, v9Index++, x++)
{
previousValues[v9Index] = (Int16)(float)Math.Round((a * x * x) + (b * x) + c);
}
}
}
// get the max absolute amplitude of the last BUFFER frames
previousAbsValues.Push((Int16)Math.Abs((previousValues[BUFFER - 16] == Int16.MinValue) ? Int16.MaxValue : previousValues[BUFFER - 16]));
int maxAbsInWindow = 0;
for (int i = 0; i < previousAbsValues.Size; i++)
{
Int16 newValue = previousAbsValues[i];
if (newValue > maxAbsInWindow)
{
maxAbsInWindow = newValue;
}
}
// get the min and max for the 9 frames at the read index
Int16 findMin = 0;
Int16 findMax = 0;
for (int i = 0; i < 9; i++)
{
Int16 newValue = previousValues[BUFFER - 16 + 2 + i];
if (newValue > findMax)
{
findMax = newValue;
}
if (newValue < findMin)
{
findMin = newValue;
}
}
int rangeTop = Math.Max((int)findMax, 100);
int rangeBottom = Math.Min((int)findMin, -100);
int rangeMiddle = (rangeBottom + rangeTop) / 2;
Int16 rangedValue = (Int16)Math.Min(Math.Max(previousValues[BUFFER - 16] - rangeMiddle, Int16.MinValue), Int16.MaxValue);
if (maxAbsInWindow < 101)
{
if (countsBufferIndex > 0)
{
// process counts data with various possible threshholds
rx_buffer_len = 0;
currentBitIndex = 0;
currentByte = 0;
self_checksumOK = false;
if (!processCountsWithThreshold(63))
{
for (int i = 1; i < 10; i++) // shouldn't this start at 1 as the above already tried?
{
rx_buffer_len = 0;
currentBitIndex = 0;
currentByte = 0;
if (processCountsWithThreshold(63 + i))
{
if (self_checksumOK)
{
break;
}
}
rx_buffer_len = 0;
currentBitIndex = 0;
currentByte = 0;
if (processCountsWithThreshold(63 - i))
{
if (self_checksumOK)
{
break;
}
}
}
}
if (self_checksumOK)
{
++self_checksumSuccessCount;
}
else if ((uint)countsBufferIndex > 20)
{
++self_checksumErrorCount;
}
countsBufferIndex = 0;
}
}
if (rangedValue > 1)
{
_MergedGlobals_currentValue = 1;
}
else if (rangedValue < -1)
{
_MergedGlobals_currentValue = 0;
}
{
_MergedGlobals_countsSinceLastTransition += 10;
if (_MergedGlobals_currentValue != _MergedGlobals_lastValue)
{
int stepsAgoCrossedZero = 10 * Math.Abs((int)rangedValue) / Math.Abs((int)rangedValue - (int)_MergedGlobals_previousValue);
_MergedGlobals_countsSinceLastTransition -= stepsAgoCrossedZero;
if (rangedValue > 1 || countsBufferIndex != 0)
{
if (countsBufferIndex == 0)
{
_MergedGlobals_countsSinceLastTransition = stepsAgoCrossedZero;
}
countsBuffer[countsBufferIndex] = _MergedGlobals_countsSinceLastTransition;
// attempt to fix noise by merging overly-short inversion, another method might be detecting slope instead of time
if (countsBufferIndex > 4 && _MergedGlobals_countsSinceLastTransition < 35)
{
int total = countsBuffer[countsBufferIndex - 0] + countsBuffer[countsBufferIndex - 1] + countsBuffer[countsBufferIndex - 2];
if (total < 100)
{
countsBufferIndex -= 2;
countsBuffer[countsBufferIndex] = total;
}
}
if (countsBufferIndex < 4000)
{
countsBufferIndex++;
}
}
_MergedGlobals_countsSinceLastTransition = stepsAgoCrossedZero;
}
_MergedGlobals_lastValue = _MergedGlobals_currentValue;
_MergedGlobals_previousValue = rangedValue;
}
}
protected void QueueEvent(UdpProtocolEvent evt)
{
LogEvent("Queuing event", evt);
eventQueue.Push(evt);
}
private void PushUndolog()
{
undolog.Push(textBox.Text);
autoUndologStage = 0;
}
