#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid())
{
SpreadMax = 0;
if (FOutput.SliceCount != 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (!FInput.IsChanged && !FTopicAdd.IsChanged && !FContract.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
Message message = OSCExtensions.FromOSC(FInput[i], FExtendedMode[0], FTopicAdd[0], FContract[0]);
if (message != null)
{
FOutput.Add(message);
}
}
FOutput.Flush();
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid() || FIndex.IsAnyInvalid())
{
if (FOutput.SliceCount > 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
if (!FInput.IsChanged && !FIndex.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
var search = from message in FInput
let track = (message["TrackId"] as Bin <int>).First
where FIndex.Contains(track)
select message;
FOutput.AssignFrom(search);
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid() || FExtendedMode.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
if (FOutput.SliceCount != 0)
{
FOutput.SliceCount = 0;
FOutput.Flush();
}
return;
}
if (!FInput.IsChanged && !FExtendedMode.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i].SliceCount = 0;
MemoryStream ms = new MemoryComStream();
FInput[i].Position = 0;
FInput[i].CopyTo(ms);
byte[] bytes = ms.ToArray();
int start = 0;
OSCPacket packet = OSCPacket.Unpack(bytes, ref start, (int)FInput[i].Length, FExtendedMode[0]);
if (packet.IsBundle())
{
var packets = ((OSCBundle)packet).Values;
foreach (OSCPacket innerPacket in packets)
{
MemoryStream memoryStream = new MemoryStream(innerPacket.BinaryData);
FOutput[i].Add(memoryStream);
}
}
else
{
MemoryStream memoryStream = new MemoryStream(packet.BinaryData);
FOutput[i].Add(memoryStream);
}
}
FOutput.Flush();
}
public void Evaluate(int spreadMax)
{
FOutput.SliceCount = FBuffer.SliceCount;
for (int i = 0; i < FBuffer.SliceCount; i++)
{
if (FBuffer[i] == null)
{
FOutput[i] = null;
}
else
{
if (FOutput[i] == null)
{
FOutput[i] = new Core.Struct(FBuffer[i]);
}
foreach (var f in FBuffer[i].Fields)
{
FOutput[i][f] = FBuffer[i].GetClonedData(f);
}
}
}
if (!declarationChanged)
{
FOutput.Flush();
FInput.Sync();
}
FBuffer.SliceCount = FInput.SliceCount;
for (int i = 0; i < FInput.SliceCount; i++)
{
if (FInput[i] == null)
{
FBuffer[i] = null;
}
else
{
if (FBuffer[i] == null || FBuffer[i].Name != FInput[i].Name)
{
FBuffer[i] = new Core.Struct(FInput[i]);
FOutput[i] = new Core.Struct(FBuffer[i]);
declarationChanged = true;
}
foreach (var f in FInput[i].Fields)
{
FBuffer[i][f] = FInput[i].GetClonedData(f);
}
}
}
if (declarationChanged)
{
FOutput.Flush();
declarationChanged = false;
}
}
public void Evaluate(int SpreadMax)
{
FTransform.Stream.IsChanged = false;
if (FTrans.IsChanged || FRot.IsChanged || FScale.IsChanged)
{
FTransform.SliceCount = SpreadMax;
for (int i = SpreadMax - 1; i >= 0; i--)
{
if (FTransform[i] == null)
{
FTransform[i] = new ElementTransformation();
}
else if (i > 0)
{
for (int j = i - 1; j >= 0; j--)
{
if (FTransform[i] != FTransform[j])
{
continue;
}
FTransform[i] = new ElementTransformation();
break;
}
}
FTransform[i].Position = FTrans[i].AsSystemVector();
FTransform[i].Rotation = FRot[i].AsSystemQuaternion();
FTransform[i].Scale = FScale[i].AsSystemVector();
}
FTransform.Flush(true);
FTransform.Stream.IsChanged = true;
}
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
if (FInput.SliceCount <= 0 || FInput[0] == null)
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
FOutput.SliceCount = SpreadMax;
var serializer = FResolver == null ?
new DataContractSerializer(typeof(T)) :
new DataContractSerializer(typeof(T), null, 65536, false, false, null, FResolver);
// string xmlString;
for (int i = 0; i < SpreadMax; i++)
{
Stream output = new MemoryStream();
serializer.WriteObject(output, FInput[i]);
FOutput[i] = output;
}
FOutput.Flush();
}
public void Evaluate(int SpreadMax)
{
FOutput.Resize(SpreadMax, () => new MemoryComStream(), str => str.Dispose());
FMmf.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
if (string.IsNullOrWhiteSpace(FName[i]))
{
continue;
}
if (FOpen[i] && !_mmfs.ContainsKey(FName[i]))
{
try
{
var mmf = MemoryMappedFile.OpenExisting(FName[i]);
_mmfs.Add(FName[i], mmf);
}
catch
{ }
}
if ((FOpen[i] || FRead[i]) && _mmfs.ContainsKey(FName[i]))
{
var mmf = _mmfs[FName[i]];
FMmf[i] = mmf;
if (FOutput[i] == null)
{
FOutput[i] = new MemoryComStream();
}
if (FSize[i] == 0)
{
using (var accessor = mmf.CreateViewStream())
{
FOutput[i].SetLength(accessor.Length);
accessor.Position = 0;
FOutput[i].Position = 0;
accessor.CopyTo(FOutput[i]);
FOutput[i].Position = 0;
}
}
else
{
using (var accessor = mmf.CreateViewStream(FOffset[i], FSize[i]))
{
FOutput[i].SetLength(accessor.Length);
accessor.Position = 0;
FOutput[i].Position = 0;
accessor.CopyTo(FOutput[i]);
FOutput[i].Position = 0;
}
}
}
}
FOutput.Stream.IsChanged = false;
if (FRead.Any() || FOpen.Any())
{
FOutput.Flush(true);
}
}
private void UpdateOutputPins()
{
if (FParticleSystemName.SliceCount != 0)
{
var particleSystemData = ParticleSystemRegistry.Instance.GetByParticleSystemName(FParticleSystemName[0]);
if (particleSystemData != null)
{
FBufferSemantic.SliceCount = FElementCountBuf.SliceCount = FStrideBuf.SliceCount = FModeBuf.SliceCount = FResetCounterBuf.SliceCount = 0;
foreach (ParticleSystemBufferSettings psbs in particleSystemData.GetBufferSettings())
{
FBufferSemantic.Add(psbs.bufferSemantic);
FElementCountBuf.Add(psbs.elementCount);
FStrideBuf.Add(psbs.stride);
FModeBuf.Add(psbs.bufferMode);
FResetCounterBuf.Add(psbs.resetCounter);
}
FBufferSemantic.Flush();
FElementCountBuf.Flush();
FStrideBuf.Flush();
FModeBuf.Flush();
FResetCounterBuf.Flush();
FElementCountPS[0] = particleSystemData.ElementCount;
FElementCountPS.Flush();
FStridePS[0] = particleSystemData.Stride;
FStridePS.Flush();
}
}
}
public override void Evaluate(int SpreadMax)
{
if (Default != null && !FInput.IsChanged)
{
return;
}
if (FInput.IsAnyInvalid())
{
if (Default == null)
{
NewDefault();
}
FOutput.SliceCount = 1;
Default.Topic = FTopic[0];
FOutput[0] = Default;
FOutput.Flush();
}
else
{
FOutput.FlushResult(FInput);
}
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (FInput.IsAnyInvalid() || FFilter.IsAnyInvalid())
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
if (SpreadMax == 0)
{
FOutput.FlushNil();
FNotFound.FlushNil();
return;
}
if (!FInput.IsChanged && !FFilter.IsChanged)
{
return;
}
FOutput.SliceCount = 0;
FNotFound.SliceCount = 0;
bool[] found = new bool[SpreadMax];
for (int i = 0; i < SpreadMax; i++)
{
found[i] = false;
}
for (int i = 0; i < FFilter.SliceCount; i++)
{
string[] filter = FFilter[i].Split('.');
var regex = FFilter[i].CreateWildCardRegex();
for (int j = 0; j < SpreadMax; j++)
{
if (!found[j])
{
found[j] = regex.IsMatch(FInput[j].Topic);
}
}
}
for (int i = 0; i < SpreadMax; i++)
{
if (found[i])
{
FOutput.Add(FInput[i]);
}
else
{
FNotFound.Add(FInput[i]);
}
}
FOutput.Flush();
FNotFound.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if ((!FInput.IsChanged && !FRemove.IsChanged))
{
return;
}
if ((FRemove.IsAnyInvalid() || FInput.IsAnyInvalid()))
{
if (FOutput.SliceCount > 0)
{
FOutput.FlushResult(FInput);
return;
}
else
{
return;
}
}
SpreadMax = FInput.SliceCount;
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
var remains = from msg in FInput[i]
where !FRemove.Contains(msg)
select msg;
FOutput[0].SliceCount = 0;
FOutput[0].AssignFrom(remains);
}
FOutput.Flush();
}
#pragma warning restore
#endregion fields & pins
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
// if (!FInput.IsChanged) return;
FOutput.SliceCount = 0;
SpreadMax = FInput.SliceCount;
if ((FInput.SliceCount == 0) || (FInput[0] == null) || (FInput[0].Length == 0))
{
return;
}
for (int i = 0; i < SpreadMax; i++)
{
// try {
MemoryStream ms = new MemoryStream();
FInput[i].Position = 0;
FInput[i].CopyTo(ms);
byte[] bytes = ms.ToArray();
int start = 0;
OSCPacket packet = OSCPacket.Unpack(bytes, ref start, (int)ms.Length);
bool matches = false;
for (int j = 0; j < FPinInAddress.SliceCount; j++)
{
switch (FPinInFilter[0])
{
case Filter.Matches:
matches |= packet.Address == FPinInAddress[j];
break;
case Filter.Contains:
matches |= packet.Address.Contains(FPinInAddress[j]);
break;
case Filter.Starts:
matches |= packet.Address.StartsWith(FPinInAddress[j]);
break;
case Filter.Ends:
matches |= packet.Address.EndsWith(FPinInAddress[j]);
break;
case Filter.All:
matches = true;
break;
}
}
if (matches)
{
FOutput.Add(ms);
}
// } catch (Exception ex) {}
}
FOutput.Flush();
}
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() || FIndex.IsAnyInvalid()? 0 : FIndex.CombineWith(FIndex);
if (SpreadMax == 0)
{
FOutput.FlushNil();
return;
}
else
{
if (!FIndex.IsChanged && !FInput.IsChanged)
{
return;
}
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
FOutput[i].AssignFrom(FInput[FIndex[i]]);
}
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged && !FPretty.IsChanged)
{
return;
}
FOutput.SliceCount = SpreadMax;
JsonSerializer ser = new JsonSerializer();
JsonSerializerSettings settings = new JsonSerializerSettings();
if (FPretty[0])
{
settings.Formatting = Formatting.Indented;
}
else
{
settings.Formatting = Formatting.None;
}
settings.TypeNameHandling = TypeNameHandling.None;
for (int i = 0; i < SpreadMax; i++)
{
string s = JsonConvert.SerializeObject(FInput[i], settings);
FOutput[i] = s ?? "";
}
FOutput.Flush();
}
public void Evaluate(int SpreadMax)
{
if (FSet[0] == false)
{
return;
}
FInput.Sync();
SpreadMax = FInput.SliceCount;
FOutput.SliceCount = SpreadMax;
bool clone = FClone[0] && (FInput[0] != null) && (FInput[0] is ICloneable);
for (int i = 0; i < FInput.SliceCount; i++)
{
T output;
if (clone)
{
output = (T)((ICloneable)FInput[i]).Clone();
}
else
{
output = FInput[i];
}
FOutput[i] = output;
}
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
SpreadMax = FInput.SliceCount;
FOutput.SliceCount = 0;
var settings = new JsonSerializerSettings();
for (int i = 0; i < SpreadMax; i++)
{
var result = JsonConvert.DeserializeObject(FInput[i]);
if (result is JArray)
{
foreach (var o in (result as JArray).Children())
{
FOutput.Add(o.ToObject <Message>());
}
}
if (result is JObject)
{
FOutput.Add((result as JObject).ToObject <Message>());
}
}
FOutput.Flush();
}
//called when data for any output pin is requested
public void Evaluate(int spreadMax)
{
//ResizeAndDispose will adjust the spread length and thereby call
//the given constructor function for new slices and Dispose on old
//slices.
FStreamOut.ResizeAndDispose(spreadMax, () => new MemoryStream());
FKeyGens.SliceCount = spreadMax;
if (FPass.IsChanged || FKeyLength.IsChanged || FKeyIterations.IsChanged || FKeySalt.IsChanged)
{
for (int i = 0; i < spreadMax; i++)
{
var outputStream = FStreamOut[i];
try
{
FKeyGens[i] = new KeyGenerator();
var key = FKeyGens[i].GenerateKey(FPass[i], FKeyLength[i], FKeyIterations[i], FKeySalt[i]);
outputStream.SetLength(0);
outputStream.Write(key, 0, key.Length);
}
catch (Exception e)
{
FLogger.Log(e);
outputStream.SetLength(0);
FErrorOut[i] = e.Message;
}
}
//this will force the changed flag of the output pin to be set
FStreamOut.Flush(true);
}
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
if (FInput.SliceCount <= 0 || FInput[0] == null)
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
Message message = Message.FromOSC(FInput[i]);
FOutput[i] = message;
}
FOutput.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
SpreadMax = FInput.IsAnyInvalid() ? 0 : FInput.SliceCount;
if (SpreadMax <= 0)
{
FMatch.FlushNil();
FOutput.FlushNil();
return;
}
FMatch.SliceCount = FOutput.SliceCount = 0;
foreach (var message in FInput)
{
var match = new bool[FFilter.SliceCount];
for (int i = 0; i < FFilter.SliceCount; i++)
{
match[i] = message.Fields.Contains(FFilter[i]);
}
if (match.Any())
{
FOutput.Add(message);
FMatch.AddRange(match);
}
}
FOutput.Flush();
FMatch.Flush();
}
#pragma warning restore
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged && !FAddress.IsChanged && !FContract.IsChanged)
{
return;
}
if ((FInput.SliceCount == 0) || (FInput[0] == null) || (FInput[0].Length == 0))
{
return;
}
if (FInput.SliceCount <= 0 || FInput[0] == null)
{
SpreadMax = 0;
}
else
{
SpreadMax = FInput.SliceCount;
}
FOutput.SliceCount = SpreadMax;
for (int i = 0; i < SpreadMax; i++)
{
Message message = Message.FromOSC(FInput[i], FAddress[0], FContract[0]);
FOutput[i] = message;
}
FOutput.Flush();
}
private void UpdateOutputPins()
{
var particleSystemData = ParticleSystemRegistry.Instance.GetByParticleSystemName(FParticleSystemName[0]);
if (particleSystemData != null)
{
FOutDefines.SliceCount = 0;
FOutDefines.Add("COMPOSITESTRUCT=" + particleSystemData.StructureDefinition);
FOutDefines.Add("MAXPARTICLECOUNT=" + particleSystemData.ElementCount);
foreach (string define in particleSystemData.GetDefines())
{
if (define != "")
{
FOutDefines.Add(define);
}
}
FOutDefines.Flush();
FOutBufferSemantics.SliceCount = 0;
FOutBufferSemantics.AssignFrom(particleSystemData.BufferSemantics);
FOutBufferSemantics.Flush();
FElementCount[0] = particleSystemData.ElementCount;
FElementCount.Flush();
FStride[0] = particleSystemData.Stride;
FStride.Flush();
}
}
public static void FlushNil(this ISpread spread)
{
if (spread.SliceCount != 0)
{
spread.SliceCount = 0;
spread.Flush();
}
}
public void OnImportsSatisfied()
{
IOManager.IOsChanged += IOManager_IOsChanged;
FEnabled.Changed += (s) =>
{
if (s.SliceCount > 0 && s[0])
{
FStructOut.SliceCount = 1;
FStructOut[0] = FStruct;
}
else
{
FStructOut.SliceCount = 0;
}
FStructOut.Flush();
};
}
public void Evaluate(int SpreadMax)
{
if (!FInput.IsChanged)
{
return;
}
SpreadMax = FInput.SliceCount;
FOutput.SliceCount = 0;
bool[] found = new bool[SpreadMax];
for (int i = 0; i < SpreadMax; i++)
{
found[i] = false;
}
for (int i = 0; i < FFilter.SliceCount; i++)
{
string[] filter = FFilter[i].Split('.');
for (int j = 0; j < SpreadMax; j++)
{
if (!found[j])
{
string[] message = FInput[j].Address.Split('.');
if (message.Length < filter.Length)
{
continue;
}
bool match = true;
for (int k = 0; k < filter.Length; k++)
{
if ((filter[k].Trim() != message[k].Trim()) && (filter[k].Trim() != "*"))
{
match = false;
}
}
found[j] = match;
}
}
}
for (int i = 0; i < SpreadMax; i++)
{
if (found[i])
{
FOutput.Add(FInput[i]);
}
else
{
FNotFound.Add(FInput[i]);
}
}
FOutput.Flush();
FNotFound.Flush();
}
public static void FlushResult <T>(this ISpread <T> spread, IEnumerable <T> result)
{
spread.SliceCount = 0;
if (result != null)
{
spread.AssignFrom(result);
}
spread.Flush();
}
public void Evaluate(int SpreadMax)
{
FOutput.Stream.IsChanged = false;
if (Initial)
{
FOutput.AssignFrom(FDefault);
Initial = false;
FOutput.Flush();
FOutput.Stream.IsChanged = true;
}
if (FEval[0])
{
FInput.Sync();
FOutput.AssignFrom(FInput);
FOutput.Flush();
FOutput.Stream.IsChanged = true;
}
}
public void Evaluate(int SpreadMax)
{
this.FOutValid.SliceCount = 1;
this.FStreamOut.SliceCount = 1;
if (this.FRead[0])
{
this.FBufferIn.Sync();
if (this.FBufferIn.IsConnected)
{
if (this.RenderRequest != null)
{
this.RenderRequest(this, this.FHost);
}
if (this.AssignedContext == null)
{
this.FOutValid.SliceCount = 0; return;
}
var context = this.AssignedContext;
if (this.FBufferIn[0].Contains(this.AssignedContext))
{
var rawBuffer = this.FBufferIn[0][context];
if (this.lastBuffer != null)
{
if (rawBuffer.Buffer.Description.SizeInBytes != lastBuffer.Size)
{
this.lastStream.Dispose();
this.lastStream = null;
this.lastBuffer.Dispose();
this.lastBuffer = null;
}
}
if (this.lastBuffer == null)
{
this.lastBuffer = new DX11StagingRawBuffer(context.Device, rawBuffer.Buffer.Description.SizeInBytes);
this.lastStream = new MemoryStream(rawBuffer.Buffer.Description.SizeInBytes);
}
lastStream.Position = 0;
context.CurrentDeviceContext.CopyResource(rawBuffer.Buffer, this.lastBuffer.Buffer);
DataStream ds = this.lastBuffer.MapForRead(context.CurrentDeviceContext);
ds.CopyTo(lastStream);
lastStream.Position = 0;
this.lastBuffer.UnMap(context.CurrentDeviceContext);
FStreamOut[0] = lastStream;
FStreamOut.Flush(true);
}
}
}
}
public void Evaluate(int SpreadMax)
{
if (OpenIn.Any(v => v) || CloseIn.Any(v => v))
{
DeviceIn.Sync();
DeviceOut.ResizeAndDispose(DeviceIn.SliceCount, () => new HidDeviceWrap());
for (int i = 0; i < DeviceOut.SliceCount; i++)
{
if (OpenIn[i])
{
if (DeviceOut[i] == null)
{
DeviceOut[i] = new HidDeviceWrap();
}
if (DeviceOut[i].Device == null)
{
DeviceOut[i].Device = DeviceIn[i];
DeviceOut[i].Initialize();
}
else
{
DeviceOut[i].Open();
}
}
if (CloseIn[i] && DeviceOut[i] != null && DeviceOut[i].Opened)
{
DeviceOut[i].Close();
DeviceOut[i].Dispose();
DeviceOut[i] = null;
}
}
DeviceOut.Stream.IsChanged = true;
DeviceOut.Flush(true);
}
if (_changeRef != HidChange.GlobalChangeCounter)
{
_changeRef = HidChange.GlobalChangeCounter;
DeviceOut.Stream.IsChanged = true;
DeviceOut.Flush(true);
}
}
public override void Evaluate(int SpreadMax)
{
InitDX11Graph();
bool warnPinSafety = false;
if (RemovePinsFirst)
{
warnPinSafety = !RetryConfig();
}
if (!FNew.Any()) // if none true
{
FOutput.FlushNil();
return;
}
SpreadMax = FNew.CombineWith(FTopic);
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
pin.Sync();
SpreadMax = Math.Max(pin.SliceCount, SpreadMax);
}
FOutput.SliceCount = 0;
for (int i = 0; i < SpreadMax; i++)
{
if (FNew[i])
{
var message = new Message();
message.Topic = FTopic[i];
foreach (string name in FPins.Keys)
{
var pin = FPins[name].ToISpread();
if (pin.SliceCount > 0)
{
message.AssignFrom(name, pin[i] as ISpread);
}
else
{
message[name] = BinFactory.New(Formular[name].Type); // will do empty spreads as well, but ignore faults
}
}
FOutput.Add(message);
}
}
FOutput.Flush();
if (warnPinSafety)
{
throw new PinConnectionException("Manually remove unneeded links first! [Create]. ID = [" + PluginHost.GetNodePath(false) + "]");
}
}
//called when data for any output pin is requested
public void Evaluate(int spreadMax)
{
//ResizeAndDispose will adjust the spread length and thereby call
//the given constructor function for new slices and Dispose on old
//slices.
FStreamOut.ResizeAndDispose(spreadMax, () => new MemoryStream());
Tasks.SliceCount = spreadMax;
IOs.SliceCount = spreadMax;
FWorking.SliceCount = spreadMax;
FError.SliceCount = spreadMax;
for (int i = 0; i < spreadMax; i++)
{
if (!FAsync[i])
{
FWorking[i] = false;
}
if (FCompress[i])
{
IOs[i] = new CompressorIO();
IOs[i].InBytes = new byte[FStreamIn[i].Length];
FStreamIn[i].Position = 0;
FStreamIn[i].Read(IOs[i].InBytes, 0, (int)FStreamIn[i].Length);
if (FAsync[i])
{
Tasks[i] = new Task(CompressAsync, IOs[i]);
Tasks[i].Start();
}
else
{
CompressAsync(IOs[i]);
FWorking[i] = true;
FStreamOut[i].Position = 0;
FStreamOut[i].Write(IOs[i].OutBytes, 0, IOs[i].OutBytes.Length);
}
}
if (Tasks[i] != null)
{
if (FAsync[i])
{
if ((IOs[i].OutBytes != null) && FWorking[i])
{
FStreamOut[i].Position = 0;
FStreamOut[i].Write(IOs[i].OutBytes, 0, IOs[i].OutBytes.Length);
}
FWorking[i] = (!Tasks[i].IsCompleted) && (!Tasks[i].IsFaulted);
}
if (Tasks[i].Exception != null)
{
FError[i] = Tasks[i].Exception.Message;
}
}
}
//this will force the changed flag of the output pin to be set
FStreamOut.Flush(true);
}
