static IEnumerable <VideoEdit> _GetRaceEdits(this IEnumerable <OverlayData.RaceEvent> raceEvents)
{
var totalRaceEvents = GetInterestingRaceEvents(raceEvents);
var previousEvent = totalRaceEvents.First();
foreach (var re in totalRaceEvents.Skip(1))
{
if (re.StartTime - previousEvent.EndTime >= 10d / Settings.AppliedTimingFactor)
{
TraceDebug.WriteLine("Applying edit between {0}:{1}:{2} and {3}:{4}:{5}",
previousEvent.Interest, previousEvent.Position, previousEvent.EndTime,
re.Interest, re.Position, re.StartTime);
yield return(new VideoEdit {
StartTime = previousEvent.EndTime - 1, EndTime = re.StartTime + 1
});
}
else
{
TraceDebug.WriteLine("Not apply edit between {0}:{1}:{2} and {3}:{4}:{5}",
previousEvent.Interest, previousEvent.Position, previousEvent.EndTime,
re.Interest, re.Position, re.StartTime);
}
previousEvent = re;
}
}
public void _AnalyseRace(Action onComplete)
{
var hwnd = Win32.Messages.FindWindow(null, "iRacing.com Simulator");
Win32.Messages.ShowWindow(hwnd, Win32.Messages.SW_SHOWNORMAL);
Win32.Messages.SetForegroundWindow(hwnd);
Thread.Sleep(Settings.Default.PeriodWaitForIRacingSwitch);
var data = iRacing.GetDataFeed()
.WithCorrectedPercentages()
.AtSpeed(16)
.RaceOnly()
.First(d => d.Telemetry.SessionState == SessionState.Racing);
raceStartFrameNumber = data.Telemetry.ReplayFrameNum - (60 * 20);
if (raceStartFrameNumber < 0)
{
TraceInfo.WriteLine("Unable to start capturing at 20 seconds prior to race start. Starting at start of replay file.");
raceStartFrameNumber = 0;
}
TraceDebug.WriteLine(data.Telemetry.ToString());
AnalyseIncidents(); //Analyse incidents
AnalyseRaceSituations(new iRacingConnection().GetBufferedDataFeed()); //Analyse race situation (all) by playing out replay at 16x speed.
onComplete();
}
/// <summary>
/// If the supplied function returns true for the period, then iteration stops
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
public IEnumerable <DataSample> Of(Func <DataSample, bool> condition)
{
bool conditionMet = false;
TimeSpan conditionMetAt = new TimeSpan();
foreach (var data in samples)
{
if (condition(data))
{
if (!conditionMet)
{
TraceDebug.WriteLine("{0}: Condition met".F(data.Telemetry.SessionTimeSpan));
conditionMet = true;
conditionMetAt = data.Telemetry.SessionTimeSpan;
}
}
else
{
if (conditionMet)
{
TraceDebug.WriteLine("{0}: Condition unmet".F(data.Telemetry.SessionTimeSpan));
}
conditionMet = false;
}
if (conditionMet && conditionMetAt + period < data.Telemetry.SessionTimeSpan)
{
break;
}
yield return(data);
}
}
void LogSystemInformation()
{
var StringBuilder1 = new StringBuilder(string.Empty);
try
{
var config = System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.PerUserRoamingAndLocal);
TraceDebug.WriteLine("Local user config path: {0}", config.FilePath);
TraceDebug.WriteLine("Application Version: {0}", AboutBox1.AssemblyVersion);
TraceDebug.WriteLine(Environment.Is64BitOperatingSystem ? "OS: 64x" : "OS: 32x");
TraceDebug.WriteLine("ProcessorCount: {0}".F(Environment.ProcessorCount));
foreach (DriveInfo DriveInfo1 in DriveInfo.GetDrives())
{
TraceDebug.WriteLine("Drive: {0}, Type: {1}, Format: {2}, Size: {3}, AvailableFreeSpace: {4}".F(
GetValue(() => DriveInfo1.Name),
GetValue(() => DriveInfo1.DriveType.ToString()),
GetValue(() => DriveInfo1.DriveFormat),
GetValue(() => DriveInfo1.TotalSize.ToString()),
GetValue(() => DriveInfo1.AvailableFreeSpace.ToString())));
}
TraceDebug.WriteLine("SystemPageSize: {0}".F(Environment.SystemPageSize));
TraceDebug.WriteLine("Version: {0}".F(Environment.Version));
LogDeviceInformation("Win32_Processor");
LogDeviceInformation("Win32_VideoController");
}
catch
{
}
}
public void Process(DataSample data, TimeSpan relativeTime)
{
try
{
var cameraGroupName = "";
var cameraName = "";
var cameraGroup = data.SessionData.CameraInfo.Groups.FirstOrDefault(g => g.GroupNum == data.Telemetry.CamGroupNumber);
if (cameraGroup != null)
{
cameraGroupName = cameraGroup.GroupName;
var camera = cameraGroup.Cameras.FirstOrDefault(c => c.CameraNum == data.Telemetry.CamCameraNumber);
if (camera != null)
{
cameraName = camera.CameraName;
}
}
TraceDebug.WriteLine("{0} Camera: Driver: {1}, GroupNumber: {2}, Number: {3}, State: {4}, GroupName: {5}, Name: {6}",
data.Telemetry.SessionTimeSpan,
data.Telemetry.CamCar.Details.Driver.UserName,
data.Telemetry.CamGroupNumber,
data.Telemetry.CamCameraNumber,
data.Telemetry.CamCameraState,
cameraGroupName,
cameraName);
}
catch (Exception e)
{
TraceError.WriteLine(e.Message);
TraceError.WriteLine(e.StackTrace);
}
}
public SourceReaderExtra CreateSourceReader(ReadWriteClassFactory readWriteFactory, Attributes attributes)
{
TraceDebug.WriteLine("Attempting to open file {0}".F(this.FileName));
var reader = readWriteFactory.CreateSourceReaderFromURL(this.FileName, attributes);
TraceDebug.WriteLine("Opened file {0}. Duration: {1}".F(this.FileName, reader.Duration.FromNanoToSeconds()));
return(new SourceReaderExtra(this.FileName, this.State, reader));
}
static List <DataSample> GetIncidentsForward(IEnumerable <DataSample> samples, int sampleScanSettle, int maxTotalIncidents)
{
TraceDebug.WriteLine("Scanning for incidents forwards from start");
return(IncidentsSupport.FindIncidents(
samples.TakeWhile(data => data.Telemetry.SessionState != SessionState.CoolDown),
sampleScanSettle,
maxTotalIncidents));
}
private void Default_SettingChanging(object sender, System.Configuration.SettingChangingEventArgs e)
{
try
{
TraceDebug.WriteLine("Setting Changed: key: {0}, name: {1}, value: {2}".F(e.SettingKey, e.SettingName, e.NewValue));
}
catch (Exception ex)
{
TraceDebug.WriteLine("Unable to log setting change");
TraceDebug.WriteLine(ex.Message);
}
}
void LogDeviceInformation(string stringIn)
{
var mc = new ManagementClass(stringIn);
var instances = mc.GetInstances();
var properties = mc.Properties;
foreach (var instance in instances)
{
foreach (var property in properties)
{
TraceDebug.WriteLine("{0}: {1}".F(property.Name, GetValue(() => instance.Properties[property.Name].Value.ToString())));
}
}
}
private static void CopyFromOldSettings(Settings settings)
{
var pp = settings.Providers.OfType <IracingReplayDirectorProvider>().First();
var currentValues = new Dictionary <string, object>();
foreach (SettingsProperty p in settings.Properties)
{
currentValues[p.Name] = settings[p.Name];
TraceDebug.WriteLine("Capturing settings -- {0}: {1}", p.Name, currentValues[p.Name]);
p.Provider = pp;
}
settings.Reload();
foreach (var kv in currentValues)
{
settings[kv.Key] = kv.Value;
}
settings.NewSettings = true;
settings.Save();
}
MediaType CreateTargetAudioMediaType(MediaType nativeMediaType)
{
var numberOfChannels = nativeMediaType.AudioNumberOfChannels;
var sampleRate = nativeMediaType.AudioSamplesPerSecond;
var availableTypes = MFSystem.TranscodeGetAudioOutputAvailableTypes(TARGET_AUDIO_FORMAT, MFT_EnumFlag.All);
TraceDebug.WriteLine("Searching for audio transcoding for sampleRate of {0}khz and {1} channels".F(sampleRate / 1000, numberOfChannels));
var type = availableTypes
.OrderByDescending(t => t.AudioAverageBytesPerSecond)
.ThenByDescending(t => t.AudioNumberOfChannels)
.FirstOrDefault(t => t.AudioSamplesPerSecond == sampleRate && t.AudioNumberOfChannels == numberOfChannels);
if (type == null)
{
TraceDebug.WriteLine("No audio transcoder found. Searching for transcoding with 2 or fewer channels at any sample rate");
type = availableTypes
.OrderByDescending(t => t.AudioAverageBytesPerSecond)
.ThenByDescending(t => t.AudioNumberOfChannels)
.FirstOrDefault(t => t.AudioNumberOfChannels <= 2);
}
if (type == null)
{
TraceDebug.WriteLine("No audio transcoder found. Search for first compatible transcoder");
type = availableTypes
.OrderByDescending(t => t.AudioAverageBytesPerSecond)
.ThenByDescending(t => t.AudioNumberOfChannels)
.FirstOrDefault();
}
if (type != null)
{
TraceDebug.WriteLine("Found audio track. SampleRate: {0}, Channels: {1}, BitRate: {2}kbs".F(type.AudioSamplesPerSecond / 1000, type.AudioNumberOfChannels, type.AudioAverageBytesPerSecond * 8 / 1000));
return(new MediaType(type));
}
throw new Exception("Unable to find target audio format");
}
//worker thread to switch cameras.
private void CameraSwitcherWorkerTask()
{
for (var iCamDriverIndex = 0; iCamDriverIndex < overlayData.CamDrivers.Count; iCamDriverIndex++)
{
//get object of current CamDriver
var curCamDriver = overlayData.CamDrivers[iCamDriverIndex];
//Set camera to current camDriver Object
ReplayControl.cameraControl.CameraOnDriver(short.Parse(curCamDriver.CurrentDriver.CarNumber), (short)curCamDriver.camGroupNumber);
//remember start-time of current camers
double startTimeCurCamera = curCamDriver.StartTime;
try
{
double startTimeNextCamera = overlayData.CamDrivers[iCamDriverIndex + 1].StartTime;
int camDuration = (int)(1000 * (startTimeNextCamera - startTimeCurCamera));
TraceDebug.WriteLine("Camera switched to driver {0} using camera-group {1}. Remaining Time: {2}".F(curCamDriver.CurrentDriver.UserName, curCamDriver.camGroupNumber, camDuration));
Thread.Sleep(camDuration);
}
catch
{
TraceDebug.Write("No more entries in list of CamDriver -> no more camera switches");
}
}
}
//Analyse race situations at maximum replay speed w/o recording.
void AnalyseRaceSituations(IEnumerable <DataSample> samples)
{
int iReplaySpeedForAnalysis = (int)replaySpeeds.FF16x; //set speed for analysis phase to FF16x
//Start iRacing Replay from the beginning with maximum speed (16x)
iRacing.Replay.MoveToFrame(raceStartFrameNumber);
//----------------------------
// copied from iRacing.Capturing because race events in app V1.0.x.x are identified during capturing the whole video.
// necessity of classes in analysis phase to be reviewed
//----------------------------
//var overlayData = new OverlayData();
removalEdits = new RemovalEdits(overlayData.RaceEvents);
commentaryMessages = new CommentaryMessages(overlayData);
recordPitStop = new RecordPitStop(commentaryMessages);
fastestLaps = new RecordFastestLaps(overlayData);
replayControl = new ReplayControl(samples.First().SessionData, incidents, removalEdits, TrackCameras);
sessionDataCapture = new SessionDataCapture(overlayData);
//CAPTURING LEADERBOARD, CAMERAS will be done at FF16x. TO BE DETERMINED WHETHER STANDARD INTERVALS HAVE TO BE REDUCED BY FACTOR OF 16?!
captureLeaderBoardEveryHalfSecond = new SampleFilter(TimeSpan.FromSeconds(0.5),
new CaptureLeaderBoard(overlayData, commentaryMessages, removalEdits).Process);
captureCamDriverEveryQuaterSecond = new SampleFilter(TimeSpan.FromSeconds(0.25),
new CaptureCamDriver(overlayData).Process);
captureCamDriverEvery4Seconds = new SampleFilter(TimeSpan.FromSeconds(4),
new LogCamDriver().Process);
//----------------------------
//end copy / end review
//----------------------------
ApplyFirstLapCameraDirection(samples, replayControl);
samples = samples
.VerifyReplayFrames()
.WithCorrectedPercentages()
.WithCorrectedDistances()
.WithFastestLaps()
.WithFinishingStatus()
.WithPitStopCounts()
.TakeUntil(3.Seconds()).Of(d => d.Telemetry.LeaderHasFinished && d.Telemetry.RaceCars.All(c => c.HasSeenCheckeredFlag || c.HasRetired || c.TrackSurface != TrackLocation.OnTrack))
.TakeUntil(3.Seconds()).AfterReplayPaused();
samples = samples.AtSpeed(iReplaySpeedForAnalysis);
overlayData.CapturedVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
ulong numberOfDataProcessed = 0;
var startTime = DateTime.Now;
foreach (var data in samples)
{
var relativeTime = (DateTime.Now - startTime).Multiply(iReplaySpeedForAnalysis); //calculate relative time in Replay taking into account replay speed (FF)
replayControl.Process(data);
sessionDataCapture.Process(data);
captureLeaderBoardEveryHalfSecond.Process(data, relativeTime);
captureCamDriverEveryQuaterSecond.Process(data, relativeTime);
recordPitStop.Process(data, relativeTime);
fastestLaps.Process(data, relativeTime);
removalEdits.Process(data, relativeTime);
captureCamDriverEvery4Seconds.Process(data, relativeTime);
numberOfDataProcessed += 1;
}
removalEdits.Stop();
TraceDebug.WriteLine("Race analysis phase completed. {0} data samples processed with replay speed {1}".F(numberOfDataProcessed, iReplaySpeedForAnalysis));
//save OverlayData into target folder for video ("working folder")
SaveReplayScript(overlayData);
TraceDebug.WriteLine("Replay Script saved to disk");
iRacing.Replay.SetSpeed(0);
}
void ReplaySearch(ReplaySearchMode mode)
{
TraceDebug.WriteLine("Replay Search {0}", mode.ToString());
SendMessage(BroadcastMessage.ReplaySearch, (short)mode);
}
static bool IsAPerferredDriver(GapMetric d)
{
TraceDebug.WriteLine("IsAPreferred Driver called for carIdx {0} Preferred: {1}, Leader: {2} : return: {3}", d.CarIdx, preferredCarIdxs.Contains(d.CarIdx), preferredCarIdxs.Contains(d.LeaderCarIdx), preferredCarIdxs.Contains(d.CarIdx) || preferredCarIdxs.Contains(d.LeaderCarIdx));
return(preferredCarIdxs.Contains(d.CarIdx)); /* || preferredCarIdxs.Contains(d.LeaderCarIdx);*/
}
internal void _CaptureRaceTest(Action <string> onComplete, IEnumerable <DataSample> samples)
{
var overlayData = new OverlayData();
var removalEdits = new RemovalEdits(overlayData.RaceEvents);
var commentaryMessages = new CommentaryMessages(overlayData);
var videoCapture = new VideoCapture();
var recordPitStop = new RecordPitStop(commentaryMessages);
var fastestLaps = new RecordFastestLaps(overlayData);
var replayControl = new ReplayControl(samples.First().SessionData, incidents, removalEdits, TrackCameras);
var sessionDataCapture = new SessionDataCapture(overlayData);
var captureLeaderBoardEveryHalfSecond = new SampleFilter(TimeSpan.FromSeconds(0.5),
new CaptureLeaderBoard(overlayData, commentaryMessages, removalEdits).Process);
var captureCamDriverEveryQuaterSecond = new SampleFilter(TimeSpan.FromSeconds(0.25),
new CaptureCamDriver(overlayData).Process);
var captureCamDriverEvery4Seconds = new SampleFilter(TimeSpan.FromSeconds(4),
new LogCamDriver().Process);
TraceDebug.WriteLine("Cameras:");
TraceDebug.WriteLine(TrackCameras.ToString());
ApplyFirstLapCameraDirection(samples, replayControl);
samples = samples
.VerifyReplayFrames()
.WithCorrectedPercentages()
.WithCorrectedDistances()
.WithFastestLaps()
.WithFinishingStatus()
.WithPitStopCounts()
.TakeUntil(3.Seconds()).Of(d => d.Telemetry.LeaderHasFinished && d.Telemetry.RaceCars.All(c => c.HasSeenCheckeredFlag || c.HasRetired || c.TrackSurface != TrackLocation.OnTrack))
.TakeUntil(3.Seconds()).AfterReplayPaused();
if (shortTestOnly)
{
samples = samples.AtSpeed(Settings.Default.TimingFactorForShortTest);
Settings.AppliedTimingFactor = 1.0 / Settings.Default.TimingFactorForShortTest;
}
videoCapture.Activate(workingFolder);
var startTime = DateTime.Now;
overlayData.CapturedVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
foreach (var data in samples)
{
var relativeTime = DateTime.Now - startTime;
replayControl.Process(data);
sessionDataCapture.Process(data);
captureLeaderBoardEveryHalfSecond.Process(data, relativeTime);
captureCamDriverEveryQuaterSecond.Process(data, relativeTime);
recordPitStop.Process(data, relativeTime);
fastestLaps.Process(data, relativeTime);
removalEdits.Process(data, relativeTime);
captureCamDriverEvery4Seconds.Process(data, relativeTime);
}
var files = videoCapture.Deactivate();
removalEdits.Stop();
var overlayFile = SaveOverlayData(overlayData, files);
//terminate iRacing after video capture completed
try
{
//ToBe added: Option to select/deselect termination of iRacing after capturing video in new settings Dialog
Process[] iRacingProc = Process.GetProcessesByName("iRacingSim64DX11");
iRacingProc[0].Kill();
}
catch
{
throw new Exception("Could not terminate iRacing Simulator".F(workingFolder));
}
iRacing.Replay.SetSpeed(0);
AltTabBackToApp();
if (files.Count == 0)
{
throw new Exception("Unable to find video files in '{0}' - possible wrong working folder".F(workingFolder));
}
_WithOverlayFile(overlayFile);
onComplete(overlayFile);
}
/// <summary>
/// Assumes the game is in paused mode
/// Filters the samples to just single frame numbers, that the game moves after invoking the moveReplay action (eg: which sends message to the game - MoveToNextIncident)
/// If the game does not advance to another frame within about 1second, it will stop enumerating
/// </summary>
/// <param name="samples"></param>
/// <param name="moveReplay"></param>
/// <param name="sampleScanSettle">The number of samples to take, which must all have the same frame number - to identify that iRacing has paused.</param>
/// <returns></returns>
static IEnumerable <DataSample> PositionsOf(this IEnumerable <DataSample> samples, int sampleScanSettle)
{
var lastSamples = new List <int>();
var lastFrameNumber = -2;
Func <DataSample, states> waitForMessage = ignored => states.RequestPaceCar;
foreach (var dx in samples)
{
switch (waitForMessage(dx))
{
case states.Continue:
break;
case states.RequestPaceCar:
iRacing.Replay.NoWait.CameraOnDriver(0, 0);
waitForMessage = d => d.Telemetry.CamCarIdx == 0 ? states.RequestNextIncident : states.Continue;
break;
case states.RequestNextIncident:
iRacing.Replay.NoWait.MoveToNextIncident();
waitForMessage = d =>
{
lastSamples.Add(d.Telemetry.ReplayFrameNum);
if (lastSamples.Count == sampleScanSettle)
{
lastSamples.RemoveAt(0);
}
if (lastSamples.Count == (sampleScanSettle - 1) && lastSamples.All(f => f == d.Telemetry.ReplayFrameNum))
{
if (d.Telemetry.ReplayFrameNum == lastFrameNumber)
{
TraceDebug.WriteLine("Incidents: Frame number did not change - asuming no more incidents. Current Frame: {0}", d.Telemetry.ReplayFrameNum);
return(states.Break);
}
if (d.Telemetry.CamCarIdx == 0) //Pace Car
{
TraceWarning.WriteLine("Incident scan aborted - iRacing has not progressed to incident. Frame Number: {0}", d.Telemetry.ReplayFrameNum);
return(states.Break);
}
lastFrameNumber = d.Telemetry.ReplayFrameNum;
TraceDebug.WriteLine("Incidents: last {0} samples have settled on frame number {1}", sampleScanSettle, d.Telemetry.ReplayFrameNum);
lastSamples.Add(-1);
lastSamples.RemoveAt(0);
return(states.Yield);
}
;
return(states.Continue);
};
break;
case states.Yield:
yield return(dx);
waitForMessage = ignored => states.RequestPaceCar;
break;
case states.Break:
yield break;
}
}
}
internal void _CaptureRaceTest(Action <string> onComplete, IEnumerable <DataSample> samples)
{
//identify wheather highlights video only is selected and OBS pause/resume can be used (to be implemented)
if (bRecordUsingPauseResume)
{
//Retrieve list of raceEvents selected depending on the duration of the highlight video
var totalRaceEvents = RaceEventExtension.GetInterestingRaceEvents(overlayData.RaceEvents.ToList());
ApplyFirstLapCameraDirection(samples, replayControl);
//Record the selected race events into a highlight video
raceVideo.Activate(workingFolder); //Active video-capturing and send start command to recording software.
OverlayData.CamDriver curCamDriver = overlayData.CamDrivers.First();
//start thread to control / switch cameras while recording
ReplayControl.cameraControl.ReplayCameraControlTask(overlayData);
//ReplayControl.cameraControl.CameraOnDriver(short.Parse(curCamDriver.CurrentDriver.CarNumber), (short)curCamDriver.camGroupNumber);
//cycle through all raceEvents selected for the highlight video and record them (REMARK: Camera switching not implemented yet)
foreach (var raceEvent in totalRaceEvents)
{
TraceInfo.WriteLine("ADV_RECORDING: Type: {0} | Durations-Span: {1} | ".F(raceEvent.GetType(), raceEvent.Duration));
//jump to selected RaceEvent in iRacing Replay
int framePositionInRace = raceStartFrameNumber + (int)Math.Round(raceEvent.StartTime * 60.0);
iRacing.Replay.MoveToFrame(raceStartFrameNumber + (int)Math.Round(raceEvent.StartTime * 60.0));
iRacing.Replay.SetSpeed((int)replaySpeeds.normal); //start iRacing Replay at selected position
raceVideo.Resume(); //resume recording
TraceDebug.WriteLine("Recording Race-Event. Frame-Position: {0} | Duration: {1} ms".F(framePositionInRace, 1000 * raceEvent.Duration));
Thread.Sleep((int)(1000 * raceEvent.Duration)); //pause thread until scene is fully recorded.
raceVideo.Pause(); //pause recording software before jumping to new position in iRacing Replay
}
TraceDebug.WriteLine("Video Capture of Race-Events completed");
raceVideo.Stop();
}
else //Code to be removed after being able to implment working solution where analysis phase and replay-capture phase are distinct processes.
//use local variables for original code instead of global variables introduced to support full analysis in analysis-phase
{
var overlayData = new OverlayData();
var removalEdits = new RemovalEdits(overlayData.RaceEvents);
var commentaryMessages = new CommentaryMessages(overlayData);
var recordPitStop = new RecordPitStop(commentaryMessages);
var fastestLaps = new RecordFastestLaps(overlayData);
var replayControl = new ReplayControl(samples.First().SessionData, incidents, removalEdits, TrackCameras);
var sessionDataCapture = new SessionDataCapture(overlayData);
var captureLeaderBoardEveryHalfSecond = new SampleFilter(TimeSpan.FromSeconds(0.5),
new CaptureLeaderBoard(overlayData, commentaryMessages, removalEdits).Process);
var captureCamDriverEveryQuaterSecond = new SampleFilter(TimeSpan.FromSeconds(0.25),
new CaptureCamDriver(overlayData).Process);
var captureCamDriverEvery4Seconds = new SampleFilter(TimeSpan.FromSeconds(4),
new LogCamDriver().Process);
TraceDebug.WriteLine("Cameras:");
TraceDebug.WriteLine(TrackCameras.ToString());
var videoCapture = new VideoCapture();
ApplyFirstLapCameraDirection(samples, replayControl);
samples = samples
.VerifyReplayFrames()
.WithCorrectedPercentages()
.WithCorrectedDistances()
.WithFastestLaps()
.WithFinishingStatus()
.WithPitStopCounts()
.TakeUntil(3.Seconds()).Of(d => d.Telemetry.LeaderHasFinished && d.Telemetry.RaceCars.All(c => c.HasSeenCheckeredFlag || c.HasRetired || c.TrackSurface != TrackLocation.OnTrack))
.TakeUntil(3.Seconds()).AfterReplayPaused();
if (shortTestOnly)
{
samples = samples.AtSpeed(Settings.Default.TimingFactorForShortTest);
Settings.AppliedTimingFactor = 1.0 / Settings.Default.TimingFactorForShortTest;
}
videoCapture.Activate(workingFolder); //Start video capturing FileName will be given by recording software.
var startTime = DateTime.Now;
overlayData.CapturedVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
foreach (var data in samples)
{
var relativeTime = DateTime.Now - startTime;
TraceDebug.WriteLine("Recording at time: {0}", relativeTime);
replayControl.Process(data);
sessionDataCapture.Process(data);
captureLeaderBoardEveryHalfSecond.Process(data, relativeTime);
captureCamDriverEveryQuaterSecond.Process(data, relativeTime);
recordPitStop.Process(data, relativeTime);
fastestLaps.Process(data, relativeTime);
removalEdits.Process(data, relativeTime);
captureCamDriverEvery4Seconds.Process(data, relativeTime);
}
var files = videoCapture.Deactivate(); //Stop video capturing - returns list with "guessed" filename. Filenmae being different from replay-script due to different time stamp.
//investigate whether renaming of video file is necessary.
removalEdits.Stop();
var overlayFile = SaveOverlayData(overlayData, files);
iRacing.Replay.SetSpeed(0);
AltTabBackToApp();
if (files.Count == 0)
{
throw new Exception("Unable to find video files in '{0}' - possible wrong working folder".F(workingFolder));
}
_WithOverlayFile(overlayFile);
onComplete(overlayFile);
}
//terminate iRacing after video capture completed to free up CPU resources
if (bCloseiRacingAfterRecording)
{
try
{
//To be added: Option to select/deselect termination of iRacing after capturing video in new settings Dialog
Process[] iRacingProc = Process.GetProcessesByName("iRacingSim64DX11");
iRacingProc[0].Kill();
}
catch
{
throw new Exception("Could not terminate iRacing Simulator".F(workingFolder));
}
}
}