def playNote(self, note): p = Note(note) p.quarterLength = 1.5 stream_obj = stream.Stream() stream_obj.append(p) sp = midi.realtime.StreamPlayer(stream_obj) sp.play()
def test_parse_music21_note(self): note = Note("A3") note.quarterLength = 4.0 parsed_pitch = self.music_xml_plugin.parse_note_pitch(str(note.pitch)) parsed_type = self.music_xml_plugin.parse_note_type(note.quarterLength) self.assertEqual(parsed_pitch, NotePitch.A3) self.assertEqual(parsed_type, NoteType.whole) note = Note("G#5") note.quarterLength = 1.5 parsed_pitch = self.music_xml_plugin.parse_note_pitch(str(note.pitch)) parsed_type = self.music_xml_plugin.parse_note_type(note.quarterLength) self.assertEqual(parsed_pitch, NotePitch.GS5) self.assertEqual(parsed_type, NoteType.dotted_quarter) note = Note("A#99") note.quarterLength = 83.1 parsed_pitch = self.music_xml_plugin.parse_note_pitch(str(note.pitch)) parsed_type = self.music_xml_plugin.parse_note_type(note.quarterLength) self.assertEqual(parsed_pitch, NotePitch.REST) self.assertEqual(parsed_type, NoteType.quarter)
def add_bass_closing(roman, duration, bass): '''Generate a closing riff for the bassline, given chord and duration in eighths''' filled = 0 length_weight = 2 # Longer notes later in the bar root = roman.root() # Root pitch of the chord (NOT a note object) while filled < duration: note = Note(deepcopy(root)) length = min(random.randint(1,length_weight),duration-filled) # cap at time left note.quarterLength = length/2.0 note.octave -= 2 bass.append(note) filled += length length_weight += length # Longer notes later in the bar
def add_to_melody_sequence(new_melody_sequence, elem, bar_length): if type(elem) not in [Note, Rest]: pass elif bar_length + elem.quarterLength >= time_signature: extra = bar_length + elem.quarterLength - time_signature elem.quarterLength = time_signature - bar_length if elem.quarterLength > 0.0: new_melody_sequence += [elem] bar_length = extra # The possible extra note elem = Note(elem.nameWithOctave) if type(elem) is Note else Rest() elem.quarterLength = extra if elem.quarterLength > 0.0: new_melody_sequence += [elem] else: new_melody_sequence += [elem] bar_length += elem.quarterLength return (new_melody_sequence, elem, bar_length)
def read_vmf_string(vmf_string): """ Reads VMF data from a string to a Score Stream. :param vmf_string: The contents of the VMF file as a string. :return: A music21 score instance containing the music in the VMF file. """ parts_converted = {} vmf = json.loads(vmf_string) # create a score score = Score() # Get the initial data number_of_parts = vmf['header']['number_of_parts'] number_of_voices = vmf['header']['number_of_voices'] smallest_note = float(Fraction(vmf['header']['tick_value'])) # create the parts and first measure. for voice_number in range(number_of_parts): part = Part() voice = Voice() part.append(voice) score.append(part) # get the body of the vmf body = vmf['body'] part_number = 0 # We do this because we want to do each part at a time. for voice_number in range(number_of_voices): # Get all ticks for a given part. part = [tick[voice_number] for tick in body] current_element = None current_voice = None # iterate over each tick for tick in part: if current_voice is None: # Get the parent part if it exists. try: current_part = parts_converted[tick[-1]] # add a new voice and write to it. voice = Voice() initial_key_signature = KeySignature(vmf['header']['key_signature']['0.0']) initial_time_signature = TimeSignature(vmf['header']['time_signature']['0.0']) voice.append(initial_key_signature) voice.append(initial_time_signature) current_part.append(voice) except KeyError: # Add it to our dictionary otherwise. current_part = score.parts[part_number] part_number += 1 parts_converted[tick[-1]] = current_part # Get the last voice. current_voice = current_part.voices[-1] if tick[0] == 1: if current_element is not None: # check for precision and adjust rounded = round(current_element.quarterLength) if abs(current_element.quarterLength - rounded) < PRECISION: current_element.quarterLength = rounded # append to the part current_voice.append(current_element) # Find how many notes to write. This will always be an int. number_of_notes = int(find_number_of_notes_in_tick(tick)) if number_of_notes == 1: # create a new note current_element = Note(Pitch(pitchClass=tick[3], octave=tick[4])) else: pitches = [] # create the pitches. # From the beginning to the end of the pitch section of the tick. for i in range(FIRST_PITCH_INDEX, FIRST_PITCH_INDEX + 2 * number_of_notes, 2): pitch = Pitch(pitchClass=tick[i], octave=tick[i + 1]) pitches.append(pitch) # create a new chord with these pitches. current_element = Chord(pitches) # set the velocity of the note. current_element.volume.velocity = DynamicConverter.vmf_to_velocity(tick[DYNAMIC_BIT]) # set the articulation if tick[ARTICULATION_BIT] != 0: current_element.articulations.append( ArticulationConverter.vmf_to_articulation(tick[ARTICULATION_BIT])) # set the value for this tick. current_element.quarterLength = smallest_note elif tick[0] == 2: # extend previous note current_element.quarterLength += smallest_note elif tick[0] == 0 and (isinstance(current_element, note.Note) or current_element is None): if current_element is not None: # check for precision and adjust rounded = round(current_element.quarterLength) if abs(current_element.quarterLength - rounded) < PRECISION: current_element.quarterLength = rounded # append to the part current_voice.append(current_element) # create new rest current_element = Rest() # Set the value for this tick. current_element.quarterLength = smallest_note elif tick[0] == 0 and isinstance(current_element, note.Rest): # extend previous rest. current_element.quarterLength += smallest_note # Append the last element in progress. if current_element is not None: # check for precision and adjust rounded = round(current_element.quarterLength) if abs(current_element.quarterLength - rounded) < PRECISION: current_element.quarterLength = rounded # append to the part current_voice.append(current_element) # create the stream for time signature changes time_signature_stream = Stream() for offset, time_signature_str in sorted(vmf['header']['time_signature'].items()): time_signature = TimeSignature(time_signature_str) time_signature_stream.append(time_signature) time_signature_stream[-1].offset = float(offset) # finish up the file. for part in score.parts: for voice in part.voices: voice.makeMeasures(inPlace=True, meterStream=time_signature_stream) for offset, t in sorted(vmf['header']['tempo'].items()): mm = tempo.MetronomeMark(number=t, referent=note.Note(type='quarter')) voice.insert(offset, mm) for offset, ks in sorted(vmf['header']['key_signature'].items()): voice.insert(offset, KeySignature(ks)) return score