public void Evaluate(int SpreadMax)
{
if (FInDevice.IsChanged || FInMode.IsChanged || FInFormat.IsChanged || FInUsage.IsChanged || FInHandle.IsChanged || FInEnabled.IsChanged || FInSyncLoop.IsChanged || FInSyncLoop.IsChanged)
{
foreach (var slice in FInstances)
{
if (slice != null)
{
slice.Dispose();
}
}
FInstances.SliceCount = 0;
FOutStatus.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
try
{
if (FInDevice[i] == null)
{
throw (new Exception("No device selected"));
}
if (FInMode[i] == null)
{
throw (new Exception("No mode selected"));
}
if (FInEnabled[i] == false)
{
throw (new Exception("Disabled"));
}
FInstances.Add(new Instance(FInDevice[i].Index, FInMode[i].Index, FInHandle[i], FInFormat[i], FInUsage[i], FInSyncLoop[i]));
FOutStatus[i] = "OK";
}
catch (Exception e)
{
FInstances.Add(null);
FOutStatus[i] = e.Message;
}
}
}
FOutFramesInBuffer.SliceCount = FInstances.SliceCount;
for (int i = 0; i < FInstances.SliceCount; i++)
{
if (FInstances[i] == null)
{
FOutFramesInBuffer[i] = 0;
}
else
{
FOutFramesInBuffer[i] = FInstances[i].FramesInBuffer;
}
}
}
public void Evaluate(int SpreadMax)
{
if (FInDevice.IsChanged || FInFramerate.IsChanged || FInChannel.IsChanged || FInChannels.IsChanged)
{
foreach (var instance in FInstances)
{
if (instance != null)
{
instance.Dispose();
}
}
FInstances.SliceCount = 0;
FOutStatus.SliceCount = SpreadMax;
FOutTimecode.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
try
{
var instance = new DecodeInstance(FInDevice[i], FInChannels[i], FInChannel[i], FInFramerate[i]);
FInstances.Add(instance);
FOutStatus[i] = "OK";
}
catch (Exception e)
{
FInstances.Add(null);
FOutStatus[i] = e.Message;
}
}
}
for (int i = 0; i < FInstances.SliceCount; i++)
{
if (FInstances[i] != null)
{
try
{
FOutTimecode[i] = FInstances[i].Timecode;
}
catch
{
}
}
else
{
FOutTimecode[i] = null;
}
}
}
private void CheckChanges()
{
if (FCaptures.SliceCount != FPinInCameraID.SliceCount)
{
while (FCaptures.SliceCount < FPinInCameraID.SliceCount)
{
FCaptures.Add <CaptureVideoInstance>(new CaptureVideoInstance());
}
for (int iDispose = FPinInCameraID.SliceCount; iDispose < FCaptures.SliceCount; iDispose++)
{
FCaptures[iDispose].Dispose();
}
FCaptures.SliceCount = FPinInCameraID.SliceCount;
}
for (int i = 0; i < FPinInCameraID.SliceCount; i++)
{
if (FCaptures[i] == null)
{
FCaptures[i] = new CaptureVideoInstance();
}
FCaptures[i].Initialise(FPinInCameraID[i], FPinInWidth[i], FPinInHeight[i]);
}
}
void CheckSliceCount(int SpreadMax)
{
if (SpreadMax == FInstances.SliceCount)
{
return;
}
for (int i = FInstances.SliceCount; i < SpreadMax; i++)
{
FInstances.Add(new ImageInstance());
}
for (int i = SpreadMax; i < FInstances.SliceCount; i++)
{
FInstances[i] = null;
FInstances.RemoveAt(i);
}
FPinOutImageDepth.SliceCount = SpreadMax;
FPinOutImageImage.SliceCount = SpreadMax;
FPinOutImageWorld.SliceCount = SpreadMax;
FPinOutStatus.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FPinOutImageDepth[i] = FInstances[i].Depth.Link;
FPinOutImageImage[i] = FInstances[i].Image.Link;
FPinOutImageWorld[i] = FInstances[i].World.Link;
}
}
private void Add(CVImageInput input)
{
T addition = new T();
addition.SetInput(input);
FProcess.Add(addition);
}
public void TestSingleAdd()
{
var spread = new Spread <int>(0);
spread.Add(10);
Assert.AreEqual(1, spread.SliceCount);
Assert.AreEqual(10, spread[0]);
}
public void Evaluate(int SpreadMax)
{
if (this.FTexIn.IsConnected)
{
binSize = FIndex.SliceCount;
// manage generators
if (generators.SliceCount > binSize)
{
for (int i = generators.SliceCount; i > binSize; i--)
{
generators[i].Dispose();
}
}
if (generators.SliceCount < binSize)
{
for (int i = generators.SliceCount; i < binSize; i++)
{
generators.Add(new DX11Resource <CopySubArray>());
}
}
// manage TextureOutput(s)
if (this.FTextureOutput.SliceCount > binSize)
{
for (int t = binSize; t < this.FTextureOutput.SliceCount; t++)
{
if (this.FTextureOutput[t] != null)
{
this.FTextureOutput[t].Dispose();
}
}
}
FTextureOutput.SliceCount = binSize;
for (int i = 0; i < binSize; i++)
{
if (this.FTextureOutput[i] == null)
{
this.FTextureOutput[i] = new DX11Resource <DX11RenderTextureArray>();
}
}
}
else
{
for (int i = 0; i < FTextureOutput.SliceCount; i++)
{
if (this.FTextureOutput[i] != null)
{
this.FTextureOutput[i].Dispose();
}
}
FTextureOutput.SliceCount = 0;
}
}
private void Add(CVImageInput input)
{
CVImageOutput output = new CVImageOutput();
T addition = new T();
addition.SetInput(input);
FProcess.Add(addition);
}
private void Add()
{
CVImageOutput output = new CVImageOutput();
T addition = new T();
addition.SetOutput(output);
FProcess.Add(addition);
FOutput.Add(output);
}
public override Spread <VObject> ToSpread(VObjectDictionaryWrap Source)
{
Spread <VObject> Out = new Spread <VObject>();
VObjectDictionary Content = Source.Content as VObjectDictionary;
Out.SliceCount = 0;
foreach (KeyValuePair <string, VObjectCollectionWrap> kvp in Content.Objects)
{
Out.Add(kvp.Value);
}
return(Out);
}
public static void Split(KeyState keyState, out ISpread <int> keys, out int time)
{
keys = new Spread <int>();
Keys keyCode = keyState.KeyCode;
if ((keyCode & Keys.Shift) > 0)
{
keys.Add((int)Keys.ShiftKey);
}
if ((keyCode & Keys.Control) > 0)
{
keys.Add((int)Keys.ControlKey);
}
if ((keyCode & Keys.Alt) > 0)
{
keys.Add((int)Keys.Menu);
}
if ((keyCode & ~Keys.Modifiers) != Keys.None)
{
keys.Add((int)(keyCode & ~Keys.Modifiers));
}
time = keyState.Time;
}
public void TestMultipleAdd()
{
var spread = new Spread <int>(0);
for (int i = 0; i < sampleData.Length; i++)
{
spread.Add(sampleData[i]);
}
Assert.AreEqual(sampleData.Length, spread.SliceCount);
for (int i = 0; i < sampleData.Length; i++)
{
Assert.AreEqual(sampleData[i], spread[i]);
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FClear[0])
{
FOut.SliceCount = 0;
}
if (FFlush[0])
{
FOut.AssignFrom(FIn);
}
if (PinChanged())
{
Spread <Spread <T> > buffer = new Spread <Spread <T> >(0);
int incr = 0, sum = 0;
while (!(sum >= FOut.SliceCount && (incr % FBinSize.SliceCount) == 0))
{
buffer.Add((Spread <T>)FOut.GetRange(sum, FBinSize[incr]));
sum += FBinSize[incr];
incr++;
}
incr = 0;
for (int i = 0; i < FId.SliceCount; i++)
{
int binSize = 1;
try
{
binSize = buffer[FId[i]].SliceCount;
}
catch
{
binSize = FBinSize[FId[i]];
}
Alter(i, incr, binSize, ref buffer);
incr += binSize;
}
FOut.SliceCount = 0;
foreach (Spread <T> t in buffer)
{
FOut.AddRange(t);
}
}
}
public override Spread <object> ToSpread(object Source)
{
if (Source is VObjectCollection)
{
Spread <object> Out = new Spread <object>();
VObjectCollection Content = Source as VObjectCollection;
Out.SliceCount = 0;
foreach (KeyValuePair <string, object> kvp in Content.Children)
{
Out.Add(kvp.Value);
}
return(Out);
}
else
{
Spread <object> Out = new Spread <object>();
Out.SliceCount = 0;
return(Out);
}
}
void CheckSliceCount(int SpreadMax)
{
if (SpreadMax == FState.SliceCount)
{
return;
}
for (int i = FState.SliceCount; i < SpreadMax; i++)
{
FState.Add <Device>(new Device());
}
for (int i = SpreadMax; i < FState.SliceCount; i++)
{
FState[i] = null;
FState.RemoveAt <Device>(i);
}
FPinOutContext.SliceCount = FState.SliceCount;
FPinOutStatus.SliceCount = FState.SliceCount;
}
public virtual void Alter(int i, int incr, int binSize, ref Spread <Spread <T> > buffer)
{
if (FSet[i] && buffer.SliceCount > 0)
{
buffer[FId[i]] = (Spread <T>)FIn.GetRange(incr, binSize);
}
if (FRemove[i] && buffer.SliceCount > 0)
{
buffer.RemoveAt(FId[i]);
}
if (FInsert[i])
{
int id = VMath.Zmod(FId[i], buffer.SliceCount + 1);
if (buffer.SliceCount > 0 || id < buffer.SliceCount)
{
buffer.Insert(id, (Spread <T>)FIn.GetRange(incr, binSize));
}
else
{
buffer.Add((Spread <T>)FIn.GetRange(incr, binSize));
}
}
}
void FillFrameList(BitmapDecoder decoder)
{
//continue if loaded
Progress = 1;
var list = new List<FrameData>(decoder.Frames.Count);
var delaySpread = new Spread<int>(0);
var positionSpread = new Spread<Vector2D>(0);
var sizeSpread = new Spread<Vector2D>(0);
var disposalSpread = new Spread<GifDisposal>(0);
Format = decoder.Frames[0].Format;
//convert and copy frames
foreach (var frame in decoder.Frames)
{
//read meta data
if(!frame.IsFrozen)
frame.Freeze();
var meta = frame.Metadata as BitmapMetadata;
if(meta != null)
{
if(meta.ContainsQuery("/grctlext/Delay"))
delaySpread.Add((ushort)meta.GetQuery("/grctlext/Delay"));
else
delaySpread.Add(0);
if(meta.ContainsQuery("/grctlext/Disposal"))
disposalSpread.Add((GifDisposal)((byte)meta.GetQuery("/grctlext/Disposal")));
else
disposalSpread.Add(GifDisposal.None);
var left = (ushort)0;
var top = (ushort)0;
if(meta.ContainsQuery("/imgdesc/Left"))
left = (ushort)meta.GetQuery("/imgdesc/Left");
if(meta.ContainsQuery("/imgdesc/Top"))
top = (ushort)meta.GetQuery("/imgdesc/Top");
positionSpread.Add(new Vector2D(left, top));
}
sizeSpread.Add(new Vector2D(frame.PixelWidth, frame.PixelHeight));
var convertedBitmap = new FormatConvertedBitmap();
convertedBitmap.BeginInit();
convertedBitmap.Source = frame;
convertedBitmap.DestinationFormat = PixelFormats.Bgra32;
convertedBitmap.EndInit();
list.Add(CopyBitmapFrameToFrameData(convertedBitmap));
}
FFrameDataList = list;
//recreate texture resources
FTextureSpread.ResizeAndDispose(FFrameDataList.Count, i => CreateTextureResource(i));
DelaySpread = delaySpread;
PositionSpread = positionSpread;
SizeSpread = sizeSpread;
DisposalSpread = disposalSpread;
IsLoading = false;
HasNewData = true;
}
public ISpread <Frame> Preload(
ISpread <int> visibleFrameIndices,
ISpread <int> preloadFrameNrs,
int bufferSize,
out int frameCount,
out double durationIO,
out double durationTexture,
out int unusedFrames,
ref ISpread <bool> loadedFrames)
{
frameCount = FFiles.Length;
durationIO = 0.0;
durationTexture = 0.0;
unusedFrames = 0;
// Nothing to do
if (FFiles.Length == 0)
{
loadedFrames.SliceCount = 0;
return(new Spread <Frame>(0));
}
// Map frame numbers to file names
var preloadFiles = preloadFrameNrs.Select(frameNr => FFiles[VMath.Zmod(frameNr, FFiles.Length)]).ToArray();
// Dispose previously loaded frames
foreach (var file in FPreloadedFrames.Keys.ToArray())
{
if (!preloadFiles.Contains(file))
{
var frame = FPreloadedFrames[file];
Dispose(frame);
}
}
// Ensure that there are as much dequeues as enqueues (or we'll run out of memory)
while (FScheduledFrameInfos.Count > preloadFrameNrs.SliceCount)
{
var frame = Dequeue();
var frameInfo = frame.Metadata;
if (!preloadFiles.Contains(frameInfo.Filename) || frameInfo.IsCanceled)
{
// Not needed anymore
Dispose(frame);
unusedFrames++;
}
else
{
FPreloadedFrames.Add(frameInfo.Filename, frame);
}
}
// Cancel unused scheduled frames
foreach (var frameInfo in FScheduledFrameInfos.Where(fi => !fi.IsCanceled))
{
if (!preloadFiles.Contains(frameInfo.Filename))
{
frameInfo.Cancel();
}
}
// Free resources if there're no frames to preload and we didn't free them yet
if (preloadFiles.Length == 0 && !FClearedMemoryPool)
{
FMemoryPool.Clear();
// Remember that we cleared the pool
FClearedMemoryPool = true;
}
// Schedule new frames
foreach (var file in preloadFiles)
{
if (!IsScheduled(file) && !IsPreloaded(file))
{
var frameInfo = CreateFrameInfo(file, bufferSize);
Enqueue(frameInfo);
}
// We're back using resources from the pool -> not clean anymore
FClearedMemoryPool = false;
}
// Write the "is loaded" state
loadedFrames.SliceCount = preloadFrameNrs.SliceCount;
for (int i = 0; i < loadedFrames.SliceCount; i++)
{
var file = preloadFiles[i];
if (!IsPreloaded(file))
{
var frameInfo = FScheduledFrameInfos.First(fi => fi.Filename == file);
loadedFrames[i] = frameInfo.IsLoaded;
}
else
{
loadedFrames[i] = true;
}
}
// Wait for the visible frames (and dipose unused ones)
var visibleFrames = new Spread <Frame>(0);
// Map frame numbers to file names
var visibleFiles = preloadFiles.Length > 0 ? visibleFrameIndices.Select(i => preloadFiles[VMath.Zmod(i, preloadFiles.Length)]) : Enumerable.Empty <string>();
foreach (var file in visibleFiles)
{
while (!IsPreloaded(file))
{
var frame = Dequeue();
var frameInfo = frame.Metadata;
if (!preloadFiles.Contains(frameInfo.Filename) || frameInfo.IsCanceled)
{
// Not needed anymore
Dispose(frame);
unusedFrames++;
}
else
{
FPreloadedFrames.Add(frameInfo.Filename, frame);
}
}
var visibleFrame = FPreloadedFrames[file];
var visibleFrameInfo = visibleFrame.Metadata;
durationIO += visibleFrameInfo.DurationIO;
durationTexture += visibleFrameInfo.DurationTexture;
visibleFrames.Add(visibleFrame);
}
// Release textures of non visible frames
foreach (var frame in FPreloadedFrames.Values.Where(f => !visibleFrames.Contains(f)))
{
frame.Dispose();
}
return(visibleFrames);
}
public void Add(CVImageOutput output)
{
FOutput.Add(output);
}
public ISpread <Frame> Preload(
ISpread <int> visibleFrameIndices,
ISpread <int> preloadFrameNrs,
int bufferSize,
EX9.Format preferedFormat,
out int frameCount,
out double durationIO,
out double durationTexture,
out int unusedFrames,
ref ISpread <bool> loadedFrames)
{
var files = FFiles;
frameCount = files.Length;
durationIO = 0.0;
durationTexture = 0.0;
unusedFrames = 0;
// Nothing to do
if (files.Length == 0)
{
loadedFrames.SliceCount = 0;
return(new Spread <Frame>(0));
}
// Map frame numbers to file names
var preloadFiles = preloadFrameNrs.Select(
frameNr =>
{
var fileName = files[VMath.Zmod(frameNr, files.Length)];
return(CreateFrameInfo(fileName, bufferSize, preferedFormat));
})
.ToArray();
// Dispose previously loaded frames
foreach (var file in FPreloadedFrames.Keys.ToArray())
{
if (!preloadFiles.Contains(file))
{
var frame = FPreloadedFrames[file];
Dispose(frame);
}
}
// Ensure that there are as much dequeues as enqueues (or we'll run out of memory)
while (FScheduledFrameInfos.Count > preloadFrameNrs.SliceCount)
{
var frame = Dequeue();
var frameInfo = frame.Metadata;
if (!preloadFiles.Contains(frameInfo) || frameInfo.IsCanceled)
{
// Not needed anymore
Dispose(frame);
unusedFrames++;
}
else
{
FPreloadedFrames.Add(frameInfo, frame);
}
}
// Cancel unused scheduled frames
foreach (var frameInfo in FScheduledFrameInfos.Where(fi => !fi.IsCanceled))
{
if (!preloadFiles.Contains(frameInfo))
{
frameInfo.Cancel();
}
}
// Schedule new frames
foreach (var file in preloadFiles)
{
if (!IsScheduled(file) && !IsPreloaded(file))
{
Enqueue(file);
}
}
// Write the "is loaded" state
loadedFrames.SliceCount = preloadFrameNrs.SliceCount;
for (int i = 0; i < loadedFrames.SliceCount; i++)
{
var file = preloadFiles[i];
if (!IsPreloaded(file))
{
var frameInfo = FScheduledFrameInfos.First(fi => fi == file);
loadedFrames[i] = frameInfo.IsLoaded;
}
else
{
loadedFrames[i] = true;
}
}
// Wait for the visible frames (and dipose unused ones)
var visibleFrames = new Spread <Frame>(0);
// Map frame numbers to file names
var visibleFiles = preloadFiles.Length > 0
? visibleFrameIndices.Select(i => preloadFiles[VMath.Zmod(i, preloadFiles.Length)])
: Enumerable.Empty <FrameInfo>();
foreach (var file in visibleFiles)
{
while (!IsPreloaded(file))
{
var frame = Dequeue();
var frameInfo = frame.Metadata;
if (!preloadFiles.Contains(frameInfo) || frameInfo.IsCanceled)
{
// Not needed anymore
Dispose(frame);
unusedFrames++;
}
else
{
FPreloadedFrames.Add(frameInfo, frame);
}
}
var visibleFrame = FPreloadedFrames[file];
var visibleFrameInfo = visibleFrame.Metadata;
durationIO += visibleFrameInfo.DurationIO;
durationTexture += visibleFrameInfo.DurationTexture;
visibleFrames.Add(visibleFrame);
}
// Release textures of non visible frames
foreach (var frame in FPreloadedFrames.Values.Where(f => !visibleFrames.Contains(f)))
{
frame.Dispose();
}
return(visibleFrames);
}
public void Evaluate(int spreadMax)
{
FBuffer.ResizeAndDismiss(spreadMax, () => new Spread <double>());
FDelta.SliceCount = spreadMax;
//return null if one of the control inputs is null
if (FDoInsert.IsAnyEmpty(FFrameCount, FReset))
{
FOutput.SliceCount = 0;
return;
}
//Reset the BufferSlice
if (FReset.IsChanged)
{
for (int i = 0; i < spreadMax; i++)
{
if (FReset[i])
{
FBuffer[i] = new Spread <double>();
FDelta[i] = 0;
}
}
}
//
for (int i = 0; i < spreadMax; i++)
{
if (FDoInsert[i])
{
//insert new values to the buffer
FBuffer[i].Insert(0, FInput[i]);
//calculate the delta between the first an last slice
if (FBuffer[i].SliceCount > 0)
{
FDelta[i] = (FBuffer[i][0] - FBuffer[i][FBuffer[i].SliceCount - 1]);
}
}
else
{
if (FBuffer.SliceCount > 0)
{
if (FBuffer[i].SliceCount > 0)
{
//add a new caluclate slice via delta to the spread
Spread <double> MovedBuffer = new Spread <double>();
ISpread <double> MovedSpread = FBuffer[i].GetRange(0, FBuffer[i].SliceCount - 1);
double NewSlice = FBuffer[i][FBuffer[i].SliceCount - 1] + FDelta[i];
MovedBuffer.Add(NewSlice);
MovedBuffer.AddRange(MovedSpread);
FBuffer[i] = MovedBuffer;
}
}
}
//remove slices from the Buffer if the framecount gets smaller
if (FFrameCount.IsChanged)
{
if (FFrameCount[i] >= 0 && FBuffer[i].SliceCount > FFrameCount[i])
{
FBuffer[i].RemoveRange(FFrameCount[i], FBuffer[i].SliceCount - FFrameCount[i]);
}
}
}
//set the output pins
FDeltaOut.AssignFrom(FDelta as ISpread <double>);
FOutput.AssignFrom(FBuffer);
}
