/**
* Copy constructor.
*
* @param n note to be copied
* @author Marcel Karras
*/
public Note(final Note n) {
this.noteString = n.noteString;
this.breakPoints = n.breakPoints;
this.duration = n.getDuration();
this.dynamic = n.getDynamic();
this.myPhrase = n.getMyPhrase();
this.offset = n.offset;
this.pan = n.pan;
this.pitch = n.pitch;
this.pitchType = n.pitchType;
this.rhythmValue = n.rhythmValue;
this.sampleStartTime = n.sampleStartTime;
}
public boolean hasNote(Note paramNote) {
for (int i = 0; i < this.phraseList.size(); i++) {
Phrase localPhrase = (Phrase) this.phraseList.get(i);
Note[] arrayOfNote = localPhrase.getNoteArray();
for (int j = 0; j < arrayOfNote.length; j++) {
Note localNote = arrayOfNote[j];
if (paramNote.getNote().equals(localNote.getNote())) {
return true;
}
}
}
return false;
}
public void flam(double paramDouble) {
int i = 0;
Enumeration localEnumeration1 = this.phraseList.elements();
while (localEnumeration1.hasMoreElements()) {
double d = paramDouble * i;
Phrase localPhrase = (Phrase) localEnumeration1.nextElement();
Enumeration localEnumeration2 = localPhrase.getNoteList().elements();
while (localEnumeration2.hasMoreElements()) {
Note localNote = (Note) localEnumeration2.nextElement();
localNote.setOffset(d);
}
i++;
}
}
private static Score adjustTempo(Score paramScore) {
Enumeration localEnumeration1 = paramScore.getPartList().elements();
double d1 = 60.0D / paramScore.getTempo();
while (localEnumeration1.hasMoreElements()) {
Part localPart = (Part) localEnumeration1.nextElement();
double d2 = d1;
if (localPart.getTempo() != 0.0D) {
d2 = 60.0D / localPart.getTempo();
}
Enumeration localEnumeration2 = localPart.getPhraseList().elements();
while (localEnumeration2.hasMoreElements()) {
Phrase localPhrase = (Phrase) localEnumeration2.nextElement();
Enumeration localEnumeration3 = localPhrase.getNoteList().elements();
while (localEnumeration3.hasMoreElements()) {
Note localNote = (Note) localEnumeration3.nextElement();
localNote.setRhythmValue(localNote.getRhythmValue() * d2);
localNote.setDuration(localNote.getDuration() * d2);
}
}
}
return paramScore;
}
@SuppressWarnings({"rawtypes", "unchecked"})
private static void noteOn(
int phrIndex,
Note[] curNote,
SMFTools smf,
int i,
double[] currentLength,
double startTime,
Vector phrVct,
short midiChannel,
short pitch,
int dynamic,
Vector evtList) {
phrIndex = -1;
// work out what phrase is ready to accept a note
for (int p = 0; p < phrVct.size(); p++) {
// Warning 0.02 should really be fixed
if (currentLength[p] <= (startTime + 0.08)) {
phrIndex = p;
break;
}
}
// need to create new phrase for a new voice?
if (phrIndex == -1) {
phrIndex = phrVct.size();
phrVct.addElement(new Phrase(startTime));
currentLength[phrIndex] = startTime;
}
// Do we need to add a rest ?
if ((startTime > currentLength[phrIndex]) && (curNote[phrIndex] != null)) {
double newTime = startTime - currentLength[phrIndex];
// perform a level of quantisation first
if (newTime < 0.25) {
double length = curNote[phrIndex].getRhythmValue();
curNote[phrIndex].setRhythmValue(length + newTime);
} else {
Note restNote = new Note(REST, newTime, 0);
restNote.setPan(midiChannel);
restNote.setDuration(newTime);
restNote.setOffset(0.0);
((Phrase) phrVct.elementAt(phrIndex)).addNote(restNote);
}
currentLength[phrIndex] += newTime;
}
// get end time
double time = MidiUtil.getEndEvt(pitch, evtList, i) / (double) smf.getPPQN();
// create the new note
Note tempNote = new Note(pitch, time, dynamic);
tempNote.setDuration(time);
curNote[phrIndex] = tempNote;
((Phrase) phrVct.elementAt(phrIndex)).addNote(curNote[phrIndex]);
currentLength[phrIndex] += curNote[phrIndex].getRhythmValue();
}
/**
* Returns a copy of this note
*
* @return Note
*/
public Note copy() {
Note note;
if (pitchType == MIDI_PITCH) {
note = new Note(this.getPitch(), this.rhythmValue, this.dynamic);
} else note = new Note(this.getFrequency(), this.rhythmValue, this.dynamic);
note.setPan(this.pan);
note.setDuration(this.duration);
note.setOffset(this.offset);
note.setSampleStartTime(this.sampleStartTime);
note.setMyPhrase(this.myPhrase);
for (int i = 0; i < breakPoints.length; i++) {
if (this.breakPoints[i] != null) note.setBreakPoints(i, this.getBreakPoints(i));
}
return note;
}
@Override
public void handleScore(Score score, ScoreContext ctx) {
Part part = ctx.getParts().get(PartType.ARPEGGIO);
if (part == null) {
return;
}
Part mainPart = ctx.getParts().get(PartType.MAIN);
double currentMeasureSize = 0;
double normalizedMeasureSize = ctx.getNormalizedMeasureSize();
SpecialNoteType specialNoteType = null;
for (Phrase phrase : mainPart.getPhraseArray()) {
if (Chance.test(20)) { // change the special note type
if (Chance.test(60)) { // to a new value
specialNoteType =
SpecialNoteType.values()[random.nextInt(SpecialNoteType.values().length)];
} else { // reset
specialNoteType = null;
}
}
Phrase arpeggioPhrase = new Phrase();
arpeggioPhrase.setTitle("Arpeggio phrase");
Scale currentScale = ((ExtendedPhrase) phrase).getScale();
// get copies of the static ones, so that we can shuffle them without affecting the original
List<Chord> scaleChords = new ArrayList<Chord>(ChordUtils.chords.get(currentScale));
Collections.shuffle(scaleChords, random);
Note[] notes = phrase.getNoteArray();
List<ToneType> firstToneTypes = new ArrayList<>();
int measures = 0;
Note[] currentNotes = null;
boolean useTwoNoteChords = Chance.test(14);
Chord chord = null;
for (int i = 0; i < notes.length; i++) {
Note currentNote = notes[i];
if (currentNote.getRhythmValue() == 0) {
continue; // rhythm value is 0 for the first notes of a (main-part) chord. So progress to
// the next
}
boolean lastMeasure = measures == ctx.getMeasures() - 1;
if (currentMeasureSize == 0 && !currentNote.isRest() && !lastMeasure) {
boolean preferStable =
ToneResolver.needsContrastingChord(firstToneTypes, ToneGroups.UNSTABLE);
boolean preferUnstable =
ToneResolver.needsContrastingChord(firstToneTypes, ToneGroups.STABLE);
// change the chord only in 1/4 of the cases
if (currentNotes == null || Chance.test(25)) {
// no alternatives for now - only 3-note chords
Chord previous = chord;
chord =
ChordUtils.getChord(
ctx,
currentNote.getPitch(),
previous,
scaleChords,
scaleChords,
scaleChords,
preferStable,
preferUnstable);
if (chord != null) {
int[] pitches = chord.getPitches();
// remove the middle note in some cases (but make it possible to have three-note
// chords in a generally two-note phrase)
if (pitches.length == 3 && useTwoNoteChords && Chance.test(90)) {
pitches = ArrayUtils.remove(pitches, 1);
}
int count = Chance.test(90) ? (Chance.test(80) ? 4 : 2) : (Chance.test(80) ? 3 : 5);
currentNotes = new Note[count];
double length = normalizedMeasureSize / count;
for (int k = 0; k < count; k++) {
Note note = NoteFactory.createNote(pitches[random.nextInt(pitches.length)], length);
note.setDynamic(
InstrumentGroups.getInstrumentSpecificDynamics(
65 + random.nextInt(10), part.getInstrument()));
if (specialNoteType != null) {
note.setDuration(note.getRhythmValue() * specialNoteType.getValue());
}
currentNotes[k] = note;
}
}
}
if (Chance.test(85) && currentNotes != null) {
for (Note note : currentNotes) {
arpeggioPhrase.addNote(note);
}
} else {
arpeggioPhrase.addRest(new Rest(normalizedMeasureSize));
}
} else if (currentMeasureSize == 0 && (currentNote.isRest() || lastMeasure)) {
arpeggioPhrase.addRest(new Rest(normalizedMeasureSize));
}
currentMeasureSize += currentNote.getRhythmValue();
if (currentMeasureSize >= normalizedMeasureSize) {
currentMeasureSize = 0;
measures++;
}
}
part.add(arpeggioPhrase);
}
}
public boolean sameDuration(Note note) {
return this.getDuration() == note.getDuration();
}
public boolean samePitch(Note note) {
return this.getPitch() == note.getPitch();
}