Add back callspot switching + prevent use after free in LFX

Thanks to @koffiato for all the testing in: https://github.com/cdozdil/OptiScaler/issues/523

Author: FakeMichau

src/low_latency_tech/ll_antilag2.cpp

@@ -30,6 +30,8 @@ inline HRESULT AntiLag2::al2_sleep() {
 
     // log_event("al2_sleep", "{}", get_timestamp() - pre_sleep);
 
+    spdlog::trace("AntiLag 2 Call Spot: {}", current_call_spot == CallSpot::SimulationStart ? "SimulationStart" : "SleepCall");
+
     return result;
 }
 
@@ -101,13 +103,22 @@ void AntiLag2::set_sleep_mode(SleepMode* sleep_mode) {
 }
 
 void AntiLag2::sleep() {
+    last_sleep_framecount = simulation_framecount;
+
     if (current_call_spot == CallSpot::SleepCall)
         al2_sleep();
 }
 
 void AntiLag2::set_marker(IUnknown* pDevice, MarkerParams* marker_params) {
     switch(marker_params->marker_type) {
         case MarkerType::SIMULATION_START:
+            simulation_framecount++;
+
+            if (last_sleep_framecount + call_spot_switch_threshold < simulation_framecount)
+                current_call_spot = CallSpot::SimulationStart;
+            else
+                current_call_spot = CallSpot::SleepCall;
+
             if (current_call_spot == CallSpot::SimulationStart)
                 al2_sleep();
         break;

src/low_latency_tech/ll_antilag2.h

@@ -11,6 +11,10 @@ class AntiLag2 : public virtual LowLatencyTech {
     AMD::AntiLag2DX11::Context dx11_ctx = {};
 
     uint32_t minimum_interval_us = 0;
+    
+    uint64_t last_sleep_framecount = 0;
+    uint64_t simulation_framecount = 0;
+    const uint64_t call_spot_switch_threshold = 20;
 
     HRESULT al2_sleep();
 

src/low_latency_tech/ll_latencyflex.cpp

@@ -19,7 +19,9 @@ void LatencyFlex::lfx_sleep(uint64_t reflex_frame_id) {
         eepy(200000000ULL);
         frame_id = 1;
         needs_reset = false;
-        ctx->Reset();
+
+        if (ctx)
+            ctx->Reset();
     }
 
     uint64_t current_timestamp = get_timestamp();
@@ -33,7 +35,8 @@ void LatencyFlex::lfx_sleep(uint64_t reflex_frame_id) {
     mutex.lock();
     auto local_frame_id = lfx_mode == LFXMode::ReflexIDs ? reflex_frame_id : this->frame_id + 1;
     // log_event("lfx_get_wait_target", "{}", frame_id);
-    target = ctx->GetWaitTarget(local_frame_id);
+    if (ctx)
+        target = ctx->GetWaitTarget(local_frame_id);
     mutex.unlock();
 
     if (target > current_timestamp) {
@@ -55,10 +58,13 @@ void LatencyFlex::lfx_sleep(uint64_t reflex_frame_id) {
         timestamp = current_timestamp;
     }
 
+    spdlog::trace("LatencyFlex Call Spot: {}", current_call_spot == CallSpot::SimulationStart ? "SimulationStart" : "SleepCall");
+
     mutex.lock();
     this->frame_id++;
     // log_event("lfx_beginframe", "{}", frame_id);
-    ctx->BeginFrame(local_frame_id, target, timestamp);
+    if (ctx)
+        ctx->BeginFrame(local_frame_id, target, timestamp);
     mutex.unlock();
 }
 
@@ -67,7 +73,8 @@ void LatencyFlex::lfx_end_frame(uint64_t reflex_frame_id) {
     mutex.lock();
     auto frame_id = Config::get().get_latencyflex_mode() == LFXMode::ReflexIDs ? reflex_frame_id : this->frame_id;
     // log_event("lfx_endframe", "{}", frame_id);
-    ctx->EndFrame(frame_id, current_timestamp, &latency, &frame_time);
+    if (ctx)
+        ctx->EndFrame(frame_id, current_timestamp, &latency, &frame_time);
     mutex.unlock();
     spdlog::trace("LFX latency: {}, frame_time: {}, current_timestamp: {}", latency, frame_time, current_timestamp);
 }
@@ -112,13 +119,24 @@ void LatencyFlex::set_sleep_mode(SleepMode* sleep_mode) {
 };
 
 void LatencyFlex::sleep() {
-    if (current_call_spot == CallSpot::SleepCall && Config::get().get_latencyflex_mode() != LFXMode::ReflexIDs)
-        lfx_sleep(INVALID_ID);
+    if (Config::get().get_latencyflex_mode() != LFXMode::ReflexIDs) {
+        last_sleep_framecount = simulation_framecount;
+        
+        if (current_call_spot == CallSpot::SleepCall)
+            lfx_sleep(INVALID_ID);
+    }
 };
 
 void LatencyFlex::set_marker(IUnknown* pDevice, MarkerParams* marker_params) {
     switch(marker_params->marker_type) {
         case MarkerType::SIMULATION_START:
+            simulation_framecount++;
+            
+            if (last_sleep_framecount + call_spot_switch_threshold < simulation_framecount)
+                current_call_spot = CallSpot::SimulationStart;
+            else
+                current_call_spot = CallSpot::SleepCall;
+                
             if (current_call_spot == CallSpot::SimulationStart)
                 lfx_sleep(marker_params->frame_id);
         break;

src/low_latency_tech/ll_latencyflex.h

@@ -12,6 +12,10 @@ class LatencyFlex : public virtual LowLatencyTech {
 
     uint32_t minimum_interval_us = 0;
 
+    uint64_t last_sleep_framecount = 0;
+    uint64_t simulation_framecount = 0;
+    const uint64_t call_spot_switch_threshold = 20;
+
     uint64_t latency = 0;
     uint64_t frame_time = 1;
     uint64_t target = 0;