rhXSSKJrJr SSKrSSKrSSKrSrSrSS0rSr Sr Sr Sr /S Qr "S S \5r"S S \5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"S S!\5r"S"S#\5r"S$S%\5r"S&S'\5r"S(S)\5r"S*S+\5r"S,S-\5r S.r!S/r"S0r#S1r$S2r%g)3)divisionprint_functionNHEADipan )MIDIFileMAJORMINORSHARPSFLATSc2\rSrSrSrSrSrSrSrSr Sr g) GenericEvent%z8 The event class from which specific events are derived NrcXlX lgN)tickinsertion_order)selfrrs K/home/james-whalen/.local/lib/python3.13/site-packages/midiutil/MidiFile.py__init__GenericEvent.__init__,s  .ctURUR:H=(a URUR:H$)a^ Equality operator. In the processing of the event list, we have need to remove duplicates. To do this we rely on the fact that the classes are hashable, and must therefore have an equality operator (__hash__() and __eq__() must both be defined). Some derived classes will need to override and consider their specific attributes in the comparison. )evtnamerrothers r__eq__GenericEvent.__eq__0s)  -I$))uzz2IJrc[UR5nUS-US--nUS- US- - nUS-US--nUS-US-- nUS -US --nUS - US - - nU$) a Return a hash code for the object. This is needed in order to allow GenericObject classes to be used as the key in a dict or set. duplicate objects are removed from the event list by storing all the objects in a set, and then reconstructing the list from the set. The only real requirement for the algorithm is that the hash of equal objects must be equal. There is probably great opportunity for improvements in the hashing function. i]~ ls  N ^R ( ^R ( ^Q ' ^Q ' ^Q ' ^R (r)rr) __name__ __module__ __qualname____firstlineno____doc__rsec_sort_orderrrr*__static_attributes__rrrr%s#GN/ Krrch^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr Sr S rU=r$) NoteOnUz" A class that encapsulates a note r&ch>X lX@lXPlXlX`l[ [ U]X75 gr)pitchdurationvolumechannel annotationsuperr5r) rr<r9rr:r;r=r __class__s rrNoteOn.__init__]s+    $ fd$T;rcURUR:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$rrrr9r<rs rr NoteOn.__eq__fY  -L$))uzz2IL ekk)L.2llemm.K MrczSURURURURUR4-$)Nz-NoteOn %d at tick %d duration %d ch %d vel %d)r9rr:r<r;rs r__str__NoteOn.__str__ns7> JJ 4==$,, BMM MrcvSnURUR-n[URU- 5nUHnU[R "SU5- nM U[R "SU5- nU[R "SUR 5- nU[R "SUR5- nU$oReturn a bytestring representation of the event, in the format required for writing into a standard midi file. r>B midi_statusr<writeVarLengthrstructpackr9r;rprevious_event_tick midibytescodevarTimetimeBytes r serializeNoteOn.serializer $,,. -@!@AH T84 4I V[[t,, V[[tzz22 V[[t{{33 r)r=r<r:r9r;Nrr,r-r.r/r0rrNr1rrrr*rGrXr2 __classcell__r?s@rr5r5UsFGKN34<M $$HM  rr5ch^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr Sr S rU=r$) NoteOffz, A class that encapsulates a Note Off event c\>X lX@lXlXPl[[ U]X65 gr)r9r;r<r=r>r`r)rr<r9rr;r=rr?s rrNoteOff.__init__s&   $ gt%d> >rcvSnURUR-n[URU- 5nUHnU[R "SU5- nM U[R "SU5- nU[R "SUR 5- nU[R "SUR5- nU$rJrMrRs rrXNoteOff.serializerZr)r=r<r9r;r[r\r^s@rr`r`sEGKN34=M$$H>  rr`c\^\rSrSrSrSrSrSU4SjjrSr\ Rr Sr Sr U=r $) Tempoz. A class that encapsulates a tempo meta-event r&cR>[SU- 5Ul[[U]X5 g)Ni)r(tempor>rmr)rrrprr?s rrTempo.__init__s#E)*  eT#D:rcURUR:H=(a9 URUR:H=(a URUR:H$r)rrrprs rr Tempo.__eq__sA  -* UZZ'* ekk) +rcxSnSnSn[R"SUR5nUSSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- nU[R"SU5- nU[R"SS5- nX&- nU$) rKrQ>LrrLr&)rPrQrprOr) rrSrTrUsubcodefourbite threebiterVrWs rrXTempo.serializes. ;;tTZZ0QqM  -@!@AH T84 4I V[[t,, V[[w// V[[t,,  r)rprr,r-r.r/r0rr1rrrr*rXr2r]r^s@rrmrms5GN;+ $$H##rrmc>^\rSrSrSrSrSrSU4SjjrSrSr U=r $) Copyrightz- A class that encapsulates a copyright event rcX>URS5Ul[[U]X5 gNz ISO-8859-1)encodenoticer>rr)rrrrr?s rrCopyright.__init__s"mmL1  i'>rcSnSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- nU[R"SU5- n[ UR 5n[U5nUHn U[R"SU 5- nM X R - nU$)rKrrurcrLb)rOrrPrQlenr rrSrTrUryrVrW payloadLengthpayloadLengthVaris rrXCopyright.serializes  -@!@AH T84 4I V[[t,, V[[w// DKK( )-8!A S!, ,I"[[ r)rr} r,r-r.r/r0rr1rrXr2r]r^s@rrrs#GN?rrc>^\rSrSrSrSrSrSU4SjjrSrSr U=r $)Texti( A class that encapsulates a text event rcX>URS5Ul[[U]X5 gr)rtextr>rr)rrrrr?s rr Text.__init__s"KK -  dD"49rcSnSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- nU[R"SU5- n[ UR 5n[U5nUHn U[R"SU 5- nM X R - nU$)rKrrurrLB)rOrrPrQrrrs rrXText.serializes  -@!@AH T84 4I V[[t,, V[[w// DII )-8!A S!, ,I"YY r)rr}rr^s@rrrs#GN:rrc@^\rSrSrSrSrSrSU4SjjrSrSr U=r $) KeySignaturei-rrcP>X lX0lX@l[[U]X5 gr) accidentalsaccidental_typemoder>rr)rrrrrrr?s rrKeySignature.__init__4s#&.  lD*4ArcSnSnSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- nU[R"SU5- nU[R"SU5- nU[R"SURUR -5- nU[R"SUR 5- nU$)rKrruYrcrLz>b)rOrrPrQrrr)rrSrTrUry event_subtyperVrWs rrXKeySignature.serialize;s   -@!@AH T84 4I V[[t,, V[[w// V[[}55 V[[t'7'7$:N:N'NOO V[[tyy11 r)rrrr}rr^s@rrr-s)GN"#Brrcb^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr Sr U=r$) ProgramChangeiN3 A class that encapsulates a program change event. rcD>X0lXl[[U]X$5 gr) programNumberr<r>rr)rr<rrrr?s rrProgramChange.__init__Vs*  mT+DBrcURUR:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$r)rrrr<rs rrProgramChange.__eq__\s\  -. UZZ'.""e&9&99.  - /rc(SnURUR-n[UR5nUHnU[R "SU5- nM U[R "SU5- nU[R "SUR 5- nU$rJ)rNr<rOrrPrQrrRs rrXProgramChange.serializeds $,,. +H T84 4I V[[t,, V[[t'9'9:: r)r<rr}r,r-r.r/r0rrNr1rrrr*rXr2r]r^s@rrrNs@GKN"#C / $$H  rrc\^\rSrSrSrSrSrS U4SjjrSr\ Rr Sr Sr U=r $) SysExEventirz6 A class that encapsulates a System Exclusive event. SysExrcD>X lX0l[[U]X5 gr)manIDpayloadr>rr)rrrrrr?s rrSysExEvent.__init__ys   j$(?rcgNFr3rs rrSysExEvent.__eq__~rcSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- n[[ UR 5S-5nUHnU[R"SU5- nM U[R"SUR 5- nX R - nU[R"SS5- nU$)rKrrLrc)rOrrPrQrrrrrSrTrUrVrWrlenBytes rrXSysExEvent.serializes  -@!@AH T84 4I V[[t,, &s4<<'81'<= $G T73 3I% V[[tzz22 \\! V[[t,, r)rrr}r~r^s@rrrrs6GN@ $$Hrrc^^\rSrSrSrSrSrS U4SjjrSr\ Rr Sr Sr U=r $) UniversalSysExEventiz@ A class that encapsulates a Universal System Exclusive event. UniversalSysExrch>X lX0lX@lXPlX`l[ [ U]X5 gr)realTime sysExChannelrUryrr>rr) rrrrrUryrrr?s rrUniversalSysExEvent.__init__s- (    !41$Hrcgrr3rs rrUniversalSysExEvent.__eq__rrcSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- n[[ UR 5S-5nUHnU[R"SU5- nM UR (aU[R"SS5- nOU[R"SS5- nU[R"SUR5- nU[R"SUR5- nU[R"SUR5- nX R - nU[R"SS5- nU$)rKrrrLr$~r) rOrrPrQrrrrrUryrs rrXUniversalSysExEvent.serializes6  -@!@AH T84 4I V[[t,, 's4<<'81'<= $G T73 3I% == T40 0I T40 0IV[[t'8'899 V[[tyy11 V[[t||44 \\! V[[t,, r)rUrrryrr}r~r^s@rrrs;GN+,I$$Hrrcb^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr Sr U=r$) ControllerEventirrcP>X@lXlX0l[[U]X%5 gr) parameterr<controller_numberr>rr)rr<rrrrr?s rrControllerEvent.__init__s"" !2 ot-dDrcgrr3rs rrControllerEvent.__eq__rrcvSnURUR-n[URU- 5nUHnU[R "SU5- nM U[R "SU5- nU[R "SUR 5- nU[R "SUR5- nU$rJ)rNr<rOrrPrQrrrRs rrXControllerEvent.serializes $,,. -@!@AH T84 4I V[[t,, V[[t'='=>> V[[t~~66 r)r<rrr}rr^s@rrrs@ GKN"#E$$H  rrc`^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr S r U=r$) ChannelPressureEventizB A class that encapsulates a Channel Pressure (Aftertouch) event. ChannelPressurercD>XlX0l[[U]X$5 gr)r<pressure_valuer>rr)rr<rrrr?s rrChannelPressureEvent.__init__s , "D24IrcURRURR:H=(aY URUR:H=(a9 URUR:H=(a URUR:H$r)r?r,rrr<rs rrChannelPressureEvent.__eq__sh''5??+C+CC. UZZ'.##u';';;.  - /rc.SnURUR-n[URU- 5nUHnU[R "SU5- nM U[R "SU5- nU[R "SUR 5- nU$rJ)rNr<rOrrPrQr)rrSrTrUvartickxs rrXChannelPressureEvent.serializes $,,. -@!@AA T1- -IV[[t,, V[[t':':;; r)r<rr}rr^s@rrrs; GKNJ / $$H  rrc`^\rSrSrSrSrSrSrS U4SjjrSr \ Rr Sr Sr U=r$) PitchWheelEventiz7 A class that encapsulates a pitch wheel change event. rcD>XlX0l[[U]X$5 gr)r<pitch_wheel_valuer>rr)rr<rrrr?s rrPitchWheelEvent.__init__s !2 ot-dDrcgrr3rs rrPitchWheelEvent.__eq__rrcSnURUR-n[URU- 5nUHnU[R "SU5-nM UR S-S- nUR S-S-nU[R "SU5-nU[R "SU5-nU[R "SU5-nU$)rKrrLi r)rNr<rOrrPrQr)rrSrTrUrVrWMSBLSBs rrXPitchWheelEvent.serialize"s $,,. -@!@AH!FKKh$??I %%,2%%,4 D$ 77  D# 66  D# 66 r)r<rr}rr^s@rrrs; GKNE $$Hrrc\^\rSrSrSrSrSrSU4SjjrSr\ Rr Sr Sr U=r $) TrackNamei3rrcX>URS5Ul[[U]X5 gr)r trackNamer>rr)rrrrr?s rrTrackName.__init__:s$")),7 i'>rcURUR:H=(a9 URUR:H=(a URUR:H$r)rrrrs rrTrackName.__eq__?sA  -2 UZZ'2%//1 3rcSn[URU- 5nUHnU[R"SU5- nM U[R"SS5- nU[R"SS5- n[ UR 5n[U5nUHnU[R"SU5- nM X R - nU$)rKrrLrrur&)rOrrPrQrr)rrSrTrVrW dataLength dataLengthVarrs rrXTrackName.serializeFs  -@!@AH T84 4I V[[d++ V[[d++ ( &z2 A S!, ,I^^# r)rr}r~r^s@rrr3s5GN? 3 $$Hrrc@^\rSrSrSrSrSrSU4SjjrSrSr U=r $) TimeSignatureiXz- A class that encapsulates a time signature. rc\>X lX0lX@lXPl[[ U]X5 gr) numerator denominatorclocks_per_ticknotes_per_quarterr>rr)rrrrrrrr?s rrTimeSignature.__init___s)"&.!2 mT+DBrcDSnSnSn[URU- 5nUHnU[R"SU5- nM U[R"SU5- nU[R"SU5- nU[R"SS5- nU[R"SUR5- nU[R"SUR 5- nU[R"SUR 5- nU[R"SUR5- nU$)rKrruXrLrx)rOrrPrQrrrr)rrSrTrUryrVrWs rrXTimeSignature.serializegs  -@!@AH T84 4I V[[t,, V[[w// V[[t,, V[[t~~66 V[[t'7'788 V[[t';';<< V[[t'='=>> r)rrrrr}rr^s@rrrXs)GN56Crrc\rSrSrSrSrSSjrSSjrSSjrSSjr SS jr SS jr SS jr SS jr SS jrSSjrSSjrSSjrSSjrSSjrSrSrSrSrSrSrSrSrSrg) MIDITracki|z( A class that encapsulates a MIDI track c[R"SSSSS5UlSUlSUlSUl/Ul/UlXlX l g ) z)Initialize the MIDITrack object. ccccMTrkrrFN) rPrQ headerStringrMIDIdataclosed eventList MIDIEventListremdep deinterleave)rremoveDuplicatesrs rrMIDITrack.__init__sL#KKdD$G  & (rNc URR[XX4UUUS95 URR[XX4-UUUS95 g)z% Add a note by chromatic MIDI number r=rN)rappendr5r`)rr<r9rr:r;r=rs raddNoteByNumberMIDITrack.addNoteByNumbersV fWTV0:5DF G ggdov1;6EG Hrc NURR[XUUUS95 g)z Add a controller event. rN)rrr)rr<rrrrs raddControllerEventMIDITrack.addControllerEvents* og=N.7>MO Prc JURR[XX4S95 g)z Add a pitch wheel event. r N)rrr)rr<rrrs raddPitchWheelEventMIDITrack.addPitchWheelEvents og=NpqrcJURR[XUS95 g)z$ Add a tempo change (or set) event. r N)rrrm)rrrprs raddTempoMIDITrack.addTempos$ eD4CE Frc LURR[XUUS95 g)z Add a SysEx event. r N)rrr)rrrrrs raddSysExMIDITrack.addSysExs& jg9HJ Krc PURR[XUX#UUS95 g)z Add a Universal SysEx event. r N)rrr)rrrUryrrrrs raddUniversalSysExMIDITrack.addUniversalSysExs+ 1$,"W.=? @rc LURR[XUUS95 g)z Add a program change event. r N)rrr)rr<rprogramrs raddProgramChangeMIDITrack.addProgramChanges& mG7)rrr)rrrrrrs raddKeySignatureMIDITrack.addKeySignatures) l4o+/;JL MrcJURR[XUS95 g)z Add a text event r N)rrr)rrrrs raddTextMIDITrack.addTexts# d4.=? @rc j[R"SU5nU[R"S[U55-nUHMupxU[R"SU5-n[U5n U Hn U[R"SU 5-nM MO URR [ SX2SSXeS95 g)z! Change the tuning of MIDI notes rLrrcr N)rPrQrfrequencyTransformrrr) rtuningsrr tuningProgamrr noteNumber frequency MIDIFreqencybytes rchangeNoteTuningMIDITrack.changeNoteTunings ++dL1FKKc'l;;'. #Z D* ==G-i8L$!FKKd$;;%(/ 1!XGN OrcURVs/sHoPM snUlURR[S9 UR(aUR 5 ggs snf)zt Process the event list, creating a MIDIEventList, which is then sorted to be in chronological order by start tick. keyN)rrsort sort_eventsrdeInterleaveNotes)revts rprocessEventListMIDITrack.processEventList sU .2^^<^cc^< K0     " " $  =s A"c[UR5n[U5UlURR[S9 g)z Remove duplicates from the eventList. This function will remove duplicates from the eventList. This is necessary because we the MIDI event stream can become confused otherwise. rSN)setrlistrUrV)rss rrMIDITrack.removeDuplicatess2  a  ,rcUR(agSUlUR(aUR5 UR5 g)a  Called to close a track before writing This function should be called to "close a track," that is to prepare the actual data stream for writing. Duplicate events are removed from the eventList, and the MIDIEventList is created. Called by the parent MIDIFile object. NT)rrrrYrFs r closeTrackMIDITrack.closeTrack(s4 ;;  ;;  ! ! # rc UR5 U=R[R"SSSSS5- sl[R"S[ UR55Ulg)z> Write the meta data and note data to the packed MIDI stream. BBBBrru/rwN)writeEventsToStreamrrPrQrrrFs rwriteMIDIStreamMIDITrack.writeMIDIStream<sN   " VT4tDD !++dC ,>?rcvSnURH'nU=RURU5- slM) g)z{ Write the events in MIDIEvents to the MIDI stream. MIDIEventList is presumed to be already sorted in chronological order. rN)rrrX)rrSevents rrfMIDITrack.writeEventsToStreamMs2  ''E MMU__-@A AM(rc/n0nURGHnURS;a[UR5[UR5-nURS:XaEXB;aX$R UR 5 OUR /X$'UR U5 MURS:Xaa[X$5S:a*X$R5UlUR U5 MX$R5 UR U5 GMGMUR U5 GM XlURR[S9 g)a Correct Interleaved notes. Because we are writing multiple notes in no particular order, we can have notes which are interleaved with respect to their start and stop times. This method will correct that. It expects that the MIDIEventList has been time-ordered. )r5r`r5r`rrSN) rrstrr9r<rrrpoprUrV)r tempEventListstackrj noteeventkeys rrWMIDITrack.deInterleaveNotesZs ''E}} 55 #5;;/#emm2DD ==H,#,+225::>/4zzl+!((/]]i/5./!3%*%8%<%<%> %,,U3+//1%,,U3 0$$U++(.+ K0rc[UR5S:Xag/nU(aUOSnSnURH.nURU- nXu- UlUnURU5 M0 X0lg)z Adjust Times to be relative, and zero-origined. If adjust is True, the track will be shifted. Regardelss times are converted to relative values here. rN)rrrr)roriginadjustrointernal_origin runningTickrj adjustedTicks radjustTimeAndOriginMIDITrack.adjustTimeAndOriginsp t!! "a '  $*& ''E ::7L%3EJ&K   ' ( +rcURUR5 URUR5 URUR5 g)z Write track to disk. N)writerrrr fileHandles r writeTrackMIDITrack.writeTracks< **+)'r)rrrrrrrrr[r})rFr)rTrr)r,r-r.r/r0rrr!r$r'r*r-r1r4r7r;r?rBrErPrYrrargrfrWryrr2r3rrr r |s ):;H",-Pr FK7<*+@NUJ=>NJ)*M@EI9:O %-" (@"B*1X+,(rr c$\rSrSrSrSrSrSrg) MIDIHeaderia2 Class to encapsulate the MIDI header structure. This class encapsulates a MIDI header structure. It isn't used for much, but it will create the appropriately packed identifier string that all MIDI files should contain. It is used by the MIDIFile class to create a complete and well formed MIDI pattern. c.[R"SSSSS5Ul[R"SS5Ul[R"SU5UlX l[R"SU5Ul[R"SU5Ulg ) aInitialize the data structures :param numTracks: The number of tracks the file contains. Integer, one or greater :param file_format: The format of the multi-track file. This should either be ``1`` (the default, and the most widely supported format) or ``2``. :param ticks_per_quarternote: The number of ticks per quarter note is what the Standard MIDI File Format Specification calls "division". Ticks are the integer unit of time in the SMF, and in every MIDI sequencer I am aware of. Common values are 120, 240, 384, 480, 960. Note that all these numbers are evenly divisible by 2,3,4,6,8,12,16, and 24, except 120 does not have 16 as a divisor. r r rhdrwz>HN)rPrQr headerSize formatnumnumeric_format numTracksticks_per_quarternote)rr file_formatrs rrMIDIHeader.__init__sm#KKdD$G ++dA.T;7)T95%+[[7L%M"rcURUR5 URUR5 URUR5 URUR5 URUR 5 gr)r|rrrrrr}s r writeFileMIDIHeader.writeFiles`**+)((334r)rrrrrrN)r,r-r.r/r0rrr2r3rrrrsN.5rrc\rSrSrSrSSSSS\S4SjrSrSrS!S jr S r S"S jr S r Sr S#SjrSrSrSrSrSrS$SjrS$SjrS$SjrS$SjrS%SjrSrS&SjrSrS#SjrSrSrS rg )'r iz A class that encapsulates a full, well-formed MIDI file object. This is a container object that contains a header (:class:`MIDIHeader`), one or more tracks (class:`MIDITrack`), and the data associated with a proper and well-formed MIDI file. rTFc[5UlUS:Xa US-UlOXl[URXV5UlX@lSUlX`lXplUR(a SUl OURUl [SUR5H'nURR[X#55 M) SUlg)a Initialize the MIDIFile class :param numTracks: The number of tracks the file contains. Integer, one or greater :param removeDuplicates: If set to ``True`` remove duplicate events before writing to disk :param deinterleave: If set to ``True`` deinterleave the notes in the stream :param adjust_origin: If set to ``True`` shift all the events in the tracks so that the first event takes place at time t=0. Default is ``False`` :param file_format: The format of the multi-track file. This should either be ``1`` (the default, and the most widely supported format) or ``2``. :param ticks_per_quarternote: The number of ticks per quarter note is what the Standard MIDI File Format Specification calls "division". Ticks are the integer unit of time in the SMF, and in most if not all MIDI sequencers. Common values are 120, 240, 384, 480, 960. Note that all these numbers are evenly divisible by 2,3,4,6,8,12,16, and 24, except 120 does not have 16 as a divisor. :param eventtime_is_ticks: If set True means event time and duration argument values are integer ticks instead of fractional quarter notes. Note that the default for ``adjust_origin`` will change in a future release, so one should probably explicitly set it. In a format 1 file, it would be a rare cirumstance where adjusting the origin of each track to the track's first note makes any sense. Example: .. code:: # Create a two-track MIDIFile from midiutil.MidiFile import MIDIFile midi_file = MIDIFile(1, adjust_origin=False) A Note on File Formats ---------------------- In previous versions of this code the file written was format 2 (which can be thought of as a collection of independent tracks) but was identified as format 1. In this version one can specify either format 1 or 2. In format 1 files there is a separate tempo track which contains tempo and time signature data, but contains no note data. If one creates a single track format 1 file the actual file has two tracks -- one for tempo data and one for note data. In the track indexing the tempo track can be ignored. In other words track 0 is the note track (the second track in the file). However, tempo and time signature data will be written to the first, tempo track. This is done to try and preserve as much interoperability with previous versions as possible. In a format 2 file all tracks are indexed and the track parameter is interpreted literally. rFcU$rr3)rs r#MIDIFile.__init__..%s1rrN)r]tracksrrheader adjust_originrreventtime_is_ticks time_to_ticksquarter_to_tickrangerr  event_counter) rrrrrrrrrs rrMIDIFile.__init__s@f ! &]DN&N T * %:""4  " "!,D !%!5!5D q$..)A KK  y)9H I*rc0[XR-5$r)r(r)rquarternote_times rrMIDIFile.quarter_to_tick1s#&@&@@AArc2[U5UR- $r)floatr)rticknums rtick_to_quarterMIDIFile.tick_to_quarter4sW~ : :::rNc URRS:XaUS- nURURX#UR U5UR U5XgUR S9 U=R S- slg)a Add notes to the MIDIFile object :param track: The track to which the note is added. :param channel: the MIDI channel to assign to the note. [Integer, 0-15] :param pitch: the MIDI pitch number [Integer, 0-127]. :param time: the time at which the note sounds. The value can be either quarter notes [Float], or ticks [Integer]. Ticks may be specified by passing eventtime_is_ticks=True to the MIDIFile constructor. The default is quarter notes. :param duration: the duration of the note. Like the time argument, the value can be either quarter notes [Float], or ticks [Integer]. :param volume: the volume (velocity) of the note. [Integer, 0-127]. :param annotation: Arbitrary data to attach to the note. The ``annotation`` parameter attaches arbitrary data to the note. This is not used in the code, but can be useful anyway. As an example, I have created a project that uses MIDIFile to write `csound `_ orchestra files directly from the class ``EventList``. rrN)rrrrrr)rtrackr<r9timer:r;r=s raddNoteMIDIFile.addNote7sy0 ;; % % * QJE E**7+/+=+=d+CTEWEWX`Ea+1;?;M;M + O arcURRS:XaUS- nURURUR U5UUR S9 U=R S- slg)a Name a track. :param track: The track to which the name is assigned. :param time: The time (in beats) at which the track name event is placed. In general this should probably be time 0 (the beginning of the track). :param trackName: The name to assign to the track [String] rr N)rrrr7rr)rrrrs rr7MIDIFile.addTrackNameWse ;; % % * QJE E''(:(:4(@)8<8J8J ( L arc URRS:XaSnURURUR U5X4XVUR S9 U=R S- slg)a Add a time signature event. :param track: The track to which the signature is assigned. Note that in a format 1 file this parameter is ignored and the event is written to the tempo track :param time: The time (in beats) at which the event is placed. In general this should probably be time 0 (the beginning of the track). :param numerator: The numerator of the time signature. [Int] :param denominator: The denominator of the time signature, expressed as a power of two (see below). [Int] :param clocks_per_tick: The number of MIDI clock ticks per metronome click (see below). :param notes_per_quarter: The number of annotated 32nd notes in a MIDI quarter note. This is almost always 8 (the default), but some sequencers allow this value to be changed. Unless you know that your sequencing software supports it, this should be left at its default value. The data format for this event is a little obscure. The ``denominator`` should be specified as a power of 2, with a half note being one, a quarter note being two, and eight note being three, etc. Thus, for example, a 4/4 time signature would have a ``numerator`` of 4 and a ``denominator`` of 2. A 7/8 time signature would be a ``numerator`` of 7 and a ``denominator`` of 3. The ``clocks_per_tick`` argument specifies the number of clock ticks per metronome click. By definition there are 24 ticks in a quarter note, so a metronome click per quarter note would be 24. A click every third eighth note would be 3 * 12 = 36. The ``notes_per_quarter`` value is also a little confusing. It specifies the number of 32nd notes in a MIDI quarter note. Usually there are 8 32nd notes in a quarter note (8/32 = 1/4), so the default value is 8. However, one can change this value if needed. Setting it to 16, for example, would cause the music to play at double speed, as there would be 16/32 (or what could be considered *two* quarter notes for every one MIDI quarter note. Note that both the ``clocks_per_tick`` and the ``notes_per_quarter`` are specified in terms of quarter notes, even is the score is not a quarter-note based score (i.e., even if the denominator is not ``4``). So if you're working with a time signature of, say, 6/8, one still needs to specify the clocks per quarter note. rrr N)rrrr;rr)rrrrrrrs rr;MIDIFile.addTimeSignaturegsgf ;; % % *E E++D,>,>t,Di,;<@B>P>P . R arc 8URU5n URRS:XaUS- nURUnU(aSOSn UR X)SX@R S9 U=R S- slX- n UR X)SXPR S9 U=R S- slX- n UR X)SX`R S9 U=R S- slX- n Ub1UR X)SXpR S9 U=R S- slgg) a Perform a Registered Parameter Number Call :param track: The track to which this applies :param channel: The channel to which this applies :param time: The time of the event :param controller_msb: The Most significant byte of the controller. In common usage this will usually be 0 :param controller_lsb: The Least significant Byte for the controller message. For example, for a fine-tuning change this would be 01. :param data_msb: The Most Significant Byte of the controller's parameter. :param data_lsb: The Least Significant Byte of the controller's parameter. If not needed this should be set to ``None`` :param time_order: Order the control events in time (see below) As an example, if one were to change a channel's tuning program:: makeRPNCall(track, channel, time, 0, 3, 0, program) (Note, however, that there is a convenience function, ``changeTuningProgram``, that does this for you.) Registered/Non-Registered Parameter Number (RPN / NRPN) ------------------------------------------------------- Controller number 6 (Data Entry), in conjunction with Controller numbers 96 (Data Increment), 97 (Data Decrement), 98 (Registered Parameter Number LSB), 99 (Registered Parameter Number MSB), 100 (Non-Registered Parameter Number LSB), and 101 (Non-Registered Parameter Number MSB), extend the number of controllers available via MIDI. Parameter data is transferred by first selecting the parameter number to be edited using controllers 98 and 99 or 100 and 101, and then adjusting the data value for that parameter using controller number 6, 96, or 97. RPN and NRPN are typically used to send parameter data to a synthesizer in order to edit sound patches or other data. Registered parameters are those which have been assigned some particular function by the MIDI Manufacturers Association (MMA) and the Japan MIDI Standards Committee (JMSC). For example, there are Registered Parameter numbers assigned to control pitch bend sensitivity and master tuning for a synthesizer. Non-Registered parameters have not been assigned specific functions, and may be used for different functions by different manufacturers. The ``time_order`` parameter is something of a work-around for sequencers that do not preserve the order of events from the MIDI files they import. Within this code care is taken to preserve the order of events as specified, but some sequencers seem to transmit events occurring at the same time in an arbitrary order. By setting this parameter to ``True`` something of a work-around is performed: each successive event (of which there are three or four for this event type) is placed in the time stream a small delta from the preceding one. Thus, for example, the controllers are set before the data bytes in this call. rrer drN&rrrrr!r rrr<rcontroller_msbcontroller_lsbdata_msbdata_lsb time_orderr tick_incrs r makeRPNCallMIDIFile.makeRPNCall@s2r!!$' ;; % % * QJE E"#A    !/ASAS ! U a    !/ASAS ! U a    !);M;M ! O a     $ $WB%-?Q?Q % S   ! #  rc 8URU5n URRS:XaUS- nURUnU(aSOSn UR X)SX@R S9 U=R S- slX- n UR X)SXPR S9 U=R S- slX- n UR X)SX`R S9 U=R S- slX- n Ub1UR X)SXpR S9 U=R S- slgg) a, Perform a Non-Registered Parameter Number Call :param track: The track to which this applies :param channel: The channel to which this applies :param time: The time of the event :param controller_msb: The Most significant byte of thecontroller. In common usage this will usually be 0 :param controller_lsb: The least significant byte for the controller message. For example, for a fine-tunning change this would be 01. :param data_msb: The most significant byte of the controller's parameter. :param data_lsb: The least significant byte of the controller's parameter. If none is needed this should be set to ``None`` :param time_order: Order the control events in time (see below) The ``time_order`` parameter is something of a work-around for sequencers that do not preserve the order of events from the MIDI files they import. Within this code care is taken to preserve the order of events as specified, but some sequencers seem to transmit events occurring at the same time in an arbitrary order. By setting this parameter to ``True`` something of a work-around is performed: each successive event (of which there are three or four for this event type) is placed in the time stream a small delta from the preceding one. Thus, for example, the controllers are set before the data bytes in this call. rrcr brNrrrs r makeNRPNCallMIDIFile.makeNRPNCalls1>!!$' ;; % % * QJE E"#A    !/ASAS ! U a    !/ASAS ! U a    !);M;M ! O a     $ $WB%-?Q?Q % S   ! #  rc .URXUSSSUUS9 g)a_ Change the tuning bank for a selected track :param track: The track to which the data should be written :param channel: The channel for the event :param time: The time of the event :param bank: The tuning bank (0-127) :param time_order: Preserve the ordering of the component events by ordering in time. See ``makeRPNCall()`` for a discussion of when this may be necessary Note that this is a convenience function, as the same functionality is available from directly sequencing controller events. The specified tuning should already have been written to the stream with ``changeNoteTuning``. rrxrNr)rrr<rbankrs rchangeTuningBankMIDIFile.changeTuningBanks&& q!Q$.  0rc .URXUSSSUUS9 g)an Change the tuning program for a selected track :param track: The track to which the data should be written :param channel: The channel for the event :param time: The time of the event :param program: The tuning program number (0-127) :param time_order: Preserve the ordering of the component events by ordering in time. See ``makeRPNCall()`` for a discussion of when this may be necessary Note that this is a convenience function, as the same functionality is available from directly sequencing controller events. The specified tuning should already have been written to the stream with ``changeNoteTuning``. rr&rNr)rrr<rr0rs rchangeTuningProgramMIDIFile.changeTuningPrograms&* q!Q$.  0rcURRS:XaUS- nURURX#UUURS9 U=RS- slg)af Add a real-time MIDI tuning standard update to a track. :param track: The track to which the tuning is applied. :param tunings: A list to tuples representing the tuning. See below for an explanation. :param sysExChannel: The SysEx channel of the event. This is mapped to "manufacturer ID" in the event which is written. Unless there is a specific reason for changing it, it should be left at its default value. :param realTime: Speicifes if the Universal SysEx event should be flagged as real-time or non-real-time. As with the ``sysExChannel`` argument, this should in general be left at it's default value. :param tuningProgram: The tuning program number. This function specifically implements the "real time single note tuning change" (although the name is misleading, as multiple notes can be included in each event). It should be noted that not all hardware or software implements the MIDI tuning standard, and that which does often does not implement it in its entirety. The ``tunings`` argument is a list of tuples, in (*note number*, *frequency*) format. As an example, if one wanted to change the frequency on MIDI note 69 to 500 (it is normally 440 Hz), one could do it thus: .. code:: python from midiutil.MidiFile import MIDIFile MyMIDI = MIDIFile(1) tuning = [(69, 500)] MyMIDI.changeNoteTuning(0, tuning, tuningProgam=0) rr N)rrrrPr)rrrJrrrKs rrPMIDIFile.changeNoteTunings`F ;; % % * QJE E++G8,8<@ *"q$..)A KKN . .v7I7I J KKN * * ,* rcSnURHVn[UR5S:dMURSRU:dM=URSRnMX U$)z5 Find the earliest time in the file's tracks.append. rr)rrrr)rrtrs rrMIDIFile.findOriginsb[[E5&&'!+&&q)..7"00388F!  r) rrrrrrrrrr)rHr})F)rTr)rF) r,r-r.r/r0TICKSPERQUARTERNOTErrrrr7r;r'r?rBrEr1r4r!r$rrrrrPr*r-rrrrr2r3rrr r s"#T$!':uTrB;  @ "=>9 v " ")*$ L   $ $ ( "49O$dEJ5$n0.(-00=A56( T 27<  D2",@8rr cUS:XaS/$/nSnUS:a)URUS-U-S-5 US-nSnUS:aM)UR5 U$)a Accept an integer, and serialize it as a MIDI file variable length quantity Some numbers in MTrk chunks are represented in a form called a variable- length quantity. These numbers are represented in a sequence of bytes, each byte holding seven bits of the number, and ordered most significant bits first. All bytes in the sequence except the last have bit 7 set, and the last byte has bit 7 clear. This form allows smaller numbers to be stored in fewer bytes. For example, if the number is between 0 and 127, it is thus represented exactly as one byte. A number between 128 and 16383 uses two bytes, and so on. Examples: Number VLQ 128 81 00 8192 C0 00 16383 FF 7F 16384 81 80 00 rrrurrb)rreverse)rvlbyteshibits rrOrOse( Avs G E a%TU*d23 a a% OO NrcUnSnSnUS-n[R"SX5SnUS-nUS-nX5S--nUS-S:XaX44$M?)z A function to read a MIDI variable length variable. It returns a tuple of the value read and the number of bytes processed. The input is an offset into the buffer, and the buffer itself. rrrLrrrb)rP unpack_from)rbuffertoffsetoutput bytesReadrOs r readVarLengthrsqG FI 1!!$8;A+M #:& 3J1     rcSn[U5nSS[R"U[S5- S5--n[U5nS[ S[U5S- S- 5-nX:waS [R"X- S5-OS n[ US - U-5n[ [U5S - S /5nXgS -- n[ US /5nUS :XaUS :XaUS :XaSn[U5nX7U/$)z0 Returns a three-byte transform of a frequency. i@Er"rc@@Q@(@irrrrr)rmathlogr(powroundmin) freq resolutiondollars firstByte lowerFreqcentDifcents secondByte thirdBytes rrIrIsJ ;D2s!4a888GG Ic#y!1D!8D @BBI8<8IdTXXt/!44qG 'C-*, -Ec%jAot,-Jq)IY%&IDZ4/I4E II 9 --rcSnS[S[USS- 5S- 5-n[[US5S-[US 5-5S -U- nU[SUS - 5-nU$) zM The reverse of frequencyTransform. Given a byte stream, return a frequency. g@rrrrrrrrcgY@g@)rrr() freqBytesr  baseFrequencyfracrMs rreturnFrequencyrsxJ#cE)A,*=$>$EGGM 3y|$)S1->> ?% G: UDC 77I rcHURURUR4$)a .. py:function:: sort_events(event) The key function used to sort events (both MIDI and Generic) :param event: An object of type :class:`MIDIEvent` or (a derrivative) :class:`GenericEvent` This function should be provided as the ``key`` for both ``list.sort()`` and ``sorted()``. By using it sorting will be as follows: * Events are ordered in time. An event that takes place earlier will appear earlier * If two events happen at the same time, the secondary sort key is ``sec_sort_order``. Thus a class of events can be processed earlier than another. One place this is used in the code is to make sure that note off events are processed before note on events. * If event time and event ordinality are the same, they are sorted in the order in which they were originally added to the list. Thus, for example, if one is making an RPN call one can specify the controller change events in the proper order and be sure that they will end up in the file that way. )rr1r)rjs rrVrVs!4 JJ,,e.C.C DDr)& __future__rrrrPwarnings __version__rcontrollerEventTypesr r r r__all__objectrr5r`rmrrrrrrrrrrrr rr rOrrIrrVr3rrrsM0  t}     ;-6-`)\)X*|*Z5L5p% %P<><B!L!H##L/,/d l F < F l F" "J!L!Hg(g(T &5&5Ri vi XF*.(Er