def testQuantizeNoteSequenceAbsolute(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(12, 100, 0.01, 10.0), (11, 55, 0.22, 0.50), (40, 45, 2.50, 3.50), (55, 120, 4.0, 4.01), (52, 99, 4.75, 5.0)]) testing_lib.add_chords_to_sequence( self.note_sequence, [('B7', 0.22), ('Em9', 4.0)]) testing_lib.add_control_changes_to_sequence( self.note_sequence, 0, [(2.0, 64, 127), (4.0, 64, 0)]) expected_quantized_sequence = copy.deepcopy(self.note_sequence) expected_quantized_sequence.quantization_info.steps_per_second = 4 testing_lib.add_quantized_steps_to_sequence( expected_quantized_sequence, [(0, 40), (1, 2), (10, 14), (16, 17), (19, 20)]) testing_lib.add_quantized_chord_steps_to_sequence( expected_quantized_sequence, [1, 16]) testing_lib.add_quantized_control_steps_to_sequence( expected_quantized_sequence, [8, 16]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=4) self.assertProtoEquals(expected_quantized_sequence, quantized_sequence)
def testExtractPerformances(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_lib.extract_performances(quantized_sequence) self.assertEqual(1, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, min_events_discard=1, max_events_truncate=10) self.assertEqual(1, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, min_events_discard=8, max_events_truncate=10) self.assertEqual(0, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, min_events_discard=1, max_events_truncate=3) self.assertEqual(1, len(perfs)) self.assertEqual(3, len(perfs[0])) perfs, _ = performance_lib.extract_performances( quantized_sequence, max_steps_truncate=100) self.assertEqual(1, len(perfs)) self.assertEqual(100, perfs[0].num_steps)
def testFromQuantizedNoteSequenceWithQuantizedVelocity(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 127, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = list(performance_lib.Performance( quantized_sequence, num_velocity_bins=16)) pe = performance_lib.PerformanceEvent expected_performance = [ pe(pe.VELOCITY, 13), pe(pe.NOTE_ON, 60), pe(pe.NOTE_ON, 64), pe(pe.TIME_SHIFT, 100), pe(pe.VELOCITY, 16), pe(pe.NOTE_ON, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 60), ] self.assertEqual(expected_performance, performance)
def testNotePerformanceFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 97, 0.0, 4.0), (64, 97, 0.0, 3.0), (67, 121, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.NotePerformance(quantized_sequence, num_velocity_bins=16) pe = performance_lib.PerformanceEvent expected_performance = [ (pe(pe.TIME_SHIFT, 0), pe(pe.NOTE_ON, 60), pe(pe.VELOCITY, 13), pe(pe.DURATION, 400)), (pe(pe.TIME_SHIFT, 0), pe(pe.NOTE_ON, 64), pe(pe.VELOCITY, 13), pe(pe.DURATION, 300)), (pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_ON, 67), pe(pe.VELOCITY, 16), pe(pe.DURATION, 100)), ] self.assertEqual(expected_performance, list(performance)) ns = performance.to_sequence(instrument=0) self.assertEqual(self.note_sequence, ns)
def transform(self, note_sequence): try: if self._steps_per_quarter is not None: quantized_sequence = sequences_lib.quantize_note_sequence( note_sequence, self._steps_per_quarter) else: quantized_sequence = sequences_lib.quantize_note_sequence_absolute( note_sequence, self._steps_per_second) return [quantized_sequence] except sequences_lib.MultipleTimeSignatureError as e: tf.logging.warning('Multiple time signatures in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([statistics.Counter( 'sequences_discarded_because_multiple_time_signatures', 1)]) return [] except sequences_lib.MultipleTempoError as e: tf.logging.warning('Multiple tempos found in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([statistics.Counter( 'sequences_discarded_because_multiple_tempos', 1)]) return [] except sequences_lib.BadTimeSignatureError as e: tf.logging.warning('Bad time signature in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([statistics.Counter( 'sequences_discarded_because_bad_time_signature', 1)]) return []
def testProgramAndIsDrumFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)], program=1) testing_lib.add_track_to_sequence( self.note_sequence, 1, [(36, 100, 0.0, 4.0), (48, 100, 0.0, 4.0)], program=2) testing_lib.add_track_to_sequence( self.note_sequence, 2, [(57, 100, 0.0, 0.1)], is_drum=True) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.Performance(quantized_sequence, instrument=0) self.assertEqual(1, performance.program) self.assertFalse(performance.is_drum) performance = performance_lib.Performance(quantized_sequence, instrument=1) self.assertEqual(2, performance.program) self.assertFalse(performance.is_drum) performance = performance_lib.Performance(quantized_sequence, instrument=2) self.assertIsNone(performance.program) self.assertTrue(performance.is_drum) performance = performance_lib.Performance(quantized_sequence) self.assertIsNone(performance.program) self.assertIsNone(performance.is_drum)
def testProgramAndIsDrumFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)], program=1) testing_lib.add_track_to_sequence(self.note_sequence, 1, [(36, 100, 0.0, 4.0), (48, 100, 0.0, 4.0)], program=2) testing_lib.add_track_to_sequence(self.note_sequence, 2, [(57, 100, 0.0, 0.1)], is_drum=True) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.Performance(quantized_sequence, instrument=0) self.assertEqual(1, performance.program) self.assertFalse(performance.is_drum) performance = performance_lib.Performance(quantized_sequence, instrument=1) self.assertEqual(2, performance.program) self.assertFalse(performance.is_drum) performance = performance_lib.Performance(quantized_sequence, instrument=2) self.assertIsNone(performance.program) self.assertTrue(performance.is_drum) performance = performance_lib.Performance(quantized_sequence) self.assertIsNone(performance.program) self.assertIsNone(performance.is_drum)
def transform(self, note_sequence): try: if self._steps_per_quarter is not None: quantized_sequence = sequences_lib.quantize_note_sequence( note_sequence, self._steps_per_quarter) else: quantized_sequence = sequences_lib.quantize_note_sequence_absolute( note_sequence, self._steps_per_second) return [quantized_sequence] except sequences_lib.MultipleTimeSignatureError as e: tf.logging.warning( 'Multiple time signatures in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([ statistics.Counter( 'sequences_discarded_because_multiple_time_signatures', 1) ]) return [] except sequences_lib.MultipleTempoError as e: tf.logging.warning('Multiple tempos found in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([ statistics.Counter( 'sequences_discarded_because_multiple_tempos', 1) ]) return [] except sequences_lib.BadTimeSignatureError as e: tf.logging.warning('Bad time signature in NoteSequence %s: %s', note_sequence.filename, e) self._set_stats([ statistics.Counter( 'sequences_discarded_because_bad_time_signature', 1) ]) return []
def testFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.Performance(quantized_sequence) self.assertEqual(100, performance.steps_per_second) pe = performance_lib.PerformanceEvent expected_performance = [ pe(pe.NOTE_ON, 60), pe(pe.NOTE_ON, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_ON, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 60), ] self.assertEqual(expected_performance, list(performance))
def testFromQuantizedNoteSequenceWithQuantizedVelocity(self): testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 127, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = list( performance_lib.Performance(quantized_sequence, num_velocity_bins=16)) pe = performance_lib.PerformanceEvent expected_performance = [ pe(pe.VELOCITY, 13), pe(pe.NOTE_ON, 60), pe(pe.NOTE_ON, 64), pe(pe.TIME_SHIFT, 100), pe(pe.VELOCITY, 16), pe(pe.NOTE_ON, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 60), ] self.assertEqual(expected_performance, performance)
def testExtractPerformances(self): music_testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_pipeline.extract_performances( quantized_sequence) self.assertEqual(1, len(perfs)) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, min_events_discard=1, max_events_truncate=10) self.assertEqual(1, len(perfs)) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, min_events_discard=8, max_events_truncate=10) self.assertEqual(0, len(perfs)) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, min_events_discard=1, max_events_truncate=3) self.assertEqual(1, len(perfs)) self.assertEqual(3, len(perfs[0])) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, max_steps_truncate=100) self.assertEqual(1, len(perfs)) self.assertEqual(100, perfs[0].num_steps)
def testExtractPerformancesMultiProgram(self): music_testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)]) self.note_sequence.notes[0].program = 2 quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_pipeline.extract_performances(quantized_sequence) self.assertEmpty(perfs)
def testExtractPerformancesMultiProgram(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)]) self.note_sequence.notes[0].program = 2 quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_lib.extract_performances(quantized_sequence) self.assertEqual(0, len(perfs))
def testExtractPerformancesNonZeroStart(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_lib.extract_performances( quantized_sequence, start_step=400, min_events_discard=1) self.assertEqual(0, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, start_step=0, min_events_discard=1) self.assertEqual(1, len(perfs))
def testExtractPerformancesNonZeroStart(self): music_testing_lib.add_track_to_sequence(self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, start_step=400, min_events_discard=1) self.assertEqual(0, len(perfs)) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, start_step=0, min_events_discard=1) self.assertEqual(1, len(perfs))
def testToSequence(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.Performance(quantized_sequence) performance_ns = performance.to_sequence() # Make comparison easier by sorting. performance_ns.notes.sort(key=lambda n: (n.start_time, n.pitch)) self.note_sequence.notes.sort(key=lambda n: (n.start_time, n.pitch)) self.assertEqual(self.note_sequence, performance_ns)
def testAssertIsQuantizedNoteSequence(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(12, 100, 0.01, 10.0), (11, 55, 0.22, 0.50), (40, 45, 2.50, 3.50), (55, 120, 4.0, 4.01), (52, 99, 4.75, 5.0)]) relative_quantized_sequence = sequences_lib.quantize_note_sequence( self.note_sequence, steps_per_quarter=self.steps_per_quarter) absolute_quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=4) sequences_lib.assert_is_quantized_sequence(relative_quantized_sequence) sequences_lib.assert_is_quantized_sequence(absolute_quantized_sequence) with self.assertRaises(sequences_lib.QuantizationStatusException): sequences_lib.assert_is_quantized_sequence(self.note_sequence)
def testExtractPerformancesSplitInstruments(self): music_testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) music_testing_lib.add_track_to_sequence( self.note_sequence, 1, [(62, 100, 0.0, 2.0), (64, 100, 2.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, split_instruments=True) self.assertLen(perfs, 2) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, min_events_discard=8, split_instruments=True) self.assertLen(perfs, 1) perfs, _ = performance_pipeline.extract_performances( quantized_sequence, min_events_discard=16, split_instruments=True) self.assertEmpty(perfs)
def testExtractPerformancesSplitInstruments(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0)]) testing_lib.add_track_to_sequence( self.note_sequence, 1, [(62, 100, 0.0, 2.0), (64, 100, 2.0, 4.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) perfs, _ = performance_lib.extract_performances( quantized_sequence, split_instruments=True) self.assertEqual(2, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, min_events_discard=8, split_instruments=True) self.assertEqual(1, len(perfs)) perfs, _ = performance_lib.extract_performances( quantized_sequence, min_events_discard=16, split_instruments=True) self.assertEqual(0, len(perfs))
def testNotePerformanceFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 97, 0.0, 4.0), (64, 97, 0.0, 3.0), (67, 121, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.NotePerformance( quantized_sequence, num_velocity_bins=16) pe = performance_lib.PerformanceEvent expected_performance = [ (pe(pe.TIME_SHIFT, 0), pe(pe.NOTE_ON, 60), pe(pe.VELOCITY, 13), pe(pe.DURATION, 400)), (pe(pe.TIME_SHIFT, 0), pe(pe.NOTE_ON, 64), pe(pe.VELOCITY, 13), pe(pe.DURATION, 300)), (pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_ON, 67), pe(pe.VELOCITY, 16), pe(pe.DURATION, 100)), ] self.assertEqual(expected_performance, list(performance)) ns = performance.to_sequence(instrument=0) self.assertEqual(self.note_sequence, ns)
def testFromQuantizedNoteSequence(self): testing_lib.add_track_to_sequence( self.note_sequence, 0, [(60, 100, 0.0, 4.0), (64, 100, 0.0, 3.0), (67, 100, 1.0, 2.0)]) quantized_sequence = sequences_lib.quantize_note_sequence_absolute( self.note_sequence, steps_per_second=100) performance = performance_lib.Performance(quantized_sequence) self.assertEqual(100, performance.steps_per_second) pe = performance_lib.PerformanceEvent expected_performance = [ pe(pe.NOTE_ON, 60), pe(pe.NOTE_ON, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_ON, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 67), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 64), pe(pe.TIME_SHIFT, 100), pe(pe.NOTE_OFF, 60), ] self.assertEqual(expected_performance, list(performance))
def split_performance(performance, steps_per_segment, new_performance_fn, clip_tied_notes=False): """Splits a performance into multiple fixed-length segments. Args: performance: A Performance (or MetricPerformance) object to split. steps_per_segment: The number of quantized steps per segment. new_performance_fn: A function to create new Performance (or MetricPerformance objects). Takes `quantized_sequence` and `start_step` arguments. clip_tied_notes: If True, clip tied notes across segments by converting each segment to NoteSequence and back. Returns: A list of performance segments. """ segments = [] cur_segment = new_performance_fn(quantized_sequence=None, start_step=0) cur_step = 0 for e in performance: if e.event_type != performance_lib.PerformanceEvent.TIME_SHIFT: if cur_step == steps_per_segment: # At a segment boundary, note-offs happen before the cutoff. # Everything else happens after. if e.event_type != performance_lib.PerformanceEvent.NOTE_OFF: segments.append(cur_segment) cur_segment = new_performance_fn( quantized_sequence=None, start_step=len(segments) * steps_per_segment) cur_step = 0 cur_segment.append(e) else: # We're not at a segment boundary. cur_segment.append(e) else: if cur_step + e.event_value <= steps_per_segment: # If it's a time shift, but we're still within the current segment, # just append to current segment. cur_segment.append(e) cur_step += e.event_value else: # If it's a time shift that goes beyond the current segment, possibly # split the time shift into two events and create a new segment. cur_segment_steps = steps_per_segment - cur_step if cur_segment_steps > 0: cur_segment.append(performance_lib.PerformanceEvent( event_type=performance_lib.PerformanceEvent.TIME_SHIFT, event_value=cur_segment_steps)) segments.append(cur_segment) cur_segment = new_performance_fn( quantized_sequence=None, start_step=len(segments) * steps_per_segment) cur_step = 0 new_segment_steps = e.event_value - cur_segment_steps if new_segment_steps > 0: cur_segment.append(performance_lib.PerformanceEvent( event_type=performance_lib.PerformanceEvent.TIME_SHIFT, event_value=new_segment_steps)) cur_step += new_segment_steps segments.append(cur_segment) # There may be a final segment with zero duration. If so, remove it. if segments and segments[-1].num_steps == 0: segments = segments[:-1] if clip_tied_notes: # Convert each segment to NoteSequence and back to remove notes that are # held across segment boundaries. for i in range(len(segments)): sequence = segments[i].to_sequence() if isinstance(segments[i], performance_lib.MetricPerformance): # Performance is quantized relative to meter. quantized_sequence = sequences_lib.quantize_note_sequence( sequence, steps_per_quarter=segments[i].steps_per_quarter) else: # Performance is quantized with absolute timing. quantized_sequence = sequences_lib.quantize_note_sequence_absolute( sequence, steps_per_second=segments[i].steps_per_second) segments[i] = new_performance_fn( quantized_sequence=quantized_sequence, start_step=segments[i].start_step) segments[i].set_length(steps_per_segment) return segments
def split_performance(performance, steps_per_segment, new_performance_fn, clip_tied_notes=False): """Splits a performance into multiple fixed-length segments. Args: performance: A Performance (or MetricPerformance) object to split. steps_per_segment: The number of quantized steps per segment. new_performance_fn: A function to create new Performance (or MetricPerformance objects). Takes `quantized_sequence` and `start_step` arguments. clip_tied_notes: If True, clip tied notes across segments by converting each segment to NoteSequence and back. Returns: A list of performance segments. """ segments = [] cur_segment = new_performance_fn(quantized_sequence=None, start_step=0) cur_step = 0 for e in performance: if e.event_type != performance_lib.PerformanceEvent.TIME_SHIFT: if cur_step == steps_per_segment: # At a segment boundary, note-offs happen before the cutoff. # Everything else happens after. if e.event_type != performance_lib.PerformanceEvent.NOTE_OFF: segments.append(cur_segment) cur_segment = new_performance_fn(quantized_sequence=None, start_step=len(segments) * steps_per_segment) cur_step = 0 cur_segment.append(e) else: # We're not at a segment boundary. cur_segment.append(e) else: if cur_step + e.event_value <= steps_per_segment: # If it's a time shift, but we're still within the current segment, # just append to current segment. cur_segment.append(e) cur_step += e.event_value else: # If it's a time shift that goes beyond the current segment, possibly # split the time shift into two events and create a new segment. cur_segment_steps = steps_per_segment - cur_step if cur_segment_steps > 0: cur_segment.append( performance_lib.PerformanceEvent( event_type=performance_lib.PerformanceEvent. TIME_SHIFT, event_value=cur_segment_steps)) segments.append(cur_segment) cur_segment = new_performance_fn(quantized_sequence=None, start_step=len(segments) * steps_per_segment) cur_step = 0 new_segment_steps = e.event_value - cur_segment_steps if new_segment_steps > 0: cur_segment.append( performance_lib.PerformanceEvent( event_type=performance_lib.PerformanceEvent. TIME_SHIFT, event_value=new_segment_steps)) cur_step += new_segment_steps segments.append(cur_segment) # There may be a final segment with zero duration. If so, remove it. if segments and segments[-1].num_steps == 0: segments = segments[:-1] if clip_tied_notes: # Convert each segment to NoteSequence and back to remove notes that are # held across segment boundaries. for i in range(len(segments)): sequence = segments[i].to_sequence() if isinstance(segments[i], performance_lib.MetricPerformance): # Performance is quantized relative to meter. quantized_sequence = sequences_lib.quantize_note_sequence( sequence, steps_per_quarter=segments[i].steps_per_quarter) else: # Performance is quantized with absolute timing. quantized_sequence = sequences_lib.quantize_note_sequence_absolute( sequence, steps_per_second=segments[i].steps_per_second) segments[i] = new_performance_fn( quantized_sequence=quantized_sequence, start_step=segments[i].start_step) segments[i].set_length(steps_per_segment) return segments