/* fix up pre-origin time for the FOF state object */
public void FixUpPreOrigin(
int ActualPreOrigin)
{
FOFStateRec State = this;
EnvelopeStateFixUpInitialDelay(
State.WaveTableIndexEnvelope,
ActualPreOrigin);
EnvelopeStateFixUpInitialDelay(
State.WaveTableLoudnessEnvelope,
ActualPreOrigin);
EnvelopeStateFixUpInitialDelay(
State.FOFSamplingRateEnvelope,
ActualPreOrigin);
LFOGeneratorFixEnvelopeOrigins(
State.IndexLFOGenerator,
ActualPreOrigin);
LFOGeneratorFixEnvelopeOrigins(
State.LoudnessLFOGenerator,
ActualPreOrigin);
LFOGeneratorFixEnvelopeOrigins(
State.PitchLFO,
ActualPreOrigin);
LFOGeneratorFixEnvelopeOrigins(
State.FOFSamplingRateLFOGenerator,
ActualPreOrigin);
if (State.OscEffectGenerator != null)
{
FixUpOscEffectGeneratorPreOrigin(
State.OscEffectGenerator,
ActualPreOrigin);
}
State.PreStartCountdown += ActualPreOrigin;
}
/* find out if the FOF oscillator has finished */
public bool IsItFinished()
{
FOFStateRec State = this;
/* we are finished when one of the following conditions is met: */
/* - output volume is zero AND loudness envelope is finished */
/* - we are not generating any signal */
if (!State.WaveTableWasDefined)
{
return(true);
}
if (State.ActiveGrainList != null)
{
return(false); /* allow active grains to finish */
}
return(IsEnvelopeAtEnd(State.WaveTableLoudnessEnvelope));
}
/* finalize before termination */
public void Finalize(
SynthParamRec SynthParams,
bool writeOutputLogs)
{
FOFStateRec State = this;
if (State.OscEffectGenerator != null)
{
FinalizeOscEffectGenerator(
State.OscEffectGenerator,
SynthParams,
writeOutputLogs);
}
FreeEnvelopeStateRecord(
ref State.WaveTableIndexEnvelope,
SynthParams);
FreeLFOGenerator(
ref State.IndexLFOGenerator,
SynthParams);
FreeEnvelopeStateRecord(
ref State.WaveTableLoudnessEnvelope,
SynthParams);
FreeLFOGenerator(
ref State.LoudnessLFOGenerator,
SynthParams);
FreeLFOGenerator(
ref State.PitchLFO,
SynthParams);
FreeEnvelopeStateRecord(
ref State.FOFSamplingRateEnvelope,
SynthParams);
FreeLFOGenerator(
ref State.FOFSamplingRateLFOGenerator,
SynthParams);
Free(
ref SynthParams.freelists.FOFStateRecFreeList,
ref State);
}
/* send a key-up signal to one of the oscillators */
public void KeyUpSustain3()
{
FOFStateRec State = this;
LFOGeneratorKeyUpSustain3(
State.IndexLFOGenerator);
LFOGeneratorKeyUpSustain3(
State.LoudnessLFOGenerator);
LFOGeneratorKeyUpSustain3(
State.FOFSamplingRateLFOGenerator);
EnvelopeKeyUpSustain3(
State.WaveTableIndexEnvelope);
EnvelopeKeyUpSustain3(
State.WaveTableLoudnessEnvelope);
EnvelopeKeyUpSustain3(
State.FOFSamplingRateEnvelope);
LFOGeneratorKeyUpSustain3(
State.PitchLFO);
if (State.OscEffectGenerator != null)
{
OscEffectKeyUpSustain3(
State.OscEffectGenerator);
}
}
/* wave resampler helper */
private static void FOFGeneratorStereo(
FOFStateRec State,
int nActualFrames,
float[] workspace,
int lOffset,
int rOffset,
SynthParamRec SynthParams)
{
/* see if we shouldn't be here */
if (!State.WaveTableWasDefined)
{
return;
}
/* do some setup */
bool EnvelopeFinished = IsEnvelopeAtEnd(State.WaveTableLoudnessEnvelope);
int LocalSamplePositionMask = State.FramesPerTable - 1;
/* iterate over samples */
for (int Scan = 0; Scan < nActualFrames; Scan++)
{
/* check for launching */
GrainLaunchCheck(
State,
EnvelopeFinished,
SynthParams);
/* prepare point */
float CurrentLeft = workspace[Scan + lOffset];
float CurrentRight = workspace[Scan + rOffset];
/* generate sounds for all registered grains */
FOFGrainRec GrainScan = State.ActiveGrainList;
FOFGrainRec GrainLag = null;
while (GrainScan != null)
{
/* wave generation */
float RightWeight = GrainScan.FOFSamplePosition.FracF;
int ArraySubscript = GrainScan.FOFSamplePosition.Int & LocalSamplePositionMask;
/* L+F(R-L) */
float Left0Value = GrainScan.WaveData0[ArraySubscript];
float Right0Value = GrainScan.WaveData0[ArraySubscript + 1];
float CombinedValue = Left0Value + (RightWeight * (Right0Value - Left0Value));
if ((GrainScan.WaveData1 != null) && State.Template.EnableCrossWaveTableInterpolation)
{
/* L+F(R-L) -- applied twice */
float Left1Value = GrainScan.WaveData1[ArraySubscript];
float Right1Value = GrainScan.WaveData1[ArraySubscript + 1];
float Wave0Temp = CombinedValue;
CombinedValue = Wave0Temp + (GrainScan.Wave1Weight * (Left1Value
+ (RightWeight * (Right1Value - Left1Value)) - Wave0Temp));
}
/* else index == 1, so no right hand wave to use */
CurrentLeft += GrainScan.LeftLoudness * CombinedValue;
CurrentRight += GrainScan.RightLoudness * CombinedValue;
/* increment phase */
bool Advance = true;
GrainScan.FOFSamplePosition += GrainScan.FOFSamplePositionDifferential;
if (GrainScan.FOFSamplePosition.Int >= State.FramesPerTable)
{
GrainScan.FOFSamplePosition.MaskInt64HighHalf(LocalSamplePositionMask);
if (State.Template.FOFExpansion == OscFOFExpandType.eOscFOFSilenceFill)
{
/* silence fill. */
/* for silence fill, we now terminate this oscillator. */
Advance = false;
FOFGrainRec Temp = GrainScan;
GrainScan = GrainScan.Next;
if (GrainLag != null)
{
GrainLag.Next = GrainScan;
}
else
{
State.ActiveGrainList = GrainScan;
}
Free(ref SynthParams.freelists.FOFGrainRecFreeList, ref Temp);
}
else
{
/* loop around. */
/* we only terminate the oscillator if it's not the first */
/* one, otherwise we allow it to restart */
if (GrainLag != null)
{
/* not the first one */
Advance = false;
FOFGrainRec Temp = GrainScan;
GrainScan = GrainScan.Next;
GrainLag.Next = GrainScan;
Free(ref SynthParams.freelists.FOFGrainRecFreeList, ref Temp);
}
}
}
if (Advance)
{
GrainLag = GrainScan;
GrainScan = GrainScan.Next;
}
}
/* send value back */
workspace[Scan + lOffset] = CurrentLeft;
workspace[Scan + rOffset] = CurrentRight;
}
}
/* fof pitch start pulse: */
/* | | | | | | */
/* 0.0 1.1 2.1 3.2 0.3 1.4 2.4 3.5 0.6 1.6 2.7 3.7 0.8 1.9 2.9 0.0 1.1 2.1 3.2 0.3 */
/* sampling period pulse: */
/* * * * * * * * * * * * * * * * * * * * * */
/* no interpolation of grains: */
/* 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 */
/* with interpolation of grains: */
/* 0.0 1.0 2.0 0.3 1.3 2.3 0.5 1.5 2.5 0.7 1.7 2.7 0.0 1.0 2.0 0.3 */
/* pitch start pulse and grain sampling pulse have same units to allow */
/* start pulse fraction to be used for initial grain fraction. */
/* check to see if we should launch a new grain */
private static void GrainLaunchCheck(
FOFStateRec State,
bool EnvelopeFinished,
SynthParamRec SynthParams)
{
/* first, handle grain launching. do this by adding the pitch differential */
/* to the accumulator and checking for overflow. */
State.WaveTableSamplePosition += State.WaveTableSamplePositionDifferential;
/* if this overflows, then truncate it and launch a new grain */
if (State.WaveTableSamplePosition.Int >= State.FramesPerTable)
{
/* time to launch a new grain */
/* truncate grain pitch index to keep wave table index inside */
State.WaveTableSamplePosition.MaskInt64HighHalf(State.FramesPerTable - 1);
/* check for discard mode */
if (State.Template.FOFCompression == OscFOFCompressType.eOscFOFDiscard)
{
/* if we are in discard mode, then dump any active grains */
FOFGrainRec Scan = State.ActiveGrainList;
while (Scan != null)
{
FOFGrainRec one = Scan;
Scan = Scan.Next;
Free(ref SynthParams.freelists.FOFGrainRecFreeList, ref one);
}
State.ActiveGrainList = null;
}
/* creating new grain, but only if the envelope generator hasn't terminated */
if (!EnvelopeFinished)
{
/* initialize grain differential to the sampling rate */
/* note that grain differential is independent of the */
/* number of frames in the table. */
Fixed64 FOFSamplePositionDifferential = new Fixed64(
State.FOFSamplingRateContour * State.Template.FOFSamplingRate
/ SynthParams.dSamplingRate);
// create new grain, but only if differential isn't really close to zero
if (!((FOFSamplePositionDifferential.FracI < 0x00010000) &&
(FOFSamplePositionDifferential.Int == 0)))
{
FOFGrainRec NewGrain = New(ref SynthParams.freelists.FOFGrainRecFreeList);
// must initialize all fields: NewGrain
/* set up grain's phase index */
NewGrain.FOFSamplePosition = State.WaveTableSamplePosition;
/* set up wave data pointers using current wave table index */
#if DEBUG
if ((State.WaveTableIndex < 0) || (State.WaveTableIndex > State.NumberOfTablesMinus1))
{
// table index out of range
Debug.Assert(false);
throw new InvalidOperationException();
}
#endif
NewGrain.WaveData0 = State.WaveTableMatrix[(int)(State.WaveTableIndex)];
NewGrain.WaveData1 = null;
NewGrain.Wave1Weight = 0;
if ((int)(State.WaveTableIndex) < State.NumberOfTablesMinus1)
{
NewGrain.WaveData1 = State.WaveTableMatrix[(int)(State.WaveTableIndex) + 1];
NewGrain.Wave1Weight = (float)(State.WaveTableIndex - (int)(State.WaveTableIndex));
}
/* set up amplitudes */
NewGrain.LeftLoudness = State.LeftLoudness;
NewGrain.RightLoudness = State.RightLoudness;
NewGrain.FOFSamplePositionDifferential = FOFSamplePositionDifferential;
NewGrain.Next = null;
/* inserted at front of list (important later) */
NewGrain.Next = State.ActiveGrainList;
State.ActiveGrainList = NewGrain;
}
}
}
}
/* generate a sequence of samples (called for each envelope clock) */
public SynthErrorCodes Generate(
int nActualFrames,
float[] workspace,
int RawBufferLOffset,
int RawBufferROffset,
int PrivateWorkspaceLOffset,
int PrivateWorkspaceROffset,
SynthParamRec SynthParams)
{
FOFStateRec State = this;
if (State.PreStartCountdown <= 0)
{
if (State.OscEffectGenerator == null)
{
/* non-effects case */
/* generate waveform */
FOFGeneratorStereo(
State,
nActualFrames,
workspace,
RawBufferLOffset,
RawBufferROffset,
SynthParams);
}
else
{
/* effect postprocessing case */
/* initialize private storage */
FloatVectorZero(
workspace,
PrivateWorkspaceLOffset,
nActualFrames);
FloatVectorZero(
workspace,
PrivateWorkspaceROffset,
nActualFrames);
/* generate waveform */
FOFGeneratorStereo(
State,
nActualFrames,
workspace,
PrivateWorkspaceLOffset,
PrivateWorkspaceROffset,
SynthParams);
/* apply processor to it */
SynthErrorCodes error = ApplyOscEffectGenerator(
State.OscEffectGenerator,
workspace,
PrivateWorkspaceLOffset,
PrivateWorkspaceROffset,
nActualFrames,
SynthParams);
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
/* copy out data */
FloatVectorAcc(
workspace,
PrivateWorkspaceLOffset,
workspace,
RawBufferLOffset,
nActualFrames);
FloatVectorAcc(
workspace,
PrivateWorkspaceROffset,
workspace,
RawBufferROffset,
nActualFrames);
}
}
return(SynthErrorCodes.eSynthDone);
}
/* restart a FOF oscillator. this is used for tie continuations */
public void Restart(
ref AccentRec NewAccents,
double NewLoudness,
double NewHurryUp,
bool RetriggerEnvelopes,
double NewStereoPosition,
double NewInitialFrequency,
double PitchDisplacementDepthLimit,
double PitchDisplacementRateLimit,
SynthParamRec SynthParams)
{
FOFStateRec State = this;
NewStereoPosition += State.Template.StereoBias;
if (NewStereoPosition < -1)
{
NewStereoPosition = -1;
}
else if (NewStereoPosition > 1)
{
NewStereoPosition = 1;
}
State.Panning = (float)NewStereoPosition;
State.NoteLoudnessScaling = NewLoudness * State.Template.OverallOscillatorLoudness;
EnvelopeRetriggerFromOrigin(
State.WaveTableIndexEnvelope,
ref NewAccents,
NewInitialFrequency,
1,
NewHurryUp,
RetriggerEnvelopes,
SynthParams);
EnvelopeRetriggerFromOrigin(
State.WaveTableLoudnessEnvelope,
ref NewAccents,
NewInitialFrequency,
1,
NewHurryUp,
RetriggerEnvelopes,
SynthParams);
EnvelopeRetriggerFromOrigin(
State.FOFSamplingRateEnvelope,
ref NewAccents,
NewInitialFrequency,
1,
NewHurryUp,
RetriggerEnvelopes,
SynthParams);
LFOGeneratorRetriggerFromOrigin(
State.IndexLFOGenerator,
ref NewAccents,
NewInitialFrequency,
NewHurryUp,
1,
1,
RetriggerEnvelopes,
SynthParams);
LFOGeneratorRetriggerFromOrigin(
State.LoudnessLFOGenerator,
ref NewAccents,
NewInitialFrequency,
NewHurryUp,
1,
1,
RetriggerEnvelopes,
SynthParams);
LFOGeneratorRetriggerFromOrigin(
State.PitchLFO,
ref NewAccents,
NewInitialFrequency,
NewHurryUp,
PitchDisplacementDepthLimit,
PitchDisplacementRateLimit,
RetriggerEnvelopes,
SynthParams);
LFOGeneratorRetriggerFromOrigin(
State.FOFSamplingRateLFOGenerator,
ref NewAccents,
NewInitialFrequency,
NewHurryUp,
1,
1,
RetriggerEnvelopes,
SynthParams);
if (State.OscEffectGenerator != null)
{
OscEffectGeneratorRetriggerFromOrigin(
State.OscEffectGenerator,
ref NewAccents,
NewInitialFrequency,
NewHurryUp,
RetriggerEnvelopes,
SynthParams);
}
/* do not reset PitchLFOStartCountdown since we can't give it a proper value */
/* to do the expected thing, and we'll be interrupting the phase of the LFO */
/* wave generator */
}
/* perform one envelope update cycle, and set a new frequency for an FOF */
/* state object. used for portamento and modulation of frequency (vibrato) */
public SynthErrorCodes UpdateEnvelopes(
double NewFrequencyHertz,
SynthParamRec SynthParams)
{
SynthErrorCodes error;
FOFStateRec State = this;
float FloatTemp;
double DoubleTemp;
double Differential;
float OneHalfVol;
float LeftLoudness;
float RightLoudness;
if (State.PitchLFOStartCountdown > 0)
{
State.PitchLFOStartCountdown -= 1;
}
else
{
/* do some pitch stuff */
error = SynthErrorCodes.eSynthDone;
NewFrequencyHertz = LFOGenUpdateCycle(
State.PitchLFO,
NewFrequencyHertz,
NewFrequencyHertz,
SynthParams,
ref error);
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
}
NewFrequencyHertz = NewFrequencyHertz * State.Template.FrequencyMultiplier + State.Template.FrequencyAdder;
Differential = NewFrequencyHertz / SynthParams.dSamplingRate * State.FramesPerTable;
State.WaveTableSamplePositionDifferential = new Fixed64(Differential);
/* this is for the benefit of resampling only -- envelope generators do their */
/* own pre-origin sequencing */
if (State.PreStartCountdown > 0)
{
State.PreStartCountdown -= 1;
}
error = SynthErrorCodes.eSynthDone;
DoubleTemp = State.NumberOfTablesMinus1 *
LFOGenUpdateCycle(
State.IndexLFOGenerator,
EnvelopeUpdate(
State.WaveTableIndexEnvelope,
NewFrequencyHertz,
SynthParams,
ref error),
NewFrequencyHertz,
SynthParams,
ref error);
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
if (DoubleTemp < 0)
{
DoubleTemp = 0;
}
else if (DoubleTemp > State.NumberOfTablesMinus1)
{
DoubleTemp = State.NumberOfTablesMinus1;
}
State.WaveTableIndex = DoubleTemp;
error = SynthErrorCodes.eSynthDone;
State.FOFSamplingRateContour = LFOGenUpdateCycle(
State.FOFSamplingRateLFOGenerator,
EnvelopeUpdate(
State.FOFSamplingRateEnvelope,
NewFrequencyHertz,
SynthParams,
ref error),
NewFrequencyHertz,
SynthParams,
ref error);
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
error = SynthErrorCodes.eSynthDone;
FloatTemp = (float)(State.NoteLoudnessScaling * LFOGenUpdateCycle(
State.LoudnessLFOGenerator,
EnvelopeUpdate(
State.WaveTableLoudnessEnvelope,
NewFrequencyHertz,
SynthParams,
ref error),
NewFrequencyHertz,
SynthParams,
ref error));
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
/* left = FloatTemp * .5 * (1 - State.Panning) */
/* right = FloatTemp * .5 * (1 + State.Panning) */
OneHalfVol = .5f * FloatTemp;
LeftLoudness = OneHalfVol - OneHalfVol * State.Panning;
RightLoudness = OneHalfVol + OneHalfVol * State.Panning;
State.LeftLoudness = LeftLoudness;
State.RightLoudness = RightLoudness;
if (State.OscEffectGenerator != null)
{
error = OscEffectGeneratorUpdateEnvelopes(
State.OscEffectGenerator,
NewFrequencyHertz,
SynthParams);
if (error != SynthErrorCodes.eSynthDone)
{
return(error);
}
}
return(SynthErrorCodes.eSynthDone);
}
/* create a new FOF state object. */
public SynthErrorCodes NewState(
double FreqForMultisampling,
ref AccentRec Accents,
double Loudness,
double HurryUp,
out int PreOriginTimeOut,
double StereoPosition,
double InitialFrequency,
double PitchDisplacementDepthLimit,
double PitchDisplacementRateLimit,
int PitchDisplacementStartPoint,
PlayTrackInfoRec TrackInfo,
SynthParamRec SynthParams,
out IOscillator StateOut)
{
FOFTemplateRec Template = this;
int OnePreOrigin;
int NumberOfTables;
PreOriginTimeOut = 0;
StateOut = null;
FOFStateRec State = New(ref SynthParams.freelists.FOFStateRecFreeList);
// must initilize all fields: State
State.WaveTableSamplePosition = new Fixed64(0);
State.WaveTableSamplePositionDifferential = new Fixed64(0);
State.WaveTableIndex = 0;
State.LeftLoudness = 0;
State.RightLoudness = 0;
State.FOFSamplingRateContour = 0;
State.Template = Template;
int MaxPreOrigin = 0;
State.ActiveGrainList = null; /* no grains to begin with */
State.NoteLoudnessScaling = Loudness * Template.OverallOscillatorLoudness;
State.WaveTableWasDefined = GetMultiWaveTableReference(
Template.WaveTableSourceSelector,
FreqForMultisampling,
out State.WaveTableMatrix,
out State.FramesPerTable,
out NumberOfTables);
State.NumberOfTablesMinus1 = NumberOfTables - 1;
if (State.WaveTableWasDefined)
{
/* we want the first grain to go on the first sampling point, so we */
/* set this up to start on the next interval. */
State.WaveTableSamplePosition = new Fixed64(State.FramesPerTable - State.FramesPerTable
* (InitialFrequency / SynthParams.dSamplingRate));
}
/* State.WaveTableSamplePositionDifferential specified in separate call */
/* State.FramesPerTable > 0: */
/* if the wave table is empty, then we don't do any work (and we must not, */
/* since array accesses would cause a crash) */
if (State.WaveTableWasDefined)
{
if (!(State.FramesPerTable > 0))
{
State.WaveTableWasDefined = false;
}
}
/* State.WaveTableWasDefined: */
/* if there is no wave table defined for the current pitch, then we don't */
/* bother generating any data */
/* (no action required) */
State.PreStartCountdown = (int)(Template.TimeDisplacement * SynthParams.dEnvelopeRate + 0.5);
if (-State.PreStartCountdown > MaxPreOrigin)
{
MaxPreOrigin = -State.PreStartCountdown;
}
/* State.WaveTableIndex determined by envelope update */
State.WaveTableIndexEnvelope = NewEnvelopeStateRecord(
Template.IndexEnvelopeTemplate,
ref Accents,
InitialFrequency,
1,
HurryUp,
out OnePreOrigin,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.IndexLFOGenerator = NewLFOGenerator(
Template.IndexLFOTemplate,
out OnePreOrigin,
ref Accents,
InitialFrequency,
HurryUp,
1,
1,
FreqForMultisampling,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
/* State.MonoLoudness, State.LeftLoudness, State.RightLoudness */
/* are determined by the envelope update */
StereoPosition += Template.StereoBias;
if (StereoPosition < -1)
{
StereoPosition = -1;
}
else if (StereoPosition > 1)
{
StereoPosition = 1;
}
State.Panning = (float)StereoPosition;
State.WaveTableLoudnessEnvelope = NewEnvelopeStateRecord(
Template.LoudnessEnvelopeTemplate,
ref Accents,
InitialFrequency,
1,
HurryUp,
out OnePreOrigin,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.LoudnessLFOGenerator = NewLFOGenerator(
Template.LoudnessLFOTemplate,
out OnePreOrigin,
ref Accents,
InitialFrequency,
HurryUp,
1,
1,
FreqForMultisampling,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.PitchLFO = NewLFOGenerator(
Template.PitchLFOTemplate,
out OnePreOrigin,
ref Accents,
InitialFrequency,
HurryUp,
PitchDisplacementDepthLimit,
PitchDisplacementRateLimit,
FreqForMultisampling,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.PitchLFOStartCountdown = PitchDisplacementStartPoint;
State.FOFSamplingRateEnvelope = NewEnvelopeStateRecord(
Template.FOFSamplingRateEnvelopeTemplate,
ref Accents,
InitialFrequency,
1,
HurryUp,
out OnePreOrigin,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.FOFSamplingRateLFOGenerator = NewLFOGenerator(
Template.FOFSamplingRateLFOTemplate,
out OnePreOrigin,
ref Accents,
InitialFrequency,
HurryUp,
1,
1,
FreqForMultisampling,
_PlayTrackParamGetter,
TrackInfo,
SynthParams);
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
State.OscEffectGenerator = null;
if (Template.OscEffectTemplate != null)
{
SynthErrorCodes Result = NewOscEffectGenerator(
Template.OscEffectTemplate,
ref Accents,
HurryUp,
InitialFrequency,
FreqForMultisampling,
out OnePreOrigin,
TrackInfo,
SynthParams,
out State.OscEffectGenerator);
if (Result != SynthErrorCodes.eSynthDone)
{
return(Result);
}
if (OnePreOrigin > MaxPreOrigin)
{
MaxPreOrigin = OnePreOrigin;
}
}
PreOriginTimeOut = MaxPreOrigin;
StateOut = State;
return(SynthErrorCodes.eSynthDone);
}
