3jUdZddlmZgdZddlmZddlZddlmZddlZ ddl m Z ddl m Z dd l mZdd l mZdd l mZej"d ZGd dej&Zed*dZed+dZd,dZd-dZd.dZd/dZd0dZGdde ZGdde ZGdde ZGdde ZdZeezezeze j>dzZ Gd d!ejBZ"Gd"de"Z#Gd#d$ejBZ$Gd%d&ejBZ%e"e#e$e%gZ&d'e'd(<e(d)k(rddl Z e jRyy)1ax Objects and tools for processing MIDI data. Converts from MIDI files to :class:`~music21.midi.MidiEvent`, :class:`~music21.midi.MidiTrack`, and :class:`~music21.midi.MidiFile` objects, and vice versa. This module originally used routines from Will Ware's public domain midi.py library from 2001 which was once posted at groups.google.com/g/alt.sources/msg/0c5fc523e050c35e ) annotations)ChannelModeMessagesChannelVoiceMessages DeltaTimeMETAEVENT_MARKER MetaEvents MidiEvent MidiExceptionMidiFile MidiTrack SysExEvents getNumbergetVariableLengthNumber putNumberputNumbersAsListputVariableLengthNumber)IterableN)overload) ContainsEnum)defaults) environment) exceptions21)prebasez midi.basec eZdZy)r N)__name__ __module__ __qualname__>/DATA/.local/lib/python3.12/site-packages/music21/midi/base.pyr r :srr cyNr midiByteslengths r rr>rcyr"rr#s r rrBr&rcd}t|tr$t|D]}||}|dz|z}|||dfS|}||d|zz d|zzz }||z }||fS)ao Extract the first `length` bytes from a bytes object (or int) and return it and the remaining bytes object as a 2-tuple The `length` is the number of chars to read. This will sum a length greater than 1 if desired. Note that MIDI uses big-endian for everything. This is the inverse of Python's chr() function. Read first two bytes from the bytes encoding of "tests" and return the remainder >>> midi.getNumber(b'tests', 2) (29797, b'sts') That number comes from: >>> ord('t') * 256 + ord('e') 29797 Demonstration of reading the whole length of a byte in: >>> midi.getNumber(b'test', 4) (1952805748, b'') Reading in zero bytes leaves the midiStr unchanged: >>> midi.getNumber(b'test', 0) (0, b'test') The method can also take in an integer and return an integer and the remainder part. This usage might be deprecated in the future and has already been replaced within music21 internal code. >>> midi.getNumber(516, 1) # = 2*256 + 4 (4, 512) * Changed in v10: remove Python 2 legacy string as input -- use bytes instead. rN) isinstancebytesrange)r$r% summationimidiBytemidNumbigBytess r rrFsPI)U#vA |H"a83I)FG,,,v!f*51v:FG I%(""rcxd}d}|dkr'||}|dz|dzz}|dz }|dzs|||dfS|dkr'td) u Given a string or bytes of data, strip off the first character, or all high-byte characters terminating with one whose ord() function is < 0x80. Thus, a variable number of bytes might be read. After finding the appropriate termination, return the remaining string. This is necessary as DeltaTime times are given with variable size, and thus may be of different numbers if characters are used. >>> midi.getVariableLengthNumber(b'A-u') (65, b'-u') >>> midi.getVariableLengthNumber(b'-u') (45, b'u') >>> midi.getVariableLengthNumber(b'u') (117, b'') >>> midi.getVariableLengthNumber(b'test') (116, b'est') >>> midi.getVariableLengthNumber(b'E@-E') (69, b'@-E') >>> midi.getVariableLengthNumber(b'@-E') (64, b'-E') >>> midi.getVariableLengthNumber(b'-E') (45, b'E') >>> midi.getVariableLengthNumber(b'E') (69, b'') Test that variable length characters work: >>> midi.getVariableLengthNumber(b'\xff\x7f') (16383, b'') >>> midi.getVariableLengthNumber('中xy'.encode('utf-8')) (210638584, b'y') If no low-byte character is encoded, raises an IndexError >>> midi.getVariableLengthNumber('中国'.encode('utf-8')) Traceback (most recent call last): IndexError: index out of range Up to v9.7, this method could also take a string as input and return a string. This usage is now removed. riNz#did not find the end of the number!)r )r$r-r.xs r rr{skbI A c' aL!^D1  QDim+ + c' = >>rct}t|D]&}d|dz |z z}||z dz}|j|(t|S)a Put a single number as a hex number at the end of a bytes object `length` bytes long. >>> midi.putNumber(3, 4) b'\x00\x00\x00\x03' >>> midi.putNumber(0, 1) b'\x00' >>> midi.putNumber(258, 2) b'\x01\x02' If the number is larger than the length currently only the least significant bytes are returned. This behavior may change in the near future to raise an exception instead. >>> midi.putNumber(258, 1) b'\x02' r)r5) bytearrayr,appendr+)numr%lstr.nthisNums r rrsQ& +C 6] !a !8t# 7 :rc|dkrtd|t} |dz|dz }}|j|dz|dk(rn%|j|ddz|d<t |S)a Turn an integer number into the smallest bytes object that can hold it for MIDI Numbers < 128 are encoded as single bytes and are the same as bytes([x]) >>> midi.putVariableLengthNumber(4) b'\x04' >>> midi.putVariableLengthNumber(127) b'\x7f' >>> bytes([127]) b'\x7f' >>> midi.putVariableLengthNumber(0) b'\x00' Numbers > 7bit but < 16384 need two characters, with the first character set as 0x80 + n // 128 and the second character set as n % 128: >>> midi.putVariableLengthNumber(128) b'\x81\x00' >>> midi.putVariableLengthNumber(129) b'\x81\x01' >>> midi.putVariableLengthNumber(255) b'\x81\x7f' This differs from the 8-bit representation of `bytes([x])`: >>> bytes([128]) b'\x80' >>> bytes([255]) b'\xff' This method can also deal with numbers > 255, which `bytes` cannot. >>> midi.putVariableLengthNumber(256) b'\x82\x00' >>> bytes([256]) Traceback (most recent call last): ValueError: bytes must be in range(0, 256) It also differs from the normal way of representing 256 in Python bytes: >>> bytes([1, 0]) b'\x01\x00' Here are MIDI representation of other numbers that are too large to fit in 8 bits but stored in two bytes in MIDI. >>> midi.putVariableLengthNumber(1024) b'\x88\x00' Notice that the least significant byte is second. >>> midi.putVariableLengthNumber(8192) b'\xc0\x00' >>> midi.putVariableLengthNumber(8193) b'\xc0\x01' This is the maximum normal MIDI number that can be stored in 2 bytes. >>> midi.putVariableLengthNumber(16383) b'\xff\x7f' Numbers >= 16384 are not used in 2-byte classic MIDI, but this routine continues the basic principle from above: >>> midi.putVariableLengthNumber(16384) b'\x81\x80\x00' >>> midi.putVariableLengthNumber(16384 + 128) b'\x81\x81\x00' >>> midi.putVariableLengthNumber(16384 * 2) b'\x82\x80\x00' >>> midi.putVariableLengthNumber(16384 ** 2) b'\x81\x80\x80\x80\x00' Negative numbers raise MidiException >>> midi.putVariableLengthNumber(-1) Traceback (most recent call last): music21.midi.base.MidiException: cannot putVariableLengthNumber() when number is negative: -1 rz:cannot putVariableLengthNumber() when number is negative: r4r3r6)r r:r;reverser+)r7r=ys r rrsj 1uXYZX[\]] +C 4xa1 1t8 6   KKM"gnCG :rct}|D]0}|dkr|dz}|dk\rtd||j|2t|S)aS Translate a list of numbers (0-255) into bytes. Used for encoding data messages where each byte encodes a different discrete value. >>> midi.putNumbersAsList([0, 0, 0, 3]) b'\x00\x00\x00\x03' For positive numbers this method behaves the same as `bytes(numList)` and that method should be used if you are sure all numbers are positive. >>> bytes([0, 0, 0, 3]) b'\x00\x00\x00\x03' If a number is < 0 then it wraps around from the top. This is used in places like MIDI key signatures where flats are represented by `256 - flats`. >>> midi.putNumbersAsList([0, 0, 0, -3]) b'\x00\x00\x00\xfd' >>> midi.putNumbersAsList([0, 0, 0, -1]) b'\x00\x00\x00\xff' The behavior with negative numbers is different from `bytes(numList)` List can be of any length >>> midi.putNumbersAsList([1, 16, 255]) b'\x01\x10\xff' Any number > 255 (or less than -255) raises an exception: >>> midi.putNumbersAsList([256]) Traceback (most recent call last): music21.midi.base.MidiException: Cannot place a number > 255 in a list: 256 rz'Cannot place a number > 255 in a list: )r:r r;r+)numListpostr>s r rr;sWF ;D  q5CA 8"I! MN N A  ;rc,eZdZdZdZdZdZdZdZdZ dZ y ) rzo ChannelVoiceMessages are the main MIDI messages for channel 1-16, such as NOTE_ON, NOTE_OFF, etc. r6N) rrr__doc__NOTE_OFFNOTE_ONPOLYPHONIC_KEY_PRESSURECONTROLLER_CHANGEPROGRAM_CHANGECHANNEL_KEY_PRESSURE PITCH_BENDrrr rris/HG"NJrrc,eZdZdZdZdZdZdZdZdZ dZ y ) rxyz{|}~r4N) rrr ALL_SOUND_OFFRESET_ALL_CONTROLLERS LOCAL_CONTROL ALL_NOTES_OFF OMNI_MODE_OFF OMNI_MODE_ON MONO_MODE_ON POLY_MODE_ONrrr rrws+M MMMLLLrrcXeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZy)rrr5r3r) !/QTXYr4r9N)rrrSEQUENCE_NUMBER TEXT_EVENTCOPYRIGHT_NOTICESEQUENCE_TRACK_NAMEINSTRUMENT_NAMELYRICMARKER CUE_POINT PROGRAM_NAMESOUND_SET_UNSUPPORTEDMIDI_CHANNEL_PREFIX MIDI_PORT END_OF_TRACK SET_TEMPO SMPTE_OFFSETTIME_SIGNATURE KEY_SIGNATURESEQUENCER_SPECIFIC_META_EVENTUNKNOWNrrr rrshOJO E FIL !ILILNM$(!GrrceZdZdZdZy)r N)rrrF0_SYSEX_EVENTF7_SYSEX_EVENTrrr r r s NNrr r9rcPeZdZdZdej ddf ddZeddZddZ eddZ e jdd Z edd Z e jdd Z edd Z e jdd Z ddZdd dZd!dZd!dZd"dZddZddZddZd#dZy)$r a A model of a MIDI event, including note-on, note-off, program change, controller change, any many others. MidiEvent objects are paired (preceded) by :class:`~music21.midi.DeltaTime` objects in the list of events in a MidiTrack object. The `track` argument must be a :class:`~music21.midi.MidiTrack` object. The `type` attribute is an enumeration of a Midi event from the ChannelVoiceMessages, ChannelModeMessages, SysExEvents, or MetaEvents enums; if unspecified, defaults to MetaEvents.UNKNOWN. The `channel` attribute is an integer channel id, from 1 to 16. The `time` attribute is an integer duration of the event in ticks. This value can be zero. This value is not essential, as ultimate time positioning is determined by :class:`~music21.midi.DeltaTime` objects. The `pitch` attribute is only defined for note-on and note-off messages. The attribute stores an integer representation (0-127, with 60 = middle C). The `velocity` attribute is only defined for note-on and note-off messages. The attribute stores an integer representation (0-127). A note-on message with velocity 0 is generally assumed to be the same as a note-off message. The `data` attribute is used for storing other messages, such as SEQUENCE_TRACK_NAME string values. .. warning:: The attributes `.midiProgram` and `.midiChannel` on :class:`~music21.instrument.Instrument` objects are 0-indexed, just as they need to be in the written binary .mid. However, as a convenience, :attr:`MidiEvent.channel` is 1-indexed. No analogous convenience is provided for program change data. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.channel = 3 >>> me1.time = 200 >>> me1.pitch = 60 >>> me1.velocity = 120 >>> me1 >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.MetaEvents.SEQUENCE_TRACK_NAME >>> me2.data = 'guitar' >>> me2 * Changed in v9.7: None is not a valid type anymore. Use MetaEvents.UNKNOWN instead. Channel defaults to 1. Nrr5c||_||_||_||_d|_d|_d|_d|_d|_yr") tracktypetimechannel parameter1 parameter2 centShiftcorrespondingEventlastStatusByte)selfrrrrs r __init__zMidiEvent.__init__sK &+ $(  # *.*. $( 37)-rc||jtjk(ry|jtjk(ryy)ah Ensure that for MidiEvents at the same "time", that order is NOTE_OFF, PITCH_BEND, all others. >>> CVM = midi.ChannelVoiceMessages >>> noteOn = midi.MidiEvent(type=CVM.NOTE_ON) >>> noteOff = midi.MidiEvent(type=CVM.NOTE_OFF) >>> pitchBend = midi.MidiEvent(type=CVM.PITCH_BEND) >>> sorted([noteOn, noteOff, pitchBend], key=lambda me: me.sortOrder) [, , ] iir)rrrPrVrs r sortOrderzMidiEvent.sortOrders3" 99,55 5 YY.99 9rc|jd}n=t|jtr |j}n|jj}t|jt r|jj }n$|jd}nt|j}|d}|jdk7r|d|jdz }|d|z }|jr|d|jz }|jtjtjfvrddg}n|jd g}nd d g}|D]0}t|||dz|zd ztt||z}2|S) NNone, rzt=ztrack=z , channel=pitchvelocitydatarr=)rr*intindexrrnamereprrisChannelEventrrrQrPrgetattr)r trackIndex printTyperattrListattribs r _reprInternalzMidiEvent._reprInternalsW :: J  C (J))J dii . I YY ITYYIk  99> 2dii]"% %A vj\ ""    :dll-. .A 99-557K7T7TU U,H&"8(,7FtV$0Hv%+d743H.IIrc|jtjtjfvr!|jt |jSyr")rrrQrPrrrs r rzMidiEvent.pitchBs? II.668L8U8UV VOO/t' 'rc||_yr"rrvalues r rzMidiEvent.pitchK rcPt|jtsy|jSr")r*rrrs r rzMidiEvent.velocityOs$//3/rc||_yr")rrs r rzMidiEvent.velocityUrrc|jS)z Read or set the data (`.parameter1`) for the object Does some automatic conversions: >>> me = midi.MidiEvent(type=midi.ChannelModeMessages.LOCAL_CONTROL) >>> me.data = True >>> me.data b'\x01' rrs r rzMidiEvent.dataZsrc|^t|tsNt|tr|jd}||_yt|trtt |g}||_y)Nzutf-8)r*r+strencodeboolrrrs r rzMidiEvent.datahsU  Zu%=%% W- E4(s5zl+rcN|jtvxs|jtvS)a returns bool if the channel matters for this event >>> me = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=4) >>> me.isChannelEvent() True >>> dt = midi.DeltaTime() >>> dt.isChannelEvent() False )rrrrs r rzMidiEvent.isChannelEventqs#yy00TDIIAT4TTrcV|dz}||kDr|}n |d|zkrd|z}d}d|z }|}||z }|dkDrtt||z}n|dkrtt||z}nd}||z} t| } | d} | dz} t| dkDr | d} | dz} n| } d} | |_| |_y) a Treat this event as a pitch bend value, and set the .parameter1 and .parameter2 fields appropriately given a specified bend value in cents. Also called Pitch Wheel The `bendRange` parameter gives the number of half steps in the bend range. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.PITCH_BEND) >>> me1.setPitchBend(50) >>> me1.parameter1, me1.parameter2 (0, 80) >>> me1.setPitchBend(100) >>> me1.parameter1, me1.parameter2 (0, 96) Neutral is 0, 64 >>> me1.setPitchBend(0) >>> me1.parameter1, me1.parameter2 (0, 64) Parameter 2 is the most significant digit, not parameter 1. >>> me1.setPitchBend(101) >>> me1.parameter1, me1.parameter2 (40, 96) Exceeding maximum pitch bend sets the max (127, 127) >>> me1.setPitchBend(200) >>> me1.parameter1, me1.parameter2 (127, 127) >>> me1.setPitchBend(300) >>> me1.parameter1, me1.parameter2 (127, 127) >>> me1.setPitchBend(-50) >>> me1.parameter1, me1.parameter2 (0, 48) >>> me1.setPitchBend(-100) >>> me1.parameter1, me1.parameter2 (0, 32) >>> me1.setPitchBend(-196) >>> me1.parameter1, me1.parameter2 (36, 1) >>> me1.setPitchBend(-200) >>> me1.parameter1, me1.parameter2 (0, 0) Again, excess trimmed >>> me1.setPitchBend(-300) >>> me1.parameter1, me1.parameter2 (0, 0) But a larger `bendRange` can be set in semitones for non-GM devices: >>> me1.setPitchBend(-300, bendRange=4) >>> me1.parameter1, me1.parameter2 (0, 16) >>> me1.setPitchBend(-399, bendRange=4) >>> me1.parameter1, me1.parameter2 (20, 0) OMIT_FROM_DOCS Pitch bends very close to 0 formerly had problems >>> me1.setPitchBend(-196) >>> me1.parameter1, me1.parameter2 (36, 1) >>> me1.setPitchBend(-197) >>> me1.parameter1, me1.parameter2 (123, 0) drAi i?rr4r5N)rroundrlenrr) rcents bendRange centRangecentertopSpan bottomSpan shiftScalarshifttarget charValued1d2s r setPitchBendzMidiEvent.setPitchBend~sbO 9 E R)^ #NEv% i' 19kG345E QYkJ678EE%,F3 q\ $Y y>A 1BdBBB rc>t|dkrtd|d|d}|d}d}t|dkDr|d}|dz}|dz}|dz|_t||_|jtj tj fvr,|dkDrtd |jd |||_|dd S|jtjk(rd }tj|rft||_|jtjk(rd }|ddk(|_n)|jtjk(r d }|d|_|s||_||_|dd S|jtj k(r||_||_|dd S|jtj"tj$fvr||_||_|dd S|jtj*k(r||_||_|dd St-d|j)a\ Take a set of bytes that represent a ChannelVoiceMessage and set the appropriate event type and data, returning the remaining bytes. Channel voice messages start with a one-byte message from 0x80 to 0xEF, where the first nibble (8-E) is the message type and the second nibble (0-F) is the channel represented in hex. First let's create a MidiEvent that does not know its type. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1 Now create two messages -- a note on (at pitch = 60 or C4) at velocity 120 >>> midBytes = bytes([0x92, 60, 120]) >>> midBytes b'\x92>> midBytes += b'hello' >>> midBytes b'\x92>> remainder = me1.parseChannelVoiceMessage(midBytes) >>> me1 The remainder would probably contain a delta time and following events, but here we'll just show that it passes whatever is left through. >>> remainder b'hello' We will ignore remainders for the rest of this demo. Note that all attributes are set properly: >>> me1.type >>> me1.pitch # 60 = middle C 60 >>> me1.velocity 120 The channel is 3 because 0x90 is NOTE_ON for channel 1, 0x91 is 2, and 0x92 is 3, etc. >>> me1.channel 3 Now let's make a program change on channel 16: >>> me2 = midi.MidiEvent(mt) >>> rem = me2.parseChannelVoiceMessage(bytes([0xCF, 71])) >>> me2 >>> me2.data # 71 = clarinet (0-127 indexed) 71 Program changes and channel pressures only go to 127. More than that signals an error: >>> me2.parseChannelVoiceMessage(bytes([0xCF, 200])) Traceback (most recent call last): music21.midi.base.MidiException: Cannot have a followed by a byte > 127: 200 rhz length of z must be at least 2rr5rr4zCannot have a z followed by a byte > 127: NFTriz"expected ChannelVoiceMessage, got )r ValueErrorrrrrTrUr rrSrhasValuerarerrrVrQrPrrrR TypeError)rr$byte0byte1byte2 msgNybble channelNybblespecificDataSets r parseChannelVoiceMessagez"MidiEvent.parseChannelVoiceMessages%T y>A z)6IJK K! !  y>A aLE "T\ $q( (3  99-<<-BBD Ds{#$TYYM1LUGTVVDIQR= YY.@@ @#O"++E2/6 99 3 A AA&*O!*1!5DIYY"5"B"BB&*O )! DI""'"'QR= YY.99 9#DO#DOQR= YY/779M9V9VW WDJ!DMQR= YY.FF F#DO#DOQR= >> channel = 0x2 >>> noteOnMessage = midi.ChannelVoiceMessages.NOTE_ON | channel >>> hex(noteOnMessage) '0x92' This is how the system reads note-on messages (0x90-0x9F) and channels >>> hex(0x91 & 0xF0) # testing message type extraction '0x90' >>> hex(0x92 & 0xF0) # testing message type extraction '0x90' >>> (0x90 & 0x0F) + 1 # getting the channel 1 >>> (0x9F & 0x0F) + 1 # getting the channel 16 rhz%MidiEvent.read(): got bad data stringrrr6Nr9rr5zgot unknown midi event typezhex(midiBytes[1])zUnknown midi event type )r environLocal printDebugrrr+rrrr rrrrrrhexr )rr$rrunningStatusBytemsgTyperr%midiBytesAfterLengths r readzMidiEvent.readus, y>A   # #8$y/J L q\ 4<"".$)4+>+>*?$@!$+!*I5IaLE d]"'D t|q\ ( ( 100; ;  ! !% (#E*DI+B9QR=+Q (F(,Wf5DI'0 0& &""5)&u- '.. +B9QR=+Q (F(,Wf5DI'0 0  # #%BCJ%8#il:K%M N":3u:, GH Hrc  tjrt|jtsJ|jt vrt |jdz |jjzg}|jt jt jfvr|j |j tdt|jtrt |jg}n |j}t|jtrt |jg}n |j}||z}||zS|jt jk(r5t|jtrt |jg}||zS t|jtrt |jg}n2t|jt r |j}n t!d||zS|jt$vr|jt d|jzdz g}t |jjg}t|jtrt |jg}n |j}||z|zS|jt&vrt|jt rjt |jjg}|t)t+|jz}tj,t |j}||zS|jt.vrt|jt t0fr~t t2g}|t |jjgz }|t)t+|jz } tj,t |j}||zStd |j#t t"f$r td|d|jddzwxYw#t4t f$rN|t7j8d tj,t0|jj;d d zcYSwxYw) a Return a set of bytes for this MIDI event (used for translating from music21 to MIDI) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=10) >>> noteOn.pitch = 60 >>> noteOn.velocity = 127 >>> noteOn.getBytes() b'\x99<\x7f' Changing the pitch changes the second byte (from less than to greater than): >>> noteOn.pitch = 62 >>> noteOn.getBytes() b'\x99>\x7f' >>> ord('>') 62 Changing the velocity changes the third byte: >>> noteOn.velocity = 64 >>> noteOn.getBytes() b'\x99>@' The third byte is `\x40` but it is represented by '@' >>> ord('@') 64 >>> hex(64) '0x40' And changing the channel changes the first byte: >>> noteOn.channel = 11 >>> noteOn.getBytes() b'\x9a>@' r5z>Cannot write MIDI event without parameter1 and parameter2 set.zdata must be bytes or intzGot incorrect data for z in .data: rz"cannot parse Miscellaneous MessagerKNFKDasciiignorezunknown midi event type: )t TYPE_CHECKINGr*rrrr+rrrTrUrrr rrrrrr rrcastrrrUnicodeDecodeError unicodedata normalizer) rbytes0 param1data param2datar channelModemsgValuessys_datas r getByteszMidiEvent.getBytessJ ??dii6 66 99, ,DLL1,tyy>?@Fyy!5!D!D!5!J!J!LL??*doo.E'X doos3!&'8!9J!%Jdoos3!&'8!9J!%J!J.D= 2AAAjQUQZQZ\_F`dii[)D=  @!$))S1$dii[1#DIIu5#yy'(CDD D= YY- -$))2G !4q!8 9:Kdiioo./H$))S)dii[)yy)D0 0 YY+ %*TYY*Ftyy'(A+C N;;AvveTYY/Hx<  YY* $DIIs|)L'()A  () )A (TYY8 8A ,66%38|# ";DII= IJ JO":.@'1${499-rR>?@@@:' 2 , ;00FF3 *&(+,,  ,s A#O;:(P-;/P*-AR  R c^|jtjk(r|jdk7ryy)a Return a boolean if this is a note-on message and velocity is not zero. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.velocity = 120 >>> me1.isNoteOn() True >>> me1.isNoteOff() False A zero velocity note-on is treated as a note-off: >>> me1.velocity = 0 >>> me1.isNoteOn() False >>> me1.isNoteOff() True A midi event can be neither a note on or a note off. >>> me1.type = midi.ChannelVoiceMessages.PROGRAM_CHANGE >>> me1.isNoteOn() False >>> me1.isNoteOff() False rTF)rrrQrrs r isNoteOnzMidiEvent.isNoteOnCs(: 99,44 4!9Krc|jtjk(ry|jtjk(r|jdk(ryy)a Return a boolean if this should be interpreted as a note-off message, either as a real note-off or as a note-on with zero velocity. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_OFF >>> me1.isNoteOn() False >>> me1.isNoteOff() True >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.velocity = 0 >>> me2.isNoteOn() False >>> me2.isNoteOff() True See :meth:`~music21.midi.MidiEvent.isNoteOn` for more examples. TrF)rrrPrQrrs r isNoteOffzMidiEvent.isNoteOffds>. 99,55 5 YY.66 64==A;Mrc$|jdk(ryy)z Return a boolean if this is a DeltaTime subclass. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.isDeltaTime() True rTF)rrs r isDeltaTimezMidiEvent.isDeltaTimes 99 #rc|jrC|jr3|j|jk(r|j|jk(ryy)a  Returns True if `other` is a MIDI event that specifies a note-off message for this message. That is, this event is a NOTE_ON message, and the other is a NOTE_OFF message for this pitch on this channel. Otherwise returns False >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.velocity = 120 >>> me1.pitch = 60 >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.velocity = 0 >>> me2.pitch = 60 `me2` is a Note off for `me1` because it has velocity 0 and matches pitch. >>> me1.matchedNoteOff(me2) True Now the pitch does not match, so it does not work. >>> me2.pitch = 61 >>> me1.matchedNoteOff(me2) False >>> me2.type = midi.ChannelVoiceMessages.NOTE_OFF >>> me1.matchedNoteOff(me2) False >>> me2.pitch = 60 >>> me1.matchedNoteOff(me2) True Channels must match also: >>> me2.channel = 12 >>> me1.matchedNoteOff(me2) False Note that this method is no longer used in MIDI Parsing because it is inefficient. TF)rrrr)rothers r matchedNoteOffzMidiEvent.matchedNoteOffs<^ ==?u0zzU[[(T\\U]]-Jr)rMidiTrack | NonerMidiEventTypesrrrrreturnrrr)r int | None)rr)rzint | bytes | None)rzint | str | bytes | bool | Nonerr)rh)rz int | floatrrr$r+rr+rr+)rr rr)rrrrOrrrpropertyrrrsetterrrrrrrrrrrrrrr r r s6t*.(2(:(: ! -&-%-- -6."J \\   __     [[   Uvp}J~VIpsKlB: 2rr cZeZdZdZ d dfd Zd fd Zd dZd dZd dZxZ S) ra A :class:`~music21.midi.MidiEvent` subclass that stores the time change (in ticks) since the start or since the last MidiEvent. Pairs of DeltaTime and MidiEvent objects are the basic presentation of temporal data. The `track` argument must be a :class:`~music21.midi.MidiTrack` object. Time values are in integers, representing ticks. The `channel` attribute, inherited from MidiEvent is not used and set to 1 unless overridden (it does not do anything if set and is not written out to MIDI). >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time = 1 >>> dt Changed in v9.7 -- DeltaTime repr no longer lists its channel (to de-emphasize it). Channel defaults to 1. c8t||||d|_y)N)rrr)superrr)rrrr __class__s r rzDeltaTime.__init__s T7; rcpt|}|jdd}|jdk(rd|z}|S)Nz 'DeltaTime', rz(empty) )r rreplacer)rrepr s r rzDeltaTime._reprInternals:g#%kk/2. 99>s"C rcy)z9 Save processing time -- is always False Frrs r rzDeltaTime.isChannelEventsrcDt|\|_}|j|fS)a Read a byte-string until hitting a character below 0x80 and return the converted number and the rest of the bytes. The first number is also stored in `self.time`. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time 0 >>> dt.readUntilLowByte(b'\x20') (32, b'') >>> dt.time 32 >>> dt.readUntilLowByte(b'\x20hello') (32, b'hello') here the '\x82' is above 0x80 so the 'h' is read as part of the continuation. >>> dt.readUntilLowByte(b'\x82hello') (360, b'ello') * Changed in v9: had an incompatible signature with MidiEvent. )rr)roldBytesnewBytess r readUntilLowBytezDeltaTime.readUntilLowBytes$86h? 8yy(""rc0t|j}|S)a Convert the time integer into a set of bytes. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time = 1 >>> dt.getBytes() b'\x01' >>> dt.time = 128 >>> dt.getBytes() b'\x81\x00' >>> dt.time = 257 >>> dt.getBytes() b'\x82\x01' >>> dt.time = 16385 >>> dt.getBytes() b'\x81\x80\x01' )rr)rr$s r rzDeltaTime.getBytess,,DII6 r)Nrr5)rrrrrrrr)rr+rtuple[int, bytes]r) rrrrOrrrrr __classcell__)r s@r rrsH0!%       #>rceZdZdZdZdddZddZeddZddZ dddZ ddZ d Z dd Z dd Zdd Zdd ZddZy)r am A MIDI Track. Each track contains an index and a list of events. All events are stored in the `events` list, in order. An `index` is an integer identifier for this object. It is often called "trackId" though technically the id for a MidiTrack is always b'MTrk' >>> mt = midi.MidiTrack(index=3) >>> mt.events [] >>> mt.index 3 The data consists of all the midi data after b'MTrk' >>> mt.data b'' And the .length is the same as the data's length >>> mt.length 0 After reading a string >>> mt.read(b'MTrk\x00\x00\x00\x16\x00\xff\x03\x00\x00' ... + b'\xe0\x00@\x00\x90CZ\x88\x00\x80C\x00\x88\x00\xff/\x00') b'' The returned value is what is left over after the track is read (for instance the data for another track) >>> mt.length 22 * New in v9.7: len(mt) returns the same as mt.length, but more Pythonic. >>> len(mt) 22 >>> mt.data[:8] b'\x00\xff\x03\x00\x00\xe0\x00@' Note that the '\x16' got translated to ascii '@'. >>> mt.events [, , , , , , , , , ] >>> mt There is a class attribute of the headerId which is the same for all MidiTrack objects >>> midi.MidiTrack.headerId b'MTrk' sMTrkc.||_g|_d|_y)Nr)reventsr)rrs r rzMidiTrack.__init__os ')  rc,t|jS)z * New in v9.7. rrrs r __len__zMidiTrack.__len__ts499~rc,t|jSr"rrs r r%zMidiTrack.lengthzs499~rc|dd|jk(s tdt|ddd\}}|d|}||_||d}|j ||S)a Read as much of the bytes object (representing midi data) as necessary; return the remaining bytes object for reassignment and further processing. The string should begin with `MTrk`, specifying a Midi Track Stores the read data (after the header and length information) in self.data Calls `processDataToEvents` which creates :class:`~music21.midi.DeltaTime` and :class:`~music21.midi.MidiEvent` objects and stores them in self.events Nrjz.badly formed midi string: missing leading MTrk)headerIdr rrprocessDataToEvents)rr$r% trackData remainders r rzMidiTrack.read~sn!} - PQ Q%imQ7 gv&  fg&    +rcZd}d}|rt|}|j|\}}||z}t|}||j|_ |j |}|}|j j||j j||}|ryy#t $r|}YwxYw)zE Populate .events with trackData. Called by .read() rN)r)rrr rrr rr;) rr$rpreviousMidiEventdelta_tdttrackDataCandidate timeCandidate midiEvents r r#zMidiTrack.processDataToEventss,0 d+G%,%=%=i%H "B" 2IM"-I ,+<+K+K ( %NN+=> $ KK  w ' KK  y ) ) 7"! /   s B B*)B*c 8g}|jD]"} |j|j$dj |}|jtt|dz|zS#t$r&}tj d|d|dYd}~d}~wwxYw)a Returns bytes of midi-data from the `.events` in the object. For conversion from music21 to MIDI. For example: two events, one note-on and one note-off on C4 which appears as "<" in the data. >>> mt = midi.MidiTrack(index=2) >>> dt1 = midi.DeltaTime(mt, time=0) >>> noteOn = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.NOTE_ON, channel=3) >>> noteOn.pitch = 60 >>> noteOn.velocity = 20 >>> dt2 = midi.DeltaTime(mt, time=1030) >>> noteOff = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.NOTE_OFF, channel=3) >>> noteOff.pitch = 60 >>> noteOff.velocity = 0 >>> mt.events = [dt1, noteOn, dt2, noteOff] >>> bytes = mt.getBytes() >>> bytes b'MTrk\x00\x00\x00\t\x00\x92<\x14\x88\x06\x82<\x00' Explanation: The first four bytes `MTrk` are the header for any MIDI Track >>> bytes[:4] b'MTrk' The next four bytes are the length of the data in bytes, the final `b'\t'` indicates there are 9 bytes to follow. >>> midi.base.getNumber(bytes[4:8], 4) (9, b'') The next byte is an empty delta time event. >>> bytes[8] 0 The next three bytes are the note-on event. >>> noteOn2 = midi.MidiEvent() >>> _ = noteOn2.parseChannelVoiceMessage(bytes[9:12]) >>> noteOn2 Followed by two bytes for the DeltaTime of 1030 ticks. >>> dt3 = midi.DeltaTime() >>> dt3.readUntilLowByte(bytes[12:14]) (1030, b'') The 1030 is stored as b'\x88\x06' where the first byte is 136 and the second 6, but MIDI stores each continuing digit as the last 7 bits of a 8-bit number with first bit 1, so we remove the first bit by subtracting 128: 136 - 128 = 8. Then we multiply 8 by 128 to get 1024 and add 6 to get 1030. Finally, the last three bytes are the note-off event. >>> noteOff2 = midi.MidiEvent() >>> _ = noteOff2.parseChannelVoiceMessage(bytes[14:]) >>> noteOff2 zConversion error for z: z ; ignored.Nrrj) rr;rr rwarnjoinr"rr)rr$r,ex bytes_outs r rzMidiTrack.getBytessJ"$ I W  !3!3!56%HHY' }}yY;;iGG ! W!!$9)Brd*"UVV WsA** B3BBcP|jdt|jd}|S)Nz -- z events)rrr)rrs r rzMidiTrack._reprInternals'zzl$s4;;/0 8rc4|jD] }||_ y)a We may attach events to this track before setting their `track` parameter. This method will move through all events and set their track to this track. >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> noteOn.pitch = 60 >>> noteOn.velocity = 20 >>> noteOn >>> mt.events = [noteOn] >>> mt.updateEvents() >>> noteOn >>> noteOn.track is mt True N)rrres r updateEventszMidiTrack.updateEventss&AAGrcJ|jD]}|jsyy)a> Return True/False if this track has any note-ons defined. >>> mt = midi.MidiTrack(index=2) >>> mt.hasNotes() False >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> mt.events = [noteOn] >>> mt.hasNotes() True TF)rrr4s r hasNoteszMidiTrack.hasNotes,s#Azz|rcl|tddvrtd||jD] }||_ y)a Set the one-indexed channel of all events in this Track. >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> mt.events = [noteOn] >>> mt.setChannel(11) >>> noteOn.channel 11 Channel must be a value from 1-16 >>> mt.setChannel(22) Traceback (most recent call last): music21.midi.base.MidiException: bad channel value: 22 r5zbad channel value: N)r,r rr)rrr5s r setChannelzMidiTrack.setChannel?s:" a $"5eW => >AAIrct}|jD].}|js|j|j0t |S)a Get all channels used in this Track (sorted) excepting events like DeltaTime or end events where the channel does not matter >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> noteOn2 = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=5) >>> dt = midi.DeltaTime(1000, channel=2) # channel does not matter >>> noteOn3 = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> noteOn4 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE, channel=5) >>> mt.events = [noteOn, noteOn2, dt, noteOn3, noteOn4] >>> mt.getChannels() [5, 14] )setrraddrsortedrrGr5s r getChannelszMidiTrack.getChannelsUsA A!#d|rcg}|jD]e}|jtjk(s!t |j t s<|j |vsK|j|j g|S)a Get all unique program changes used in this Track, in order they appear. >>> mt = midi.MidiTrack(index=2) >>> pc1 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE) >>> pc1.data = 14 >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> pc2 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE) >>> pc2.data = 1 >>> mt.events = [pc1, noteOn, pc2] >>> mt.getProgramChanges() [14, 1] )rrrrTr*rrr;r@s r getProgramChangeszMidiTrack.getProgramChangesks[A.==="1663/d* AFF#   rN)r)rrrr)r)r$r+rrrrrr)rrrr)rz list[int])rrrrOr"rrrr%rr#rrr6r8r;rArCrrr r r )s_BFH  6&*PNH` ,&,,rr cfeZdZdZdZddZdddZddZddZddZ ddZ dd Z dd Z dd Z dd Zy )r a Low-level MIDI file writing, emulating methods from normal Python files. For most users, do not go here, simply use: score = converter.parse('path/to/file/in.mid') midi_out = score.write('midi', fp='path/to/file/out.mid') The `ticksPerQuarterNote` attribute must be set before writing. 1024 is a common value. This object is returned by some properties for directly writing files of midi representations. >>> mf = midi.MidiFile() >>> mf Music21 can read format 0 and format 1, and writes format 1. Format 2 files are not parsable. >>> mf.format 1 After loading or before writing, tracks are stored in this list. >>> mf.tracks [] Most midi files store `ticksPerQuarterNote` and not `ticksPerSecond` >>> mf.ticksPerQuarterNote 10080 >>> mf.ticksPerSecond is None True All MidiFiles have the same `headerId` >>> midi.MidiFile.headerId b'MThd' MThdcfd|_d|_g|_tj|_d|_y)Nr5)fileformattracksrticksPerQuarterticksPerQuarterNoteticksPerSecondrs r rzMidiFile.__init__s-%)  ') (0(@(@ (,rc|dvr td|tjtjt |||_y)z} Open a MIDI file path for reading or writing. For writing to a MIDI file, `attrib` should be "wb". )rbwbz0cannot read or write unless in binary mode, not:N)r rrBinaryIOopenrH)rfilenamers r rRz MidiFile.opens8  % RTZ[ [FF1::tHf'=> rc||_y)a Assign a file-like object, such as those provided by BytesIO, as an open file object. >>> from io import BytesIO >>> fileLikeOpen = BytesIO() >>> mf = midi.MidiFile() >>> mf.openFileLike(fileLikeOpen) >>> mf.close() N)rH)rfileLikes r openFileLikezMidiFile.openFileLikes  rcLt|j}|dk7rdnd}|d|S)Nr5rrz track)rrJ)r lenTracksplurals r rzMidiFile._reprInternals. $ !QBF6(++rcR|jsy|jjy)z! Close the file. N)rHclosers r r[zMidiFile.closesyy  rc|js td|j|jjy)z< Read and parse MIDI data stored in a file. No file is open.N)rHrreadstrrrs r rz MidiFile.reads.yy./ / TYY^^%&rc|dddk(std|ddt|ddd\}}|dk7r tdt|d\}}||_|d vrtd tt|d\}}t|d\}}|d zr2|d z d z }|dz}|dvrtd||dk(rd}||z|_n |dz|_t |D]9}t |} | j|}|jj| ;y)a Read and parse MIDI data as a bytes, putting the data in `.ticksPerQuarterNote` and a list of `MidiTrack` objects in the attribute `.tracks`. The name readstr is a carryover from Python 2. It works on bytes objects, not strings NrjrFz!badly formatted midi bytes, got: rlzbadly formatted midi bytesrh)rr5z cannot handle midi file format: r)ir9)zcannot handle ticks per frame: rdrei) r rrIrMrLr,r rrJr;) rr$r%midiFormatType numTracksdivisionframesPerSecond ticksPerFramer.trks r r^zMidiFile.readstrsN!}'"CIcrNCU VW W&imQ7 Q; <= =$-i$;! $  '"B6( KL L(A6 9' 15) f !)Q% 78O$tOM$44#&Em_$UVV" " "//"AD '/&'8D $ y!AA,C+I KK  s #"rc|js td|j}|jj|y)zN Write MIDI data as a file to the file opened with `.open()`. r]N)rHrwritestrwrite)rwss r rnzMidiFile.writes2yy./ / ]]_ rcn|j}|jD]}||jz}|S)z Generate the MIDI data header and convert the list of MidiTrack objects in self.tracks into MIDI data and return it as bytes. The name `writestr` is a carry-over from Python 2. It works on bytes, not strings. ) writeMThdStrrJr)rr$rks r rmzMidiFile.writestrs6%%' ;;C!CLLN2Irc|j}|dzdk7r td|jtddzt|jdz}|tt |j dz}|t|dz}|S)z Convert the information in self.ticksPerQuarterNote into MIDI data header and return it as bytes. The name `writeMThdStr` is a carry-over from Python 2. It works on bytes, not strings. rarzMCannot write midi bytes unless self.ticksPerQuarterNote is a multiple of 1024rlrjrh)rLr r"rrIrrJ)rrhr$s r rqzMidiFile.writeMThdStr(s++ v ! #_a aMMIaO3i Q6OO  #dkk*:A >>  (A 66 rNrD)rO)rUz t.BinaryIOrrr)r$r+rrr)rrrrOr"rrRrVrr[rr^rnrmrqrrr r r sB&NH- ? , '-$^ rr z list[type] _DOC_ORDER__main__)r$rr%rrztuple[int, int])r$r+r%rrr)r$z bytes | intr%rrztuple[int, bytes | int])r$r+rr)r<rr%rrr+)r7rrr+)rFz Iterable[int]rr+)*rO __future__r__all__collections.abcrrtypingrrmusic21.common.enumsrmusic21rrrr EnvironmentrMusic21Exceptionr rrrrrrrrr rLiteralrProtoM21Objectr rr r rs__annotations__rmainTestrrr rs# $%- &{&&{3  L11     2#j<?~:aH+\ < ,6, ii  P &&P fc cLW&&Wt tw%%tr$Y 8D JD zGr