public int ImportTimingGrid(TimingGrid beatGrid, xTimings xEffects)
{
int errs = 0;
int lastStart = -1;
// If grid already has timings (from a previous run) clear them, start over fresh
if (beatGrid.timings.Count > 0)
{
beatGrid.timings.Clear();
}
beatGrid.TimingGridType = TimingGridType.Freeform;
for (int q = 0; q < xEffects.effects.Count; q++)
{
xEffect xef = xEffects.effects[q];
int t = ms2cs(xef.starttime);
if (t > lastStart)
{
if (t < Sequence.Centiseconds)
{
beatGrid.AddTiming(t);
}
}
lastStart = t;
}
return(errs);
}
public int xTimingsToxLights(xTimings timings, string baseFileName)
{
int errs = 0;
return(errs);
}
} // end Beats
public int xTimingsToLORtimings(xTimings timings, Sequence4 sequence)
{
// Ignore the timings passed in, and use the ones already cached for Bars and Beats
// (Other transforms will use the one passed in)
seqFunct.Sequence = sequence;
int errs = 0;
if (xOnsets != null)
{
if (xOnsets.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Note Onsets", true);
seqFunct.ImportTimingGrid(barGrid, xOnsets);
}
}
return(errs);
}
public int xTimingsToLORChannels(xTimings timings, Sequence4 sequence, int firstBeat, bool ramps)
{
int errs = 0;
Track vampTrack = seqFunct.GetTrack("Vamp-O-Rama");
ChannelGroup beatGroup = seqFunct.GetGroup("Bars and Beats", vampTrack);
if (xOnsets != null)
{
if (xOnsets.effects.Count > 0)
{
if (ramps)
{
Channel barCh = seqFunct.GetChannel("Bars", beatGroup.Members);
seqFunct.ImportBeatChannel(barCh, xOnsets, 1, firstBeat, ramps);
}
}
}
return(errs);
}
} // end Beats
public static int RoundTimeTo(int startTime, xTimings alignTimes)
{
if (alignTimes != null)
{
if (alignTimes.effects.Count > 0)
{
}
}
if (roundVal > 1)
{
int half = roundVal / 2;
int newStart = startTime / roundVal * roundVal;
int diff = startTime - newStart;
if (diff > half)
{
newStart += roundVal;
}
return(newStart);
}
else
{
return(startTime);
}
}
public int ImportBeatChannel(Channel beatCh, xTimings xEffects, int barDivs, int firstBeat, bool ramps)
{
int errs = 0;
// Detect if we are doing 'Bars' channel for special handling
bool bars = false;
int b = beatCh.Name.IndexOf("Bars");
if (b >= 0)
{
bars = true;
}
int halfBar = 10;
// If channel already has effects (from a previous run) clear them, start over fresh
if (beatCh.effects.Count > 0)
{
beatCh.effects.Clear();
}
//int lb = barDivs - 1;
for (int q = 0; q < xEffects.effects.Count; q++)
{
if (ramps)
{
xEffect xef = xEffects.effects[q];
Effect lef = new Effect();
lef.EffectType = EffectType.Intensity;
lef.startIntensity = 100;
lef.endIntensity = 0;
lef.startCentisecond = ms2cs(xef.starttime);
// Note: No special handling required for bars if using ramps
lef.endCentisecond = ms2cs(xef.endtime);
//if (q < (xEffects.effects.Count - 1))
//{
// Alternative
// lef.endCentisecond = ms2cs(xEffects.effects[q + 1].starttime);
//}
beatCh.AddEffect(lef);
}
else // On-Off, NOT ramps
{
int n = ((q + 1) % barDivs);
if ((n == firstBeat) || bars)
{
xEffect xef = xEffects.effects[q];
Effect lef = new Effect();
lef.EffectType = EffectType.Intensity;
lef.Intensity = 100;
lef.startCentisecond = ms2cs(xef.starttime);
// If processing 'Bars' channel without Ramps, special handling is required
if (bars)
{
// Calculate a half bar for the end time
halfBar = ms2cs(xef.endtime);
halfBar -= lef.startCentisecond;
halfBar /= 2;
//halfBar = ms2cs(halfBar);
lef.endCentisecond = (lef.startCentisecond + halfBar);
}
else
{
lef.endCentisecond = ms2cs(xef.endtime);
}
//if (q < (xEffects.effects.Count - 1))
//{
// Alternative
// lef.endCentisecond = ms2cs(xEffects.effects[q].starttime);
//}
beatCh.AddEffect(lef);
}
}
} // end for loop
return(errs);
}
public int xTimingsToLORChannels(xTimings timings, Sequence4 sequence)
{
return(xTimingsToLORChannels(timings, sequence, 1, false));
}
// The true ResultsToxTimings procedure requiring more parameters, (not compliant with ITransform inteface)
public int ResultsToxTimings(string resultsFile, vamps.AlignmentType alignmentType, vamps.LabelTypes labelType, DetectionMethods detectMethod = DetectionMethods.ComplexDomain)
{
int err = 0;
bool redo = true;
if (xOnsets == null)
{
xOnsets = new xTimings("Note Onsets");
}
if ((xOnsets.effects.Count > 0) && (!ReuseResults))
{
xOnsets.effects.Clear();
}
//TODO Fix this so it works correctly
//if ((xOnsets == null) || (!ReuseResults))
//if (xOnsets == null)
{
int onsetCount = 0;
string lineIn = "";
int lastBeat = 0;
int lastBar = -1;
int beatLength = 0;
int ppos = 0;
int millisecs = 0;
int subBeat = 0;
int subSubBeat = 0;
int subSubSubBeat = 0;
int theTime = 0;
int milliLen = 0;
string noteNum = "";
int midiNum = -1;
string label = "1";
int countLines = 0;
int countBars = 1;
int countBeats = FirstBeat;
int countHalves = 1;
int countThirds = 1;
int countQuarters = 1;
int maxBeats = BeatsPerBar;
int maxHalves = BeatsPerBar * 2;
int maxThirds = BeatsPerBar * 3;
int maxQuarters = BeatsPerBar * 4;
//int align = seqFunct.GetAlignment(cboAlignBarsBeats.Text);
fps = 1000;
msPF = 1;
switch (alignmentType)
{
case vamps.AlignmentType.FPS10:
fps = 10;
msPF = 100;
break;
case vamps.AlignmentType.FPS20:
fps = 20;
msPF = 50;
break;
case vamps.AlignmentType.FPS30:
fps = 30;
msPF = 33;
break;
case vamps.AlignmentType.FPS40:
fps = 40;
msPF = 25;
break;
case vamps.AlignmentType.FPS60:
fps = 60;
msPF = 17;
break;
case vamps.AlignmentType.BeatsFull:
Annotator.xAlignTo = Annotator.xBeatsFull;
break;
case vamps.AlignmentType.BeatsHalf:
Annotator.xAlignTo = Annotator.xBeatsHalf;
break;
case vamps.AlignmentType.BeatsThird:
Annotator.xAlignTo = Annotator.xBeatsThird;
break;
case vamps.AlignmentType.BeatsQuarter:
Annotator.xAlignTo = Annotator.xBeatsQuarter;
break;
}
Annotator.alignIdx = 0; // Reset
// Pass 1, count lines
StreamReader reader = new StreamReader(resultsFile);
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
countLines++;
}
reader.Close();
// Pass 2, read data into arrays
reader = new StreamReader(resultsFile);
if (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
millisecs = Annotator.AlignTimeTo(millisecs, alignmentType);
lastBeat = millisecs;
lastBar = millisecs;
if (parts.Length > 1)
{
milliLen = xUtils.ParseMilliseconds(parts[1]);
}
if (parts.Length > 2)
{
noteNum = parts[2];
if (noteNum.Length > 0)
{
midiNum = Int32.Parse(noteNum);
if (midiNum > 0)
{
//label = SequenceFunctions.noteNames[midiNum];
}
}
}
} // end line contains a period
} // end while loop more lines remaining
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
label = countBeats.ToString();
// FULL BEATS - QUARTER NOTES
//millisecs = xUtils.RoundTimeTo(millisecs, msPF);
// Moved down to below > lastbeat check
//millisecs = Annotator.AlignTimeTo(millisecs, alignmentType);
beatLength = millisecs - lastBeat;
if (parts.Length > 1)
{
milliLen = xUtils.ParseMilliseconds(parts[1]);
}
// Has it advanced since the last one?
if (millisecs > lastBeat)
{
// OK, now align it
millisecs = Annotator.AlignTimeTo(millisecs, alignmentType);
// Is it still past the lastone after alignment?
if (millisecs > lastBeat)
{
// Save it, add it to list
xOnsets.Add(label, lastBeat, millisecs, midiNum);
// update count
countBeats++;
// Remember this for next round (in order to skip ones which haven't advanced)
lastBeat = millisecs;
}
}
// Get length and midi number for next entry
if (parts.Length > 2)
{
noteNum = parts[2];
if (noteNum.Length > 0)
{
midiNum = Int32.Parse(noteNum);
if (midiNum > 0)
{
//label = SequenceFunctions.noteNames[midiNum];
}
}
}
onsetCount++;
} // end line contains a period
} // end while loop more lines remaining
xOnsets.Add(label, lastBeat, millisecs, midiNum);
reader.Close();
}
return(err);
} // end Beats
public static int ReadBeatData(string resultsFile, ref TimesCollection xTimes, xTimings alignTimes)
{
int err = 0;
if ((xTimes.xBars == null) || (!xTimes.Reuse))
{
int onsetCount = 0;
string lineIn = "";
int lastBeat = 0;
int lastBar = -1;
int beatLength = 0;
int ppos = 0;
int millisecs = 0;
int subBeat = 0;
int subSubBeat = 0;
int subSubSubBeat = 0;
int theTime = 0;
int countLines = 0;
int countBars = 1;
int countBeats = xTimes.FirstBeat;
int countHalves = 1;
int countThirds = 1;
int countQuarters = 1;
int maxBeats = xTimes.BeatsPerBar;
int maxHalves = xTimes.BeatsPerBar * 2;
int maxThirds = xTimes.BeatsPerBar * 3;
int maxQuarters = xTimes.BeatsPerBar * 4;
//int align = GetAlignment(cboAlignBarsBeats.Text);
// Pass 1, count lines
StreamReader reader = new StreamReader(resultsFile);
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
countLines++;
}
reader.Close();
xTimes.xBars = new xTimings("Bars" + " (Whole notes, (" + xTimes.BeatsPerBar.ToString() + " Quarter notes))");
xTimes.xBeatsFull = new xTimings("Beats-Full (Quarter notes)");
xTimes.xBeatsHalf = new xTimings("Beats-Half (Eighth notes)");
xTimes.xBeatsThird = new xTimings("Beats-Third (Twelth notes)");
xTimes.xBeatsQuarter = new xTimings("Beats-Quarter (Sixteenth notes)");
// Pass 2, read data into arrays
reader = new StreamReader(resultsFile);
if (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
millisecs = xUtils.RoundTimeTo(millisecs, align);
lastBeat = millisecs;
lastBar = millisecs;
} // end line contains a period
} // end while loop more lines remaining
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
// FULL BEATS - QUARTER NOTES
millisecs = xUtils.RoundTimeTo(millisecs, alignTimes);
beatLength = millisecs - lastBeat;
xTimes.xBeatsFull.Add(countBeats.ToString(), lastBeat, millisecs);
countBeats++;
// BARS
if (countBeats > maxBeats)
{
countBeats = 1;
xTimes.xBars.Add(countBars.ToString(), lastBar, millisecs);
countBars++;
lastBar = millisecs;
}
// HALF BEATS - EIGHTH NOTES
subBeat = lastBeat + (beatLength / 2);
subBeat = xUtils.RoundTimeTo(subBeat, alignTimes);
xTimes.xBeatsHalf.Add(countHalves.ToString(), lastBeat, subBeat);
countHalves++;
xTimes.xBeatsHalf.Add(countHalves.ToString(), subBeat, millisecs);
countHalves++;
if (countHalves > maxHalves)
{
countHalves = 1;
}
// THIRD BEATS - TWELTH NOTES
subBeat = lastBeat + (beatLength / 3);
subBeat = xUtils.RoundTimeTo(subBeat, alignTimes);
xTimes.xBeatsThird.Add(countThirds.ToString(), lastBeat, subBeat);
countThirds++;
subSubBeat = lastBeat + (beatLength * 2 / 3);
subSubBeat = xUtils.RoundTimeTo(subSubBeat, alignTimes);
xTimes.xBeatsThird.Add(countThirds.ToString(), subBeat, subSubBeat);
countThirds++;
xTimes.xBeatsThird.Add(countThirds.ToString(), subSubBeat, millisecs);
countThirds++;
if (countThirds > maxThirds)
{
countThirds = 1;
}
// QUARTER BEATS - SIXTEENTH NOTES
subBeat = lastBeat + (beatLength / 4);
subBeat = xUtils.RoundTimeTo(subBeat, align);
xTimes.xBeatsQuarter.Add(countQuarters.ToString(), lastBeat, subBeat);
countQuarters++;
subSubBeat = lastBeat + (beatLength / 2);
subSubBeat = xUtils.RoundTimeTo(subSubBeat, align);
xTimes.xBeatsQuarter.Add(countQuarters.ToString(), subBeat, subSubBeat);
countQuarters++;
subSubSubBeat = lastBeat + (beatLength * 3 / 4);
subSubSubBeat = xUtils.RoundTimeTo(subSubSubBeat, align);
xTimes.xBeatsQuarter.Add(countQuarters.ToString(), subSubBeat, subSubSubBeat);
countQuarters++;
xTimes.xBeatsQuarter.Add(countQuarters.ToString(), subSubSubBeat, millisecs);
countQuarters++;
if (countQuarters > maxQuarters)
{
countQuarters = 1;
}
lastBeat = millisecs;
onsetCount++;
} // end line contains a period
} // end while loop more lines remaining
reader.Close();
}
return(err);
} // end Beats
public int xTimingsToLORChannels(xTimings timings, Sequence4 sequence, int firstBeat, bool ramps)
{
int errs = 0;
Track vampTrack = seqFunct.GetTrack("Vamp-O-Rama", true);
ChannelGroup beatGroup = seqFunct.GetGroup("Bars and Beats", vampTrack);
if (xBars != null)
{
if (xBars.effects.Count > 0)
{
//if (ramps)
//{
Channel barCh = seqFunct.GetChannel("Bars", beatGroup.Members);
//seqFunct.ImportBeatChannel(barCh, xBars, 1, firstBeat, ramps);
//seqFunct.ImportBeatChannel(barCh, xBars, 1, firstBeat, true);
seqFunct.ImportBeatChannel(barCh, xBars, 1, firstBeat, ramps);
//////}
//}
}
}
//if (chkBeatsFull.Checked)
if (true)
{
if (xBeatsFull != null)
{
if (xBeatsFull.effects.Count > 0)
{
Channel beatCh = seqFunct.GetChannel("Beats-Full", beatGroup.Members);
seqFunct.ImportBeatChannel(beatCh, xBeatsFull, BeatsPerBar, firstBeat, ramps);
}
}
}
//if (chkBeatsHalf.Checked)
if (true)
{
if (xBeatsHalf != null)
{
if (xBeatsHalf.effects.Count > 0)
{
Channel beatCh = seqFunct.GetChannel("Beats-Half", beatGroup.Members);
seqFunct.ImportBeatChannel(beatCh, xBeatsHalf, BeatsPerBar * 2, firstBeat, ramps);
}
}
}
//if (chkBeatsThird.Checked)
if (true)
{
if (xBeatsThird != null)
{
if (xBeatsThird.effects.Count > 0)
{
Channel beatCh = seqFunct.GetChannel("Beats-Third", beatGroup.Members);
seqFunct.ImportBeatChannel(beatCh, xBeatsThird, BeatsPerBar * 3, firstBeat, ramps);
}
}
}
//if (chkBeatsQuarter.Checked)
if (true)
{
if (xBeatsQuarter != null)
{
if (xBeatsQuarter.effects.Count > 0)
{
Channel beatCh = seqFunct.GetChannel("Beats-Quarter", beatGroup.Members);
seqFunct.ImportBeatChannel(beatCh, xBeatsQuarter, BeatsPerBar * 4, firstBeat, ramps);
}
}
}
return(errs);
}
} // end Beats
public int xTimingsToLORtimings(xTimings timings, Sequence4 sequence)
{
// Ignore the timings passed in, and use the ones already cached for Bars and Beats
// (Other transforms will use the one passed in)
seqFunct.Sequence = sequence;
int errs = 0;
if (xBars != null)
{
if (xBars.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Bars", true);
seqFunct.ImportTimingGrid(barGrid, xBars);
}
}
//if (chkBeatsFull.Checked)
if (true)
{
if (xBeatsFull != null)
{
if (xBeatsFull.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Full", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsFull);
}
}
}
//if (chkBeatsHalf.Checked)
if (true)
{
if (xBeatsHalf != null)
{
if (xBeatsHalf.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Half", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsHalf);
}
}
}
//if (chkBeatsThird.Checked)
if (true)
{
if (xBeatsThird != null)
{
if (xBeatsThird.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Third", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsThird);
}
}
}
//if (chkBeatsQuarter.Checked)
if (true)
{
if (xBeatsQuarter != null)
{
if (xBeatsQuarter.effects.Count > 0)
{
TimingGrid barGrid = seqFunct.GetGrid("Beats-Quarter", true);
seqFunct.ImportTimingGrid(barGrid, xBeatsQuarter);
}
}
}
if (xFrames != null)
{
if (xFrames.effects.Count > 0)
{
TimingGrid barFrame = seqFunct.GetGrid(xFrames.timingName, true);
seqFunct.ImportTimingGrid(barFrame, xFrames);
}
}
return(errs);
}
// Required by ITransform inteface, wrapper to true ResultsToxTimings procedure requiring more parameters
public int ResultsToxTimings(string resultsFile, vamps.AlignmentType alignmentType, vamps.LabelTypes labelType)
{
int err = 0;
if ((xBars == null) || (xBars.effects.Count < 2) || (!ReuseResults))
{
int onsetCount = 0;
string lineIn = "";
int lastBeat = 0;
int lastBar = -1;
int beatLength = 0;
int ppos = 0;
int millisecs = 0;
int subBeat = 0;
int subSubBeat = 0;
int subSubSubBeat = 0;
int theTime = 0;
int countLines = 0;
int countBars = 1;
int countBeats = FirstBeat;
int countHalves = 1;
int countThirds = 1;
int countQuarters = 1;
int maxBeats = BeatsPerBar;
int maxHalves = BeatsPerBar * 2;
int maxThirds = BeatsPerBar * 3;
int maxQuarters = BeatsPerBar * 4;
//int align = seqFunct.GetAlignment(cboAlignBarsBeats.Text);
if (alignmentType == vamps.AlignmentType.FPS20)
{
fps = 20;
msPF = 50;
}
else
{
if (alignmentType == vamps.AlignmentType.FPS40)
{
fps = 40;
msPF = 25;
}
else
{
// if (alignmentType == vamps.AlignmentType.None)
// or if alignmentType == anything else (which would be invalid!)
//{
fps = 1000;
msPF = 1;
//}
}
}
// Pass 1, count lines
StreamReader reader = new StreamReader(resultsFile);
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
countLines++;
}
reader.Close();
xBars = new xTimings("Bars" + " (Whole notes, (" + BeatsPerBar.ToString() + " Quarter notes))");
xBeatsFull = new xTimings("Beats-Full (Quarter notes)");
xBeatsHalf = new xTimings("Beats-Half (Eighth notes)");
xBeatsThird = new xTimings("Beats-Third (Twelth notes)");
xBeatsQuarter = new xTimings("Beats-Quarter (Sixteenth notes)");
// Pass 2, read data into arrays
reader = new StreamReader(resultsFile);
if (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
millisecs = xUtils.RoundTimeTo(millisecs, msPF);
lastBeat = millisecs;
lastBar = millisecs;
} // end line contains a period
} // end while loop more lines remaining
while (!reader.EndOfStream)
{
lineIn = reader.ReadLine();
ppos = lineIn.IndexOf('.');
if (ppos > xUtils.UNDEFINED)
{
string[] parts = lineIn.Split(',');
millisecs = xUtils.ParseMilliseconds(parts[0]);
// FULL BEATS - QUARTER NOTES
millisecs = xUtils.RoundTimeTo(millisecs, msPF);
beatLength = millisecs - lastBeat;
xBeatsFull.Add(countBeats.ToString(), lastBeat, millisecs, countBeats);
countBeats++;
// BARS
if (countBeats > maxBeats)
{
countBeats = 1;
xBars.Add(countBars.ToString(), lastBar, millisecs, countBars);
countBars++;
lastBar = millisecs;
}
// HALF BEATS - EIGHTH NOTES
subBeat = lastBeat + (beatLength / 2);
subBeat = xUtils.RoundTimeTo(subBeat, msPF);
xBeatsHalf.Add(countHalves.ToString(), lastBeat, subBeat, countHalves);
countHalves++;
xBeatsHalf.Add(countHalves.ToString(), subBeat, millisecs, countHalves);
countHalves++;
if (countHalves > maxHalves)
{
countHalves = 1;
}
// THIRD BEATS - TWELTH NOTES
subBeat = lastBeat + (beatLength / 3);
subBeat = xUtils.RoundTimeTo(subBeat, msPF);
xBeatsThird.Add(countThirds.ToString(), lastBeat, subBeat, countThirds);
countThirds++;
subSubBeat = lastBeat + (beatLength * 2 / 3);
subSubBeat = xUtils.RoundTimeTo(subSubBeat, msPF);
xBeatsThird.Add(countThirds.ToString(), subBeat, subSubBeat, countThirds);
countThirds++;
xBeatsThird.Add(countThirds.ToString(), subSubBeat, millisecs, countThirds);
countThirds++;
if (countThirds > maxThirds)
{
countThirds = 1;
}
// QUARTER BEATS - SIXTEENTH NOTES
subBeat = lastBeat + (beatLength / 4);
subBeat = xUtils.RoundTimeTo(subBeat, msPF);
xBeatsQuarter.Add(countQuarters.ToString(), lastBeat, subBeat, countQuarters);
countQuarters++;
subSubBeat = lastBeat + (beatLength / 2);
subSubBeat = xUtils.RoundTimeTo(subSubBeat, msPF);
xBeatsQuarter.Add(countQuarters.ToString(), subBeat, subSubBeat, countQuarters);
countQuarters++;
subSubSubBeat = lastBeat + (beatLength * 3 / 4);
subSubSubBeat = xUtils.RoundTimeTo(subSubSubBeat, msPF);
xBeatsQuarter.Add(countQuarters.ToString(), subSubBeat, subSubSubBeat, countQuarters);
countQuarters++;
xBeatsQuarter.Add(countQuarters.ToString(), subSubSubBeat, millisecs, countQuarters);
countQuarters++;
if (countQuarters > maxQuarters)
{
countQuarters = 1;
}
lastBeat = millisecs;
onsetCount++;
} // end line contains a period
} // end while loop more lines remaining
reader.Close();
totalMilliseconds = lastBeat;
totalCentiseconds = lastBeat / 10;
//int t = xBars.effects[0].starttime;
int t = 0;
int f = 1;
if (alignmentType == vamps.AlignmentType.FPS10)
{
xFrames.timingName = "Frames 10FPS, 10cs";
while (t <= totalMilliseconds)
{
if (t > 0)
{
xFrames.Add(f.ToString(), t, t + 100);
}
t += 100;
f++;
}
}
if (alignmentType == vamps.AlignmentType.FPS20)
{
xFrames.timingName = "Frames 20FPS, 5cs";
while (t <= totalMilliseconds)
{
if (t > 0)
{
xFrames.Add(f.ToString(), t, t + 50);
}
t += 50;
f++;
}
}
if (alignmentType == vamps.AlignmentType.FPS30)
{
xFrames.timingName = "Frames 30FPS, 3.33cs";
while (t <= totalMilliseconds)
{
if (t > 0)
{
xFrames.Add(f.ToString(), t, t + 33);
f++;
xFrames.Add(f.ToString(), t + 33, t + 67);
f++;
xFrames.Add(f.ToString(), t + 67, t + 100);
}
t += 100;
f++;
}
}
if (alignmentType == vamps.AlignmentType.FPS40)
{
xFrames.timingName = "Frames 40FPS, 2.5cs";
while (t < totalMilliseconds)
{
if (t > 0)
{
xFrames.Add(f.ToString(), t, t + 25);
}
t += 25;
f++;
}
}
if (alignmentType == vamps.AlignmentType.FPS60)
{
xFrames.timingName = "Frames 60FPS, 1.667cs";
while (t <= totalMilliseconds)
{
if (t > 0)
{
xFrames.Add(f.ToString(), t, t + 17);
f++;
xFrames.Add(f.ToString(), t + 17, t + 33);
f++;
xFrames.Add(f.ToString(), t + 33, t + 50);
f++;
xFrames.Add(f.ToString(), t + 50, t + 67);
f++;
xFrames.Add(f.ToString(), t + 67, t + 83);
f++;
xFrames.Add(f.ToString(), t + 83, t + 100);
}
t += 100;
f++;
}
}
}
Annotator.xBars = xBars;
Annotator.xBeatsFull = xBeatsFull;
Annotator.xBeatsHalf = xBeatsHalf;
Annotator.xBeatsThird = xBeatsThird;
Annotator.xBeatsQuarter = xBeatsQuarter;
return(err);
} // end Beats
public string xTimingsOutX(xTimings timings, xTimings.LabelTypes labelType, bool indent = false)
{
string label = "";
string level0 = "";
string level1 = " ";
string level2 = " ";
if (indent)
{
level0 = " ";
level1 = " ";
level2 = " ";
}
xEffect effect = null;
StringBuilder ret = new StringBuilder();
// <timing
ret.Append(level0);
ret.Append(xTimings.RECORD_start);
ret.Append(xTimings.TABLE_timing);
ret.Append(xTimings.SPC);
// name="the Name"
ret.Append(xTimings.FIELD_name);
ret.Append(xTimings.VALUE_start);
ret.Append(timings.timingName);
ret.Append(xTimings.VALUE_end);
ret.Append(xTimings.SPC);
// SourceVersion="2019.21">
ret.Append(xTimings.FIELD_source);
ret.Append(xTimings.VALUE_start);
ret.Append(timings.sourceVersion);
ret.Append(xTimings.VALUE_end);
ret.Append(xTimings.RECORD_end);
ret.Append(xTimings.CRLF);
// <EffectLayer>
ret.Append(level1);
ret.Append(xTimings.RECORD_start);
ret.Append(xTimings.TABLE_layers);
ret.Append(xTimings.RECORD_end);
ret.Append(xTimings.CRLF);
for (int i = 0; i < timings.effects.Count; i++)
{
effect = timings.effects[i];
ret.Append(level2);
ret.Append(xTimings.RECORD_start);
ret.Append(xEffect.TABLE_Effect);
ret.Append(xTimings.SPC);
// label="foo"
ret.Append(xEffect.FIELD_label);
ret.Append(xTimings.VALUE_start);
switch (labelType)
{
case xTimings.LabelTypes.None:
// Append Nothing!
break;
case xTimings.LabelTypes.Numbers:
ret.Append(effect.xlabel);
break;
case xTimings.LabelTypes.NoteNames:
label = "";
if (effect.Midi >= 0 && effect.Midi <= 127)
{
//label = SequenceFunctions.noteNames[timings.effects[i].Midi];
label = xUtils.noteNames[effect.Midi];
}
ret.Append(label);
break;
case xTimings.LabelTypes.MidiNumbers:
ret.Append(effect.Midi.ToString());
break;
case xTimings.LabelTypes.KeyNumbers:
ret.Append(effect.Midi.ToString());
break;
case xTimings.LabelTypes.KeyNames:
label = "";
if (effect.Midi >= 0 && effect.Midi <= 24)
{
label = SequenceFunctions.keyNames[effect.Midi];
}
ret.Append(label);
break;
case xTimings.LabelTypes.Letters:
ret.Append(effect.xlabel);
break;
case xTimings.LabelTypes.Frequency:
label = "";
if (effect.Midi >= 0 && effect.Midi <= 127)
{
label = SequenceFunctions.noteFreqs[effect.Midi];
}
ret.Append(label);
break;
}
ret.Append(xTimings.VALUE_end);
ret.Append(xTimings.SPC);
// starttime="50"
ret.Append(xEffect.FIELD_start);
ret.Append(xTimings.VALUE_start);
ret.Append(timings.effects[i].starttime.ToString());
ret.Append(xTimings.VALUE_end);
ret.Append(xTimings.SPC);
// endtime="350" />
ret.Append(xEffect.FIELD_end);
ret.Append(xTimings.VALUE_start);
ret.Append(timings.effects[i].endtime.ToString());
ret.Append(xTimings.VALUE_end);
ret.Append(xTimings.SPC);
ret.Append(xEffect.RECORD_end);
ret.Append(xTimings.CRLF);
}
// </EffectLayer>
ret.Append(level1);
ret.Append(xTimings.RECORDS_done);
ret.Append(xTimings.TABLE_layers);
ret.Append(xTimings.RECORD_end);
ret.Append(xTimings.CRLF);
// </timing>
ret.Append(level0);
ret.Append(xTimings.RECORDS_done);
ret.Append(xTimings.TABLE_timing);
ret.Append(xTimings.RECORD_end);
return(ret.ToString());
}
