3jYdZddlmZddlmZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddlmZmZmZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl m Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-ej\r ddl m/Z/ddl0m1Z1ejddZ3e-Z4ejjdejlZ7GddejpZ9Gd d!ejtZ;Gd"d#e<Z=dfdgd%Z>dhd&Z?ejdf did'ZA djd)d* dkd+ZB dld,d- dmd.ZCd$d,d)d/ dnd0ZD dod1ZEejf dpd2ZFd,d(d)d3 dqd4ZGejf drd5ZHd,d(d)d3 dsd6ZIdtd7ZJ du dvd8ZKe jd9d:d;d)d* dwd<ZMd)d* dxd=ZNd>ZOdydzd?ZPd{d@ZQ dy d|dAZRdBZS dy d}dCZT d~ ddDZU d ddEZV d ddFZW ddGZX dl ddHZY ddIZZdd,d-dJZ[ ddKZ\ ddLZ]d)d* ddMZ^d)d* ddNZ_d$dO ddPZ`ejd,ddd$dQd)dR ddSZaddTZbddUZc dl ddVZdd$d)dW ddXZe ddYZfdd$d,d)dZd[Zgejd,dfd)d* dd\Zhd$d,dd)d] dd^Zidd)d_ dd`Zj d ddaZkdbZldd,d)dc dddZmeiemgZneodek(rddl Z e jyy)z Module to translate MIDI data to music21 Streams and vice versa. Note that quantization of notes takes place in the :meth:`~music21.stream.Stream.quantize` method not here. ) annotations)SequenceN)chord)common)opFrac)defaultsduration)dynamics) exceptions21) environment) instrument) ConductorUnpitchedPercussion deduplicatekey)meter)note) percussion)pitch)stream)tempo)volume) MidiTrack DeltaTimeMidiFile MidiEventChannelVoiceMessages MetaEventsputNumbersAsList getNumber putNumber)MIDIPercussionExceptionPercussionMapper)base) OffsetQLInzmidi.translate NotRestType)boundc,eZdZUded<ded<ded<y)TimedNoteEventintonTimeoffTimereventN)__name__ __module__ __qualname____annotations__C/DATA/.local/lib/python3.12/site-packages/music21/midi/translate.pyr+r+<s K L r5r+c eZdZy)TranslateExceptionNr0r1r2r4r5r6r8r8Br5r8c eZdZy)TranslateWarningNr9r4r5r6r<r<Fr:r5r<Fcztt|tjz}|r|tjz }|S)a Helper function to convert a music21 offset value to MIDI ticks, depends on *defaults.ticksPerQuarter* and *defaults.ticksAtStart*. Returns an int. >>> defaults.ticksPerQuarter 10080 >>> defaults.ticksAtStart 10080 >>> midi.translate.offsetToMidiTicks(0) 0 >>> midi.translate.offsetToMidiTicks(0, addStartDelay=True) 10080 >>> midi.translate.offsetToMidiTicks(1) 10080 >>> midi.translate.offsetToMidiTicks(20.5) 206640 )r,roundrticksPerQuarter ticksAtStart)o addStartDelaytickss r6offsetToMidiTicksrDMs6. a(2223 4E &&& Lr5c`tt|jtjzS)aY Converts a :class:`~music21.duration.Duration` object to midi ticks. Depends on *defaults.ticksPerQuarter*, Returns an int. Does not use defaults.ticksAtStart >>> n = note.Note() >>> n.duration.type = 'half' >>> midi.translate.durationToMidiTicks(n.duration) 20160 >>> d = duration.Duration('quarter') >>> dReference = midi.translate.ticksToDuration(10080, inputM21DurationObject=d) >>> dReference is d True >>> d.type 'quarter' >>> d.type = '16th' >>> d.quarterLength 0.25 >>> midi.translate.durationToMidiTicks(d) 2520 )r,r> quarterLengthrr?)ds r6durationToMidiTicksrHjs#2 uQ__x'?'??@ AAr5c^|tj}n|}t||z |_|S)a Converts a number of MIDI Ticks to a music21 duration.Duration() object. Optional parameters include ticksPerQuarter -- in case something other than the default.ticksPerQuarter (10080) is used in this file. And it can take a :class:`~music21.duration.Duration` object to modify, specified as *inputM21DurationObject* >>> d = midi.translate.ticksToDuration(10080) >>> d >>> d.type 'quarter' >>> n = note.Note() >>> midi.translate.ticksToDuration(30240, inputM21DurationObject=n.duration) >>> n.duration.type 'half' >>> n.duration.dots 1 More complex rhythms can also be set automatically: >>> d2 = duration.Duration() >>> d2reference = midi.translate.ticksToDuration(23625, inputM21DurationObject=d2) >>> d2 is d2reference True >>> d2.quarterLength 2.34375 >>> d2.type 'complex' >>> d2.components (DurationTuple(type='half', dots=0, quarterLength=2.0), DurationTuple(type='16th', dots=0, quarterLength=0.25), DurationTuple(type='64th', dots=1, quarterLength=0.09375)) >>> d2.components[2].type '64th' >>> d2.components[2].dots 1 )r DurationrrF)rCr?inputM21DurationObjectrGs r6ticksToDurationrLs6`%     "U_45AO Hr5utf-8encodingctg}t|tr|S||jx}d}n|}t||}|j |t ||}t j|_|j|d|_ |j || |jt|d||} || z }|S)a Returns a list of midi.MidiEvent objects found at the beginning of a track. A MidiTrack reference can be provided via the `mt` parameter. >>> startEvents = midi.translate.getStartEvents() >>> startEvents [, ] (Music21 DeltaTime events get assigned to the given channel, but this is not written out) >>> startEvents[0].channel 1 >>> mt = midi.MidiTrack(3) >>> midi.translate.getStartEvents(mt, channel=2, instrumentObj=instrument.Harpsichord()) [, , , ] Bug fixed in v9.6 -- the program change and delta time are written to the given track. channelignoreT)includeDeltaTime midiTrackrT) isinstancerbestNamerappendrr SEQUENCE_TRACK_NAMEtypeencodedata midiPrograminstrumentToMidiEvents) rWrT instrumentObjrPeventsrYpartNamedtmesubs r6getStartEventsrgs>)+F-+  }/E/E/G#G8"P 9g .B MM" 9g .B,,BGooh1BG MM"  ]%>%>%J$]6:/8-46 #  Mr5T addEndDelaycg}t|}|rtjnd|_|j |t |t j}d|_|j ||S)a Returns a list of midi.MidiEvent objects found at the end of a track. >>> midi.translate.getEndEvents() [, ] Set `addEndDelay` to False to omit the trailing rest before END_OF_TRACK: >>> midi.translate.getEndEvents(addEndDelay=False) [, ] * Changed in v10: getEndEvents does not take a channel. * New in v10.3: addEndDelay keyword. Note: the addEndDelay keyword and its threading through the MIDI export functions was AI-assisted (issue #1141). trackrrlr\r5) rrr@timerZrr END_OF_TRACKr^)rWrirbrdres r6 getEndEventsrps`0)+F  #B'2h##BG MM"   $ $ BBG MM" Mr5rBrirPcht|tjrO|jdur|j }t t jtj||||Stj|}tj}|jd|t ||||S)z Either calls streamToMidiFile on the music21Object or puts a copy of that object into a Stream (so as not to change activeSites, etc.) and calls streamToMidiFile on that object. * New in v10.3: addEndDelay keyword. Frqr) rXrStreamatSoundingPitchtoSoundingPitchstreamToMidiFiletcastcopydeepcopyinsert) music21ObjectrBrirP m21ObjectCopyss r6music21ObjectToMidiFiler,s-/  ( (E 1)99;Mv}}m D.;,7)13 3  m4 !==? M",7)13 3r5ct|tjstd|||z dk7r|t ||z |}|S|}|j d|S)aP Construct (or edit the duration of) a NotRest subclass, usually a note.Note (or a chord.Chord if provided to `returnClass`). * Changed in v8: no inputM21. * Changed in v10: Remove part about creating an Unpitched object -- that has been wrong for some time (probably since PercussionChords were introduced). z'Expected subclass of note.NotRest; got r)r?r TinPlace) issubclassrNotRest TypeErrorrLgetGrace)tOntOffr? returnClassnrs r6!_constructOrUpdateNotRestSubclassrOsr k4<< 0A+OPP s q /$*BQ#ST I] D ! Ir5c|\}}}|jdk(rtj}ntj}t ||||}t |tjr|j |j _nPt |tjr( tj|j }||_ ntd||j|j _d|j _t%j&tjtjz|S#t$rtj}YwxYw)a[ Convert a TimedNoteEvent to a music21.note.Note or a music21.note.Unpitched. A timed note event is a tuple of (onTime, offTime, MidiEvent) where the MidiEvent is the Note On. (The Note Off event is not used). This method is called as part of the midiToStream() conversion. In this example, we start a NOTE_ON event at offset 1.0 (at the standard 10080 to quarter) >>> mt = midi.MidiTrack(1) >>> dt1 = midi.DeltaTime(mt) >>> dt1.time = 10080 >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.pitch = 45 >>> me1.velocity = 94 This lasts until we send a NOTE_OFF event at offset 2.0. >>> dt2 = midi.DeltaTime(mt) >>> dt2.time = 20160 >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.pitch = 45 >>> me2.velocity = 0 Another system will package dt1, dt2 and me1 into a TimedNoteEvent tuple. In this example, me2 is not used. >>> tne1 = midi.translate.TimedNoteEvent(dt1.time, dt2.time, me1) >>> n = midi.translate.midiEventsToNote(tne1) >>> n.pitch >>> n.duration.quarterLength 1.0 >>> n.volume.velocity 94 If the channel is 10, an Unpitched element is returned. >>> me1.channel = 10 >>> unp = midi.translate.midiEventsToNote(tne1) >>> unp Access the `storedInstrument`: >>> unp.storedInstrument And with values that cannot be translated, a generic :class:`~music21.instrument.UnpitchedPercussion` instance is given: >>> me1.pitch = 1 >>> unp = midi.translate.midiEventsToNote(tne1) >>> unp.storedInstrument * Changed in v7.3: Returns None if `inputM21` is provided. Returns a :class:`~music21.note.Unpitched` instance if the event is on Channel 10. * Changed in v8: `inputM21` is no longer supported. The only supported usage now is two tuples. * Changed in v9.7: Expects a single TimedNoteEvent. rz>Got something other than a Note or Unpitched from conversion: F)rTr UnpitchedNoterrXrmidiPERCUSSION_MAPPERmidiPitchToInstrumentr$rrstoredInstrumentr8velocityrvelocityIsRelativerwrx)timedNoteEventr?rr midiOnEventrris r6midiEventsToNotermsL,C{b nn ii *    B"dii #)) B ' 1!77 8I8IJA !LRD Q  %--BII#(BII 66$))DNN*B //' 1..0A 1sD--E  E rVrTrPc|}d}g}|j|jdk7rs|rt||}|j|t|}tj |_|jj|d|_|j||rt|}|j|t|} tj| _|| _ t|tjrt|| _nT|j j"| _|j j%s|j j'| _t+t-|j.j0dz| _|j| |r8t||}t5|j6|_|j|t|} tj:| _|| _ | j | _| j(| _d| _|j| | | _| | _|S)a Translate a music21 Note to a list of four MIDI events -- the DeltaTime for the start of the note (0), the NOTE_ON event, the DeltaTime to the end of the note, and the NOTE_OFF event. If `includeDeltaTime` is not True then the DeltaTime events aren't returned, thus only two events are returned. The initial deltaTime object is always 0. It will be changed when processing Notes from a Stream. The `channel` can be specified, otherwise channel 1 is assumed. >>> n1 = note.Note('C#4') >>> eventList = midi.translate.noteToMidiEvents(n1) >>> eventList [, , , ] >>> n1.duration.quarterLength = 2.5 >>> eventList = midi.translate.noteToMidiEvents(n1) >>> eventList [, , , ] Omitting DeltaTimes: >>> eventList2 = midi.translate.noteToMidiEvents(n1, includeDeltaTime=False, channel=9) >>> eventList2 [, ] * Changed in v7: made keyword-only. * Changed in v8: added support for :class:`~music21.note.Unpitched`. NrRrSrkrUr)lyricrrZrr LYRICr\r]r^rNOTE_ONrTrXrr_get_unpitched_pitch_valuerr isTwelveTonegetCentShiftFromMidi centShiftr,r>rcachedRealizedrrHr rnNOTE_OFFcorrespondingEvent) inputM21rVrTrPnmt eventListrdreme1me2s r6noteToMidiEventsrs^ A B+-I"x~~'; 2w/B   R R ""..''(; R  " C#++CHCK!T^^$.q1 GGLL ww##%GG88:CMuQXX44s:;>> mt = midi.MidiTrack(1) >>> dt1 = midi.DeltaTime(mt) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.pitch = 45 >>> me1.velocity = 94 Note that only the times of the first NOTE_ON and last NOTE_OFF matter, so we don't even bother setting the time of dt3 and dt4. >>> dt3 = midi.DeltaTime(mt) >>> me3 = midi.MidiEvent(mt) >>> me3.type = midi.ChannelVoiceMessages.NOTE_OFF The pitches of the NOTE_OFF events are not checked by this function. They are assumed to have been aligned by the previous parser. >>> me3.pitch = 45 >>> me3.velocity = 0 >>> dt2 = midi.DeltaTime(mt) >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.pitch = 46 >>> me2.velocity = 94 >>> dt4 = midi.DeltaTime(mt) >>> dt4.time = 20160 >>> me4 = midi.MidiEvent(mt) >>> me4.type = midi.ChannelVoiceMessages.NOTE_OFF >>> me4.pitch = 46 >>> me4.velocity = 0 >>> tne1 = midi.translate.TimedNoteEvent(dt1.time, dt3.time, me1) >>> tne2 = midi.translate.TimedNoteEvent(dt2.time, dt4.time, me2) >>> c = midi.translate.midiEventsToChord([tne1, tne2]) >>> c >>> c.duration.quarterLength 2.0 If the channel of the last element is set to 10, then a PercussionChord is returned: >>> me2.channel = 10 >>> midi.translate.midiEventsToChord([tne1, tne2]) * Changed in v7: Uses the last DeltaTime in the list to get the end time. * Changed in v7.3: Returns a :class:`~music21.percussion.PercussionChord` if any event is on channel 10. * Changed in v8: inputM21 is no longer supported. Flat list format is removed. * Changed in v9.7: expects a list of TimedNoteEvents. rrMFrT)rr)rTrPitchrrZrVolumerrrPercussionChordrChordrrXrrrrr$rrraddtuplepitches setVolumes) timedNoteListr? first_tOn last_tOffrvolumesany_channel_10_tOn_tOffrpvrc midi_pitchunprs r6midiEventsToChordrDsbP#2&q)I"2&q)I!#G#%GN%2 e[   " $!N KKM""q MM;#7#7 8$q%2 00 kk )  A!Z//0!J.."C 5%;;JG$%C EE#J"'N LL H+ 5224 5sEE:9E:cd}g}|}g}g}|j} |j} |j|jdk7rr|rt|} |j | t |} t j| _|jj|d| _ |j | t|D]U\} }|rt|} |j | t |} tj| _d| _t|t j"rU|j$j&| _|j$j)sV|j$j+| _n6t|t j.rt1|| _n t3d| r|jj4}n | j4}t7t9|dz| _|j | |j | Xt|D]\} }|r| _ |j | t |} tjB| _|| _|j$| _|j,| _d| _|j | |j | t|D]\} }|| }||_"||_"|S) aj Translates a :class:`~music21.chord.Chord` object to a list of base.DeltaTime and base.MidiEvents objects. The `channel` can be specified, otherwise channel 1 is assumed. See noteToMidiEvents above for more details. >>> c = chord.Chord(['c3', 'g#4', 'b5']) >>> c.volume = volume.Volume(velocity=90) >>> c.volume.velocityIsRelative = False >>> eventList = midi.translate.chordToMidiEvents(c) >>> eventList [, , , , , , , , , , , ] * Changed in v7: made keyword-only. * Changed in v8: added support for :class:`~music21.percussion.PercussionChord`. NrRrkrUrMz8ChordBase can only contain Note and Unpitched as membersrr)#rhasComponentVolumesrrrZrr rr\r]r^ enumeraterrrTrXrrrrrrrrrrrr,r>rrHr rnrr)rrVrTrPrrrnoteOnnoteOff chordVolumerrdrerchordComponent volScalar noteOnEventmeOnmeOffs r6chordToMidiEventsrsJ B+-IA!F!G((K//1"x~~'; $B   R R ""..''(;&q\> $B   R R &.. ndii 0%++00BH!''446-33HHJ  71.ABHVW W '--<>> me = midi.MidiEvent(channel=2) >>> me.type = midi.ChannelVoiceMessages.PROGRAM_CHANGE >>> me.data = 53 # MIDI program 54: Voice Oohs >>> midi.translate.midiEventToInstrument(me) The percussion map will be used if the channel is 10: >>> me.channel = 10 >>> instrumentObj = midi.translate.midiEventToInstrument(me) >>> instrumentObj >>> instrumentObj.midiChannel # 0-indexed in music21 9 >>> instrumentObj.midiProgram # 0-indexed in music21 53 Get from instrument name with particular encodings >>> encoded_flute = 'flöte'.encode('latin-1') >>> me = midi.MidiEvent(channel=4) >>> me.type = midi.MetaEvents.SEQUENCE_TRACK_NAME >>> me.data = encoded_flute >>> fl = midi.translate.midiEventToInstrument(me, encoding='latin-1') >>> fl rRrrz!Could not get an instrument from z$Unable to determine instrument from z; getting generic Instrument stacklevelrM)rrz instrument zinst )rXr^bytesdecodesplitstripr fromStringrTr,rr_instrumentFromMidiProgramInstrumentExceptionUnicodeDecodeErrorwarningswarnr< Instrument midiChannellowerreplaceisdigitr\r r[rcINSTRUMENT_NAMEinstrumentName)r/rPdecodedrs r6rrzsLG$ ejj% (jj''177?BGmmoG%%g.A ]]b Z C%@..0A!JJAM  C (44UZZ@A!JJAM003TUZT[1\] ]MMA%AM MMO5 5}}&&}b9AAC}}&&w3;;=H ZZ:99 9 AJ HZZ:55 5&A  H9 $ 25'9U V   ! ! #  ) )$  ! ! #$sDG55=I5&IIctj|s|}n|d}t|j}|d}t d|d}t j |d|}|S)am Convert a single MIDI event into a music21 TimeSignature object. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.MetaEvents.TIME_SIGNATURE >>> me1.data = midi.putNumbersAsList([3, 1, 24, 8]) # 3/2 time >>> ts = midi.translate.midiEventsToTimeSignature(me1) >>> ts >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.MetaEvents.TIME_SIGNATURE >>> me2.data = midi.putNumbersAsList([3, 4]) # 3/16 time >>> ts = midi.translate.midiEventsToTimeSignature(me2) >>> ts rMrr/)rrlistr^powr TimeSignature)rr/postrrGtss r6midiEventsToTimeSignaturershR   Y '!   D QA AtAwA   s!A3Z (B Ir5cd}g}|rt|}|j||j}|dkDr!tjd|t dgSt tj|j}d}d}t|} tj| _ d | _t||||g| _|j| |S) a  Translate a :class:`~music21.meter.TimeSignature` to a pair of events: a DeltaTime and a MidiEvent TIME_SIGNATURE. Returns a two-element list unless there is an error. >>> ts = meter.TimeSignature('5/4') >>> eventList = midi.translate.timeSignatureToMidiEvents(ts) >>> eventList[0] >>> eventList[1] Note that time signatures with numerators above 255 cannot be stored in MIDI. (A feature?) They will not be stored and an empty list will be returned. A warning will be issued. >>> ts = meter.TimeSignature('267/32') # found on music21 list >>> import warnings #_DOCS_HIDE >>> with warnings.catch_warnings(): #_DOCS_HIDE ... warnings.simplefilter('ignore') #_DOCS_HIDE ... out = midi.translate.timeSignatureToMidiEvents(ts) #_DOCS_HIDE >>> #_DOCS_SHOW out = midi.translate.timeSignatureToMidiEvents(ts) >>> out [] NrkzFTimeSignature with numerator > 255 cannot be stored in MIDI. Ignoring rrrM)rrZ numeratorrrr<r,mathlog2 denominatorrr TIME_SIGNATUREr\rTr!r^) rrVrrrdrrG metroClicksubCountres r6timeSignatureToMidiEventsr  s8 B+-I R   A3w TUWTX Y    DIIbnn %&AJH  B''BGBJ1j(;>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.MetaEvents.KEY_SIGNATURE >>> me1.data = midi.putNumbersAsList([2, 0]) # d major >>> ks = midi.translate.midiEventsToKey(me1) >>> ks >>> ks.mode 'major' >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.MetaEvents.KEY_SIGNATURE >>> me2.data = midi.putNumbersAsList([-2, 1]) # g minor >>> me2.data b'\xfe\x01' >>> list(me2.data) [254, 1] >>> ks = midi.translate.midiEventsToKey(me2) >>> ks >>> ks.sharps -2 >>> ks.mode 'minor' rMr majorminor)rrrr^r KeySignatureasKey)rr/r sharpCountmodeksks r6midiEventsToKeyrDsF   Y '!   D Aw|!Ws] !W D Aw!|  * %B A Hr5c<d}g}|rt|}|j||j}t|tj r|j dk(rd}nd}t|tj}t||g|_ |j||S)a Convert a single :class:`~music21.key.Key` or :class:`~music21.key.KeySignature` object to a two-element list of midi events, where the first is an empty DeltaTime (unless includeDeltaTime is False) and the second is a KEY_SIGNATURE :class:`~music21.midi.MidiEvent` >>> ks = key.KeySignature(2) >>> ks >>> eventList = midi.translate.keySignatureToMidiEvents(ks) >>> eventList [, ] Note that MIDI Key Signatures are connected to tracks but not to channels. MIDI Key Signatures store sharps or flats as the first number, and mode (0 = major 1 = minor) as the second number. Flats are encoded as offsets at 0xff (=1 flat) or below (0xfe = 2 flats ... etc., through 0xfb = 5 flats, below). >>> k = key.Key('b-') >>> k >>> eventList = midi.translate.keySignatureToMidiEvents(k, includeDeltaTime=False) >>> eventList [] NrkrrMrrm) rrZsharpsrXrKeyrrr KEY_SIGNATUREr!r^)rrVrrrdrrres r6keySignatureToMidiEventsrsF B+-I R  J"cgg277g#5   % % B D12BG R r5ctj|s|}n|d}t|jdd}t d|z d}t j |}|S)zX Convert a single MIDI event into a music21 Tempo object. TODO: Need Tests rMrrnumber)rrr"r^r>r MetronomeMark)rr/mspqbpmmms r6midiEventsToTempor's]   Y '!  UZZ #A &D  T!1 %C   C (B Ir5c|j |jyd}g}|rt|}|j|t |}t j |_d|_|j}|j}ttd|z }t|d|_|j||S)aF Given any TempoIndication, convert it to list of :class:`~music21.midi.MidiEvent` objects that signifies a MIDI tempo indication. >>> mm = tempo.MetronomeMark(number=90) >>> events = midi.translate.tempoToMidiEvents(mm) >>> events [, ] >>> len(events) 2 >>> events[0] >>> evt1 = events[1] >>> evt1 >>> evt1.data b'\n,+' >>> microSecondsPerQuarterNote = midi.getNumber(evt1.data, len(evt1.data))[0] >>> microSecondsPerQuarterNote 666667 >>> round(60_000_000 / microSecondsPerQuarterNote, 1) 90.0 If includeDeltaTime is False then the DeltaTime object is omitted: >>> midi.translate.tempoToMidiEvents(mm, includeDeltaTime=False) [] Test round-trip. Note that for pure tempo numbers, by default we create a text name if there's an appropriate one: >>> midi.translate.midiEventsToTempo(events) `None` is returned if the MetronomeMark lacks a number, which can happen with metric modulation marks. >>> midi.translate.tempoToMidiEvents(tempo.MetronomeMark(number=None)) is None True Sounding numbers also translate even if number is None >>> mm = tempo.MetronomeMark(numberSounding=80) >>> midi.translate.tempoToMidiEvents(mm) [, ] NrkrMr r)r"numberSoundingrrZrr SET_TEMPOr\rTgetSoundingMetronomeMark getQuarterBPMr,r>r#r^) tempoIndicationrVrrrdrer&r%r$s r6tempoToMidiEventsr.sl%/*H*H*P B+-I R   B""BGBJ  1 1 3B   C uZ#%& 'Da BG R r5c|||||jd|d}|jtjk7r|t |j |d<|S)a Pack a dictionary of parameters for each event. Packets are used for sorting and configuring all note events. Includes offset, any cent shift, the midi event, and the source object. Offset and duration values stored here are MIDI ticks, not quarter lengths. >>> n = note.Note('C4') >>> midiEvents = midi.translate.elementToMidiEventList(n) >>> getPacket = midi.translate.getPacketFromMidiEvent >>> getPacket(trackId=1, offset=0, midiEvent=midiEvents[0], obj=n) {'trackId': 1, 'offset': 0, 'midiEvent': , 'obj': , 'centShift': None, 'duration': 10080, 'lastInstrument': None} >>> inst = instrument.Harpsichord() >>> getPacket(trackId=1, offset=0, midiEvent=midiEvents[1], obj=n, lastInstrument=inst) {'trackId': 1, 'offset': 0, 'midiEvent': , 'obj': , 'centShift': None, 'duration': 0, 'lastInstrument': } r)trackIdoffset midiEventobjrr lastInstrumentr )rr\rrrHr )r0r1r2r3r4rs r6getPacketFromMidiEventr5!s\H((( D~~-6663?/s||<Z Kr5c|xtjdx\yxtjdx\t|d|Sxtjdx\t|dd|Sxt j dx\t|d|Sxtjdx\t|dd|Sxtjdx\yxtjdx\t|dSxtj dx\t#|dSxt$j&dx\t)|dSt*j,dx\t/|dS y)a  Return a list of MidiEvents (or None) from a Music21Object, assuming that dynamics have already been applied, etc. Does not include DeltaTime objects. Channel (1-indexed) is set to the default, 1. Track is not set. >>> n = note.Note('C4') >>> midiEvents = midi.translate.elementToMidiEventList(n) >>> midiEvents [, ] r4NF)rVrPrr)rV)rRestrrrrrrrrr Dynamicrrr rrrrr#r.rrr`)elrPs r6elementToMidiEventListr:[sF( TYY[ TYY[$BR R  T^^ #BU]^ ^ U[[]$R%(S S*Z ' ' )$R%V^_ _* X    "U ",R%H H# S   +BG G "U "%R%@ @# " " $)"uE E%r5c jg}d}|D]}t||}t|tjr|}|0g}d} |D]} | jt j k(r| durd} | durt|j|d} nt|j||} | jt jk7r"t|| | ||} |j| t|| t|jz| ||} |j| ||z }|jd|S) al Convert a flattened, sorted Stream to MIDI Packets. This assumes that the Stream has already been flattened, ties have been stripped, and instruments, if necessary, have been added. In converting from a Stream to MIDI, this is called first, resulting in a collection of packets by offset. Then, getPacketFromMidiEvent is called. NrOFT)rB)r3r4c*|d|djfSNr1r2 sortOrder)xs r6z!streamToPackets..sq{AkN$<$<=r5r)r:rXrrr\rrrD elementOffsetrr5rZrHr sort) r~r0rBrPpacketsByOffsetr4r9 midiEventListelementPacketsfirstNotePlayedr2rArs r6streamToPacketsrHsT&O15N.rHE b*// 0N   &I"6">">>'50"&%'%aoob&9O%aoob&9W~~!5!>!>>*#1 %%a(++BKK88#1 3 %%a(A'B >)_f = r5c^|i}|g}|i}i}g}g}|D]}|d|vr|j|d|djtjk7r|djtjk7r |d|d_|j||djtjk(rq|drlt |djtj|dj }|jdt|d|d| } |j| |d|d_|d} |d|d z} g} |d} |D]u}|\}}}| |cxkr| ks+n| |cxkr| ksn|| cxkr|ksn|| cxkr|ks)x_events r6rAz)assignPacketsToChannels..sWX. 0D0N0NOr5r)rZr\rrrrTrrl PITCH_BEND setPitchBendr5r8rr`rrC)packetschannelByInstrumentchannelsDynamicinitTrackIdToChannelMapuniqueChannelEventsr usedTracksrrepBendEndrAoEndchannelExcluder key_tuplestartstop usedChannel centShiftListchr@meListpgmChangePacket pBendStart foundChannels_start_stopr0s r6assignPacketsToChannelsrdsM2" &"$ DJ  Y  "6">"> >~""&:&C&CC)*=)9+& KKN~""&:&C&CC[>"1[>#7#7(<(G(G+,[>+A+ACB OOA&5 !)  {"$ H KK) "#=!1+ hK{Qz]*kN -I'0 $E4 e"d"D4)T)+t+!4I >  ".8&--k:".8&--k:+-4 B$N*B%z(VXX%'AkN "8:AkN - - 5!"./;K9LAF:;K.:N:N8:<#9iL$Qi#  O,;''B8:AkN - - 5 1[>// 4 ? ?#%'B OOI &/) J KK # x[!H+* "=rB / /.0  *   * 1 1) < AYfM&*+>&?"{ m +   -'@ a<  $W - W0;;!# )  H$ II O Kr5cT||Sg}|D]}|d|k(s |j||S)a Given a list of Packet dictionaries, return a list of only those whose trackId matches the filter. >>> packets = [ ... {'trackId': 1, 'name': 'hello'}, ... {'trackId': 2, 'name': 'bye'}, ... {'trackId': 1, 'name': 'hi'}, ... ] >>> midi.translate.filterPacketsByTrackId(packets, 1) [{'trackId': 1, 'name': 'hello'}, {'trackId': 1, 'name': 'hi'}] >>> midi.translate.filterPacketsByTrackId(packets, 2) [{'trackId': 2, 'name': 'bye'}] If no trackIdFilter is passed, the original list is returned: >>> midi.translate.filterPacketsByTrackId(packets) is packets True r0)rZ) packetsSrc trackIdFilter outPacketspackets r6filterPacketsByTrackIdrjsB0J )  -   f % r5cg}d}|D]^}|d}|d|z }|dkr tdt|||j}|j||j||d}`|S)a Given a list of packets (which already contain MidiEvent objects) return a list of those Events with proper delta times between them. At this stage MIDI event objects have been created. The key process here is finding the adjacent time between events and adding DeltaTime events before each MIDI event. Delta time channel values are derived from the previous midi event. rr2r1zgot a negative delta time)rnrT)r8rrTrZ)rOrWrb lastOffsetrir2 deltaTimeIntrds r6packetsToDeltaSeparatedEventsrns)+FJ;' h'*4 ! $%@A A y|Y=N=N O b i H%  Mr5ct|}|xjt|||z c_t||}|xjt ||z c_|xjt ||z c_|j |S)a Given packets already allocated with channel and/or instrument assignments, place these in a MidiTrack. Note that all packets can be sent; only those with matching trackIds will be collected into the resulting track The `channel` defines the channel that startEvents and endEvents will be assigned to Use streamToPackets to convert the Stream to the packets * New in v10.3: addEndDelay keyword. )rTrarh)rrbrgrjrnrp updateEvents)rOr0rTrarir trackPacketss r6packetsToMidiTrackrrsu 7 BII(/.;==I *'7;LII.|R@@IIIbk::IOO Ir5cg}d}d}|t|jkr|j|} |j|dz}|j}|j}|r,|s*||jz }||f}|j ||dz }n|s|s|dz }n|r|r|dz }n|dz }|t|jkr|S#t$rY|SwxYw)zY Get a list of tuples of (tickTime, MidiEvent) from the events with time deltas. rrMr)lenrb IndexError isDeltaTimernrZ) rrb currentTimer currentEvent nextEvent currentDtnextDt tupleAppends r6getTimeForEventsr}'sFK A c"))n yy|   !a%(I!,,. &&( V <,, ,K& 2K MM+ & FA FA 6 FA FAA c"))n D M=  : M= sC CCcFg}i}|dddD]|\}}|jr|||j|jf<2|jsC ||j|jf}t |||}|j |~|dddS#t $rYwxYw)a Takes in a list of tuples of (tickTime, MidiEvent) and returns a list of TimedNoteEvent objects which contain the note on time, the note off time, and the MidiEvent of the note on. (The note off MidiEvent is not included) If timedEvents is sorted in non-decreasing order of tickTime, then the output here will also be sorted in non-decreasing order of note on time. Example: here are two pitches, represented as note on and note off events: >>> CVM = midi.ChannelVoiceMessages >>> ev1on = midi.MidiEvent(type=CVM.NOTE_ON) >>> ev1on.pitch = 60 >>> ev2on = midi.MidiEvent(type=CVM.NOTE_ON) >>> ev2on.pitch = 62 >>> ev1off = midi.MidiEvent(type=CVM.NOTE_OFF) >>> ev1off.pitch = 60 >>> ev2off = midi.MidiEvent(type=CVM.NOTE_OFF) >>> ev2off.pitch = 62 >>> events = [(0, ev1on), (1, ev2on), (2, ev2off), (3, ev1off)] >>> notes = midi.translate.getNotesFromEvents(events) >>> len(notes) 2 >>> notes [TimedNoteEvent(onTime=0, offTime=3, event=), TimedNoteEvent(onTime=1, offTime=2, event=)] >>> (notes[0].event.pitch, notes[1].event.pitch) (60, 62) Nr) isNoteOffrrTisNoteOnr+rZKeyError) timedEventsnotesawaitingNoteOnrnr/r.tnes r6getNotesFromEventsr\sD#%E79N#4R4( e ?? 9=N5;; 5 6 ^^  )emm)CD$T7E: S!)* 2;  s9B B B c0i}|D]]\}}|jtjk(s$t|jt s? |jj |||<_|S#t$r%tjd|d|tdYwxYw)a From a list of timed events, that is a tuple of a tick time and a MidiEvent Return a dictionary mapping a tick time to a string representing a lyric. If more than one lyric is found at a given tick time, the last one found is stored. zUnable to decode lyrics from z as rr) r\r rrXr^rrrrrr<)rbrPlyricsrnes r6lyricTimingsFromEventsrs Fa 66Z%% %*QVVU*C  vv}}X6t  M &  3A3d8*E$  sA''+BBczg}d}|D]0\}}d}|jtjk(r t|}n|jtjk(r t |}n|jtj k(r t|}n|jtjtjfvrt||}|dk7rV||_ nN|jtjk(r1t|jt rt|}|j}|s||f}|j#|3|S)z Translate MidiEvents whose type is a MetaEvent into Music21Objects. Note: this does not translate MetaEvent.LYRIC, since that becomes a bare string. New in 9.7: add encoding rNrO)r\r r rrrr*r'rr[rr_rrrX parameter1r,rZ)rbrP metaEvents last_program timeEventrmetaObjpairs r6 getMetaEventsrs 8:JL 1+/ 66Z.. ./2G VVz// /%a(G VVz++ +'*G VV 22J4R4RS S,AAGr!&2# VV+:: :z!,,X[?\+A.G<@MM!$  1 1 1'04IOO -'+I $ m11!4i@@r5r4)r? quantizePostrrrquarterLengthDivisorsrPc |tj} n|} t|} t| } t | |} t | |} | D]#\}}| j t||z |%| jt| dg}dgt| z}d}|stj}|r t|}nd}||z }t| D]\}}||r |j}|j }|g}t#|dzt| D]`}| |j}| |j }t%||z |k\rn/t%||z |kDrd}H|j'| |d||<bt|dkDr t)||}n t+||}t||z }||j,_| j1|x}r||_| j ||| j5d|r| j7|dddd | s| S|t9|| | d}|`|d } | rY| j}t:j<r|J|j?d s$|jAd tCjD| jG|d |r7| jItjJD]}!|!jMdd| jOd| jQddd| S)aS Note that quantization takes place in stream.py since it's useful not just for MIDI. >>> fp = common.getSourceFilePath() / 'midi' / 'testPrimitive' / 'test05.mid' >>> mf = midi.MidiFile() >>> mf.open(fp) >>> mf.read() >>> mf.close() >>> mf >>> len(mf.tracks) 1 >>> mt = mf.tracks[0] >>> mt >>> mt.events [, , , , ...] >>> p = midi.translate.midiTrackToStream(mt, ticksPerQuarter=mf.ticksPerQuarterNote) >>> p >>> len(p.recurse().notesAndRests) 14 >>> p.recurse().notes.first().pitch.midi 36 >>> p.recurse().notes.first().volume.velocity 90 Note that as of music21 v7, the Part object already has measures made: >>> p.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {2.0} {3.0} {4.0} {0.0} {0.5} {1.5} {3.5} {8.0} {0.0} {0.5} {1.0} {2.5} {12.0} {0.0} {2.5} {4.0} * Changed in v7: Now makes measures. * Changed in v8: all but the first attribute are keyword only. NrOTrFrM)force)rprocessOffsetsprocessDurationsrrecurserrr) meterStreamr)rfillGaps)rrtimeRangeFromBarDuration))rPartr}rrr coreInsertrcoreElementsChangedrrtr!quantizationQuarterLengthDivisorsmaxrr-r.rangeabsrZrr editorial midiTickStartgetrrCquantizerrw TYPE_CHECKINGgetElementsByOffsetr{rr makeMeasuresrMeasure makeVoicesmakeTies makeRests)"rr?rrrrrrPkeywordsr~rrr lyricsDicttickr3chordSub iGatheredvoicesRequireddivisorchunkTolerancerr tickStartrjtSubtOffSub note_or_chordrArrts_iterms" r6midiTrackToStreamrs X KKM #2&K#5["AE{X>J' hGJ c VD?23S9 4 &(H#Gc%j0IN ( J J+,$w.N&u-> Q< ")) %%"#q1uc%j)A8??DAh&&G4)#$67T>"^3"& OOE!H %IaL!** x=1 -hHM-^_MM 9. /09 -NN9- -5 -"'M  Q &i.lFFF )>"&$(  "  mQ@&*K 0 !..*K"...2215""1e&9&9&;<NN{DN9%%fnn5A LLL 66JJtJKKtdKK Hr5c|tjr|j}n|jd}t |}|j rO|j tjD]}tj||jd||}|Stj|tj}|jd||jd||S)a  Given a score, prepare it for MIDI processing, and return a new Stream: 1. Expand repeats. 2. Make changes that will let us later create a conductor (tempo) track by placing `MetronomeMark`, `TimeSignature`, and `KeySignature` objects into a new Part, and remove them from other parts. 3. Ensure that the resulting Stream always has part-like substreams. Note: will make a deepcopy() of the stream. >>> s = stream.Score() >>> p = stream.Part() >>> m = stream.Measure(number=1) >>> m.append(tempo.MetronomeMark(100)) >>> m.append(note.Note('C4', type='whole')) # MIDI 60 >>> p.append(m) >>> s.append(p) >>> sOut = midi.translate.prepareStreamForMidi(s) >>> sOut.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} prepareStreamForMidir) rr expandRepeatscoreCopyAsDerivationconductorStreamhasPartLikeStreamsrrsr realizeVolumer{Score)r~ conductorrouts r6rrs>  OO  " "#9 :"I %%fmm4A   #5 I J Qlln 1i  1a Jr5ct|jtjj d}|rt d|Dnd}|dz }tj }||_|jdtdD]a}d}||D],}|j|}||kDr|j|||}.|jddD]} | j|c|jtjs%|jtjd |jtj s$|jtj d |S) a Strip the given stream of any events that belong in a conductor track rather than in a music track, and returns a :class:`~music21.stream.Part` containing just those events, without duplicates, suitable for being a Part to turn into a conductor track. Sets a default MetronomeMark of 120 if no MetronomeMarks are present and a TimeSignature of 4/4 if not present. Ensures that the conductor track always sorts before other parts. Here we purposely use nested generic streams instead of Scores, Parts, etc. to show that this still works. But you should use Score, Part, Measure instead. >>> s = stream.Stream(id='scoreLike') >>> p = stream.Stream(id='partLike') >>> p.priority = -2 >>> m = stream.Stream(id='measureLike') >>> m.append(tempo.MetronomeMark(100)) >>> m.append(note.Note('C4')) >>> p.append(m) >>> s.insert(0, p) >>> conductor = midi.translate.conductorStream(s) >>> conductor.priority -3 The MetronomeMark is moved and a default TimeSignature is added: >>> conductor.show('text') {0.0} {0.0} {0.0} The original stream still has the note: >>> s.show('text') {0.0} {0.0} {0.0} rc34K|]}|jywN)priority).0rs r6 z"conductorStream..: s4)Qajj)srM)r#rrrT) streamsOnly includeSelfxr!z4/4)rrrrsrminrrr{rgetOffsetInHierarchyr removeByClassrr#rr) r~ partsList minPriorityconductorPriorityrklassrlr9 offset_in_ss_or_inner_streams r6rr sBTQ))&--8LLQOPI8A#4)44qK#aKKMM.MIK(C E(B11!4KZ'$$["5$J  "#t!N   + +E 2"OD  + +E,?,? @U00<=  + +E,?,? @U0078 r5c ||dd}n+ttddttddz}g}i}g}t}g}|jrS|j t j D]0}|tjs |tr |j|2n|j||D]} | tj} d} | D]} | jO| j|vrA| jdz} |j| |j)| | || j<| j|vr|j| jd } | rd|vs|jd|Dcgc] }||vs| }}t+|D]O\}}|t-|dz kr||||<|j)||4|d ||<|j)|d Q|D]}||vs|j|||fS#t $r0| dk7r't#j$| d| d|d t&d d} Y2wxYwcc}w)a Read through Stream `s` and finding instruments in it, return a 2-tuple, the first a dictionary mapping MIDI program numbers to channel numbers, and the second, a list of unassigned channels that can be used for dynamic allocation. One channel is always left unassigned for dynamic allocation. If the number of needed channels exceeds the number of available ones, any further MIDI program numbers are assigned to channel 1. Substreams without notes or rests (e.g. representing a conductor track) will not consume a channel. Only necessarily works if :func:`~music21.midi.translate.prepareStreamForMidi` has been run before calling this routine. An instrument's `.midiChannel` attribute is observed. `None` is the default `.midiChannel` for all instruments except :class:`~music21.instrument.UnpitchedPercussion` subclasses. Put another way, the priority is: - Instrument instance `.midiChannel` (set by user or imported from MIDI) - `UnpitchedPercussion` subclasses receive MIDI Channel 10 (9 in music21) - The channel mappings produced by reading from `acceptableChannelList`, or the default range 1-16. (More precisely, 1-15, since one dynamic channel is always reserved.) .. warning:: The attribute `.midiChannel` on :class:`~music21.instrument.Instrument` is 0-indexed, but `.channel` on :class:`~music21.midi.MidiEvent` is 1-indexed, as are all references to channels in this function. NrMr Fz" specified 1-indexed MIDI channel z but acceptable channels were z. Defaulting to channel 1.rrTr)rrsetrrrrsr GeneralNoterrZrrrr_remove ValueErrorrrr<rrrt)r~acceptableChannelListacceptableChannelsallUniqueInstrumentsrPrQchannelsAssigned substreamListr3subsinstrumentStreamsetAnInstrumentr thisChannelr@programsStillNeededriPgmr]s r6channelInstrumentDatarU sH(215!%2,/$uR}2EEOuM'' 6C(()s9~$$S) 7 Q 5 56$D+0@0@H[0[#..2 (&--k:!$$[18C#D$4$45';;$++D,<,<="O3%6//$++D1CF';[&:aGZ>Z1&:[014 s%&* *);1(=  %  !3A!6 7(:1(=  %  !3A!6 72! % %  " "2 &!  //U" (#b(! #f$F{mT<>> s = stream.Score() >>> p = stream.Part() >>> m = stream.Measure(number=1) >>> m.append(tempo.MetronomeMark(100)) >>> m.append(instrument.Oboe()) >>> m.append(note.Note('C4', type='whole')) # MIDI 60 >>> p.append(m) >>> s.append(p) >>> sOut = midi.translate.prepareStreamForMidi(s) >>> partList = list(sOut.parts) >>> packetStorage = midi.translate.packetStorageFromSubstreamList(partList) >>> list(sorted(packetStorage.keys())) [0, 1] >>> list(sorted(packetStorage[0].keys())) ['initInstrument', 'rawPackets'] >>> from pprint import pprint >>> pprint(packetStorage) {0: {'initInstrument': , 'rawPackets': [{'centShift': None, 'duration': 0, 'lastInstrument': , 'midiEvent': , 'obj': , 'offset': 0, 'trackId': 0}, {'centShift': None, 'duration': 0, 'lastInstrument': , 'midiEvent': , 'obj': , 'offset': 0, 'trackId': 0}]}, 1: {'initInstrument': , 'rawPackets': [{'centShift': None, 'duration': 0, 'lastInstrument': , 'midiEvent': , 'obj': , 'offset': 0, 'trackId': 1}, {'centShift': None, 'duration': 40320, 'lastInstrument': , 'midiEvent': , 'obj': , 'offset': 0, 'trackId': 1}, {'centShift': None, 'duration': 0, 'lastInstrument': , 'midiEvent': , 'obj': , 'offset': 40320, 'trackId': 1}]}} r)r0rBrP) rawPacketsinitInstrument)rflattenrrrfirstr1r_rrrrr notesAndRestsrrH)rrBrP packetStorager0rinstObjrqs r6packetStorageFromSubstreamListr sRM"=1 ||~/3.E.E  ! !/ %'  ?w~~2g6I6I6Q&& 8R8R'ST./Ad&8&8#+&tWM08: '%" g)20 r5c|jD]\}}|d}| |d}nut|tjrd}nXt|tj rd}n;t jrt|tjsJ||j}||d<|dD]}||d< y#t$rd}Y$wxYw)z Take the packetStorage dictionary and using information from 'initInstrument' and channelByInstrument, add an 'initChannel' key to each packetStorage bundle and to each rawPacket in the bundle['rawPackets'] rNrMrrJr) itemsrrXrrrrwrrr_)rrPunused_trackIdbundlerinitCh rawPackets r6"updatePacketStorageWithChannelInfor 6 s#0"5"5"7)* ? ,T2!?!? @F !5!5 6F!':+@+@AAA()<)<=F &} -I'-Im $.%#8   sB11 B?>B?)rrBrirPclt|}t||\}}g}g} |jtjD]7} | jdr| j d| '| j | 9| D]} | jddt| ||} t| |i} | jD] \}}|d| |<g}| jD] }||dz } t|||| }| D]3}| |d}| |d }t||||| }|j |5|S) a Given a Stream, Score, Part, etc., that may have substreams (i.e., a hierarchy), return a list of :class:`~music21.midi.MidiTrack` objects. acceptableChannelList is a list of MIDI Channel numbers that can be used or None. If None, then 1-9, 11-16 are used (10 being reserved for percussion). In addition, if an :class:`~music21.instrument.Instrument` object in the stream has a `.midiChannel` that is not None, that channel is observed, and also treated as reserved. Only subclasses of :class:`~music21.instrument.UnpitchedPercussion` have a default `.midiChannel`, but users may manipulate this. See :func:`channelInstrumentData` for more, and for documentation on `acceptableChannelList`. Called by streamToMidiFile() The process: 1. makes a deepcopy of the Stream (Developer TODO: could this be done with a shallow copy? Not if ties are stripped and volume realized.) 2. we make a list of all instruments that are being used in the piece. * Changed in v6: acceptableChannelList is keyword only. addStartDelay is new. * Changed in v6.5: Track 0 (tempo/conductor track) always exported. * New in v10.3: addEndDelay keyword. )r#rrT)r matchByPitchrrJr)rPrQrRr)r0rTrari)rrrrrsr{rZ stripTiesrr rvaluesrdrr)rrrBrirPr~rPrQ midiTracksrr3rrrRr0r  netPacketsrJrars r6streamHierarchyToMidiTracksrV s{F X&A+@DY+Z(J M##FMM2  ! !"D E  C (   % 3 t$73=P]>> s = stream.Stream() >>> n = note.Note('g#') >>> n.quarterLength = 0.5 >>> s.repeatAppend(n, 4) >>> mf = midi.translate.streamToMidiFile(s) >>> mf.tracks[0].index # Track 0: conductor track 0 >>> len(mf.tracks[1].events) # Track 1: music track 22 From here, you can call mf.writestr() to get the actual file info. >>> sc = scale.PhrygianScale('g') >>> s = stream.Stream() >>> x=[s.append(note.Note(sc.pitchFromDegree(i % 11), quarterLength=0.25)) for i in range(60)] >>> mf = midi.translate.streamToMidiFile(s) >>> #_DOCS_SHOW mf.open('/Volumes/disc/_scratch/midi.mid', 'wb') >>> #_DOCS_SHOW mf.write() >>> #_DOCS_SHOW mf.close() See :func:`channelInstrumentData` for documentation on `acceptableChannelList`. Set `addEndDelay` to False to skip the trailing rest added by `getEndEvents`. * New in v10.3: addEndDelay keyword. r)rrtracksrr?ticksPerQuarterNote)rrBrirrPr~rmfs r6rvrv sEL A,Q;H9DCX6> /J BBI%55B Ir5rrPc t}|j||j|jt |f||d|S)a^ Used by music21.converter: Take in a file path (name of a file on disk) and using `midiFileToStream`, return a :class:`~music21.stream.Score` object (or if inputM21 is passed in, use that object instead). Keywords to control quantization: `quantizePost` controls whether to quantize the output. (Default: True) `quarterLengthDivisors` allows for overriding the default quantization units in defaults.quantizationQuarterLengthDivisors. (Default: (4, 3)). >>> sfp = common.getSourceFilePath() #_DOCS_HIDE >>> fp = str(sfp / 'midi' / 'testPrimitive' / 'test05.mid') #_DOCS_HIDE >>> #_DOCS_SHOW fp = '/Users/test/music21/midi/testPrimitive/test05.mid' >>> streamScore = midi.translate.midiFilePathToStream(fp) >>> streamScore * Changed in v8: inputM21 is keyword only. r)ropenreadclosemidiFileToStream)filePathrrPrrs r6midiFilePathToStreamr% s@: BGGHGGIHHJ B QH Q QQr5ct}t|}|dk(rd|_n||_||_|t |D]}t |}||D]T}t |}t|} t|jd} |dz| _ t| d| _ |dz|_ t| dd|_ t| d|_d} | ddk7rtt| ddd k(rt j"|_d } nct| ddd k(rd } t j&|_n7t(j+d | dnt(j+d | d| s|j,j/| |j,j/|W|j0j/|d} | |j3z} | S)a Convert Ascii midi data to a bytes object (formerly binary midi string). tracksEventsList contains a list of tracks which contain also a list of events. asciiMidiEventList = ['0 90 27 66', '0 90 3e 60', '3840 80 27 00', '0 80 3e 00'] The format of one event is : 'aa bb cc dd':: aa = delta time to last event (integer) bb = Midi event type cc = Note number (hex) dd = Velocity (integer) Example: >>> asciiMidiEventList = [] >>> asciiMidiEventList.append('0 90 31 15') >>> midiTrack = [] >>> midiTrack.append(asciiMidiEventList) >>> midiBinaryBytes = midi.translate.midiAsciiStringToBinaryString(tracksEventsList=midiTrack) >>> midiBinaryBytes b'MThd\x00\x00\x00\x06\x00\x01\x00\x01\x03\xc0MTrk\x00\x00\x00\x04\x00\x901\x0f' Note that the name is from pre-Python 3. There is now in fact nothing called a "binary string" it is in fact a bytes object. rM rrrrFFF8T9zUnsupported midi event: 0xzUnsupported meta event: 0xr5)rrtformatrrrrrstrrrTr,rnrrrrrr\r environLocalrrbrZrwritestr) midiFormatrtracksEventsListr numTracksrtrkrrerdchunk_event_paramvalid midiBinStrs r6midiAsciiStringToBinaryStringr6? s@ B$%IA~  0B#y!AA,C%a(s^s^$'FLL$5!U /23U 03R8!"3A"67 $Q'4/-a01!4;"6"?"? $/23A6#= $"6">">$)),FGXYZG[F\*]^ %%(BCTUVCWBX&YZJJ%%b)JJ%%b)9)< II  S !A"DJbkkm+J r5c Pt}|j|t|fi|S)aT Convert a string of binary midi data to a Music21 stream.Score object. Keywords to control quantization: `quantizePost` controls whether to quantize the output. (Default: True) `quarterLengthDivisors` allows for overriding the default quantization units in defaults.quantizationQuarterLengthDivisors. (Default: (4, 3)). N.B. -- this has been somewhat problematic, so use at your own risk. >>> midiBinStr = (b'MThd\x00\x00\x00\x06\x00\x01\x00\x01\x04\x00' ... + b'MTrk\x00\x00\x00\x16\x00\xff\x03\x00\x00\xe0\x00@\x00' ... + b'\x90CZ\x88\x00\x80C\x00\x88\x00\xff/\x00') >>> s = midi.translate.midiStringToStream(midiBinStr) >>> s.show('text') {0.0} {0.0} {0.0} {0.0} {0.0} {0.0} {1.0} {4.0} )rreadstrr#)strDatarrs r6midiStringToStreamr: s'2 BJJw B +( ++r5)rrrPc |tj}n|}|jstjdt |jf|j |||d||S)a Note: this is NOT the normal way to read a MIDI file. The best way is generally: score = converter.parse('path/to/file.mid') Convert a :class:`~music21.midi.MidiFile` object to a :class:`~music21.stream.Stream` object. The `inputM21` object can specify an existing Stream (or Stream subclass) to fill. Keywords to control quantization: `quantizePost` controls whether to quantize the output. (Default: True) `quarterLengthDivisors` allows for overriding the default quantization units in defaults.quantizationQuarterLengthDivisors. (Default: (4, 3)). >>> import os >>> fp = common.getSourceFilePath() / 'midi' / 'testPrimitive' / 'test05.mid' >>> mf = midi.MidiFile() >>> mf.open(fp) >>> mf.read() >>> mf.close() >>> len(mf.tracks) 1 >>> s = midi.translate.midiFileToStream(mf) >>> s >>> len(s.flatten().notesAndRests) 14 * Changed in v8: inputM21 and quantizePost are keyword only. z(no tracks are defined in this MIDI file.)r?rrrP)rrrr StreamExceptionrr)rrrrPrr~s r6r#r# slR LLN  99**+UVV $(*(>(>%1!"!) $ # $ Hr5__main__)F)rAr'rBboolreturnr,)rGduration.Durationr?r,)rCr,r?r,rKzduration.Duration | Noner?r@)NrMN) rWMidiTrack | NonerTr,rainstrument.Instrument | NonerPr,r?list[DeltaTime | MidiEvent]r)rWrArir>r?list[MidiEvent | DeltaTime])r|base.Music21ObjectrPr,r?r) rr,rr,r?r,rztype[NotRestType]r?r()rr+r?r,r?note.Note | note.Unpitched) rrFrVr>rTr,rPr,r?rC)rzSequence[TimedNoteEvent]r?r,r?chord.ChordBase) rrGrVr>rTr,rPr,r?rC)rznote.Unpitchedr?r,)TNrM)rinstrument.InstrumentrVr>rWrArTr,)rz!MidiEvent | tuple[int, MidiEvent]rPr,r?rH)r/rrPr,r?rH)T)r?rC)r?zkey.Key)rzkey.KeySignaturer?rC)r-ztempo.MetronomeMarkr?z"list[DeltaTime | MidiEvent] | None)NN) r0r,r1r,r2rr3zbase.Music21Object | Noner4rBr?zdict[str, t.Any])rN)r9rErPr,r?z"list[MidiEvent | DeltaTime] | None)rMFrN) r~ stream.Streamr0r,rBr>rPr,r?list[dict[str, t.Any]])NNN)rfrJrgz int | Noner?rJ)rOrJrWrr?rD)rMrMN)rrr?list[tuple[int, MidiEvent]])rrKr?zlist[TimedNoteEvent])rbrKrPr,r?zdict[int, str])rbrKrPr,r?z$list[tuple[int, base.Music21Object]])r stream.PartrrLrr>) r?r,rzstream.Part | Nonerr>rz Sequence[int]rPr,r?rL)r?rI)r~rIr?rL)r~rIrlist[int] | Noner?z'tuple[dict[int | None, int], list[int]])rzlist[stream.Part]rPr,r?dict[int, dict[str, t.Any]])rrNrPzdict[int | None, int | None]r?None) rzlist[MidiTrack]r?r,rzstream.Score | NonerPr,r?z stream.Score) rrIrBr>rir>rrMrPr,r?r)rPr,)rMiN)r?r)rrrPr,)q__doc__ __future__rcollections.abcrryrtypingrwrmusic21rrmusic21.common.numberToolsrrr r r r rmusic21.instrumentrrrrrrrrrrrmusic21.midi.baserrrrrr r!r"r#music21.midi.percussionr$r%rr&music21.common.typesr' Environmentr-rTypeVarrr( NamedTupler+Music21Exceptionr8 UserWarningr<rDrHr?rLrgrprrrrrrrr` deprecatedrrrr rrr'r.r5r:rHrdrjrnrrr}rrrrrrrrrr rrrvr%r6r:r# _DOC_ORDERr0mainTestr4r5r6rbs#$ - JJN??/'{&&'78 $&aii T\\: Q\\  66  { :B<$33597 7 7 37  7 ~!%04:  :: :.:  :  :|!%%%%% %\ 3%3  3  3F   #   @$33f0"f0f0f0X" i&ii i  i  i`$33w +w w w z" zzz z  z  zz $" $ # D5%!cd ;. ; ; ;e ;U U U  U p4n8v8 z<<<~*I(I$Ih$(15 7 7 77 ! 7 / 7  7x222$2n NN NN N  Nf bN#&D #>Y]@22 2jC,CCR ' :- '--* -f AA A A2$33 &*+-Q Q $ Q Q )Q Q Q h7tCP-1x0x0)x0+x0| c$c c ! cL...1. .F  \B$33"& -  - - -  -  - - f ,0 333 3 * 3  33r !R !RJQ Qh,D ; ;  ; ~ 0 1  zGr5