Lines Matching full:self
193 def __init__ (self, track, channel, name, empty):
194 self.track = track
195 self.channel = channel
196 self.name = name
197 self.empty = empty
198 def __str__ (self):
199 return "['%s', '%s', '%s']" % (self.track, self.channel, self.name)
206 def __init__ (self, stream, msg):
208 self.stream = stream
209 self.msg = msg
210 def __str__ (self):
211 return '[%d]: %s' % (self.stream.error_loc, self.msg)
217 def __init__ (self, ppqn=DEFAULT_PPQN, beats_per_measure=DEFAULT_BEATS_PER_MEASURE):
218 self.ppqn = ppqn
219 self.beats_per_measure = beats_per_measure
221 def ConvertToTicks (self, measures, beats, ticks):
222 total_beats = beats + (measures * self.beats_per_measure)
223 total_ticks = ticks + (total_beats * self.ppqn)
226 def ConvertTicksToMBT (self, ticks):
227 beats = ticks / self.ppqn
228 ticks -= beats * self.ppqn
229 measures = beats / self.beats_per_measure
230 beats -= measures * self.beats_per_measure
233 def ConvertTicksToStr (self, ticks, format=DEFAULT_TIME_FORMAT):
234 measures, beats, ticks = self.ConvertTicksToMBT(ticks)
237 def ConvertStrTimeToTuple(self, s):
244 def ConvertStrTimeToTicks(self, s):
245 measures, beats, ticks = self.ConvertStrTimeToTuple(s)
246 return self.ConvertToTicks(measures, beats, ticks)
248 def MbtDifference(self, mbt1, mbt2):
249 t1 = self.ConvertToTicks(mbt1[0], mbt1[1], mbt1[2])
250 t2 = self.ConvertToTicks(mbt2[0], mbt2[1], mbt2[2])
301 def __init__ (self, events, exclude=True):
302 self.events = events
303 self.exclude = exclude
304 def Check (self, event):
305 if event.msg_type in self.events:
306 return not self.exclude
307 return self.exclude
310 def __init__ (self, notes, exclude=True):
311 self.notes = notes
312 self.exclude = exclude
313 def Check (self, event):
315 if event.note in self.notes:
316 return not self.exclude
317 return self.exclude
320 def __init__ (self, channel, exclude=True):
321 self.channel = channel
322 self.exclude = exclude
323 def Check (self, event):
325 if event.channel in self.channel:
326 return not self.exclude
327 return self.exclude
360 def WriteTicks (self, stream, track):
361 WriteVarLenQty(stream, self.ticks - track.ticks)
362 track.ticks = self.ticks
363 def WriteRunningStatus (self, stream, track, filters, msg, data1, data2=None):
364 if not self.CheckFilters(filters):
366 self.WriteTicks(stream, track)
367 status = msg + self.channel
374 def CheckFilters (self, filters):
379 if (self.msg_type == META_EVENT) and (self.meta_type == META_EVENT_END_OF_TRACK):
384 if not f.Check(self):
388 def TimeEventStr (self, timebase):
389 return '[%s]: %s' % (timebase.ConvertTicksToStr(self.ticks), self.__str__())
395 def __init__ (self, ticks, seq, channel, note, velocity):
396 self.name = 'NoteOff'
397 self.msg_type = NOTE_OFF
398 self.seq = seq
399 self.ticks = ticks
400 self.channel = channel
401 self.note = note
402 self.velocity = velocity
413 def WriteToStream (self, stream, track, filters=None):
415 if self.velocity > 0:
416 self.WriteRunningStatus(stream, track, filters, NOTE_ON, self.note, self.velocity)
417 if track.running_status == (NOTE_OFF + self.channel):
418 self.WriteRunningStatus(stream, track, filters, NOTE_ON, self.note, self.velocity)
420 self.WriteRunningStatus(stream, track, filters, NOTE_ON, self.note, 0)
421 def __str__ (self):
422 return '%s: ch=%d n=%d v=%d' % (self.name, self.channel, self.note, self.velocity)
428 def __init__ (self, ticks, seq, channel, note, velocity, note_length, note_off_velocity):
429 self.name = 'NoteOn'
430 self.msg_type = NOTE_ON
431 self.ticks = ticks
432 self.seq = seq
433 self.channel = channel
434 self.note = note
435 self.velocity = velocity
436 self.note_length = note_length
437 self.note_off_velocity = note_off_velocity
449 def WriteToStream (self, stream, track, filters=None):
450 self.WriteRunningStatus(stream, track, filters, NOTE_ON, self.note, self.velocity)
451 def __str__ (self):
452 if self.note_length is not None:
453 return '%s: ch=%d n=%d v=%d l=%d' % (self.name, self.channel, self.note, self.velocity, self.note_length)
455 return '%s: ch=%d n=%d v=%d' % (self.name, self.channel, self.note, self.velocity)
461 def __init__ (self, ticks, seq, channel, note, value):
462 self.name = 'PolyKeyPressure'
463 self.msg_type = POLY_KEY_PRESSURE
464 self.ticks = ticks
465 self.seq = seq
466 self.channel = channel
467 self.note = note
468 self.value = value
478 def WriteToStream (self, stream, track, filters=None):
479 self.WriteRunningStatus(stream, track, filters, POLY_KEY_PRESSURE, self.note, self.value)
480 def __str__ (self):
481 return '%s: ch=%d n=%d v=%d' % (self.name, self.channel, self.note, self.value)
487 def __init__ (self, ticks, seq, channel, controller, value):
488 self.name = 'ControlChange'
489 self.msg_type = CONTROL_CHANGE
490 self.ticks = ticks
491 self.seq = seq
492 self.channel = channel
493 self.controller = controller
494 self.value = value
506 def WriteToStream (self, stream, track, filters=None):
507 self.WriteRunningStatus(stream, track, filters, CONTROL_CHANGE, self.controller, self.value)
508 def __str__ (self):
509 return '%s: ch=%d c=%d v=%d' % (self.name, self.channel, self.controller, self.value)
515 def __init__ (self, ticks, seq, channel, controller, value):
516 self.name = 'ChannelMode'
517 self.msg_type = CONTROL_CHANGE
518 self.ticks = ticks
519 self.seq = seq
520 self.channel = channel
521 self.controller = controller
522 self.value = value
534 def WriteToStream (self, stream, track, filters=None):
535 self.WriteRunningStatus(stream, track, filters, CONTROL_CHANGE, self.controller, self.value)
536 def __str__ (self):
537 return '%s: ch=%d c=%d v=%d' % (self.name, self.channel, self.controller, self.value)
543 def __init__ (self, ticks, seq, channel, program):
544 self.name = 'ProgramChange'
545 self.msg_type = PROGRAM_CHANGE
546 self.ticks = ticks
547 self.seq = seq
548 self.channel = channel
549 self.program = program
558 def WriteToStream (self, stream, track, filters=None):
559 self.WriteRunningStatus(stream, track, filters, PROGRAM_CHANGE, self.program)
560 def __str__ (self):
561 return '%s: ch=%d p=%d' % (self.name, self.channel, self.program)
567 def __init__ (self, ticks, seq, channel, value):
568 self.name = 'ChannelPressure'
569 self.msg_type = CHANNEL_PRESSURE
570 self.ticks = ticks
571 self.seq = seq
572 self.channel = channel
573 self.value = value
582 def WriteToStream (self, stream, track, filters=None):
583 self.WriteRunningStatus(stream, track, filters, CHANNEL_PRESSURE, self.value)
584 def __str__ (self):
585 return '%s: ch=%d v=%d' % (self.name, self.channel, self.value)
591 def __init__ (self, ticks, seq, channel, value):
592 self.name = 'PitchBend'
593 self.msg_type = PITCH_BEND
594 self.ticks = ticks
595 self.seq = seq
596 self.channel = channel
597 self.value = value
606 def WriteToStream (self, stream, track, filters=None):
607 value = self.value + 0x2000
612 self.WriteRunningStatus(stream, track, filters, PITCH_BEND, value >> 7, value & 0x7f)
613 def __str__ (self):
614 return '%s: ch=%d v=%d' % (self.name, self.channel, self.value)
620 def __init__ (self, ticks, seq, msg):
621 self.name = 'SysEx'
622 self.msg_type = SYSEX
623 self.ticks = ticks
624 self.seq = seq
625 self.length = len(msg)
626 self.msg = msg
636 def WriteToStream (self, stream, track, filters=None):
637 if not self.CheckFilters(filters):
639 self.WriteTicks(stream, track)
641 WriteVarLenQty(stream, self.length)
642 WriteBytes(stream, self.msg)
644 def __str__ (self):
645 fmt_str = '%s: f0' + ' %02x'*self.length
646 return fmt_str % ((self.name,) + tuple(self.msg))
652 def __init__ (self, ticks, seq, msg):
653 self.name = 'SysEx+'
654 self.msg_type = END_SYSEX
655 self.ticks = ticks
656 self.seq = seq
657 self.length = len(msg)
658 self.msg = msg
668 def WriteToStream (self, stream, track, filters=None):
669 if not self.CheckFilters(filters):
671 self.WriteTicks(stream, track)
673 WriteVarLenQty(stream, self.length)
674 WriteBytes(stream, self.msg)
676 def __str__ (self):
677 fmt_str = '%s:' + ' %02x'*self.length
678 return fmt_str % ((self.name,) + tuple(self.msg))
684 def __init__ (self, ticks, seq, meta_type, msg):
685 self.name = 'MetaEvent'
686 self.msg_type = META_EVENT
687 self.ticks = ticks
688 self.seq = seq
689 self.meta_type = meta_type
690 self.length = len(msg)
691 self.msg = msg
703 def WriteToStream (self, stream, track, filters=None):
704 if not self.CheckFilters(filters):
706 self.WriteTicks(stream, track)
708 WriteByte(stream, self.meta_type)
709 WriteVarLenQty(stream, self.length)
710 WriteBytes(stream, self.msg)
712 def __str__ (self):
713 fmt_str = '%s: %02x' + ' %02x'*self.length
714 return fmt_str % ((self.name, self.meta_type) + tuple(self.msg))
720 def __init__ (self):
721 self.controllers = []
722 self.rpns = []
724 self.controllers.append({})
725 self.controllers[channel] = copy.deepcopy(DEFAULT_CONTROLLER_VALUES)
726 self.rpns.append({})
727 self.rpns[channel] = copy.deepcopy(DEFAULT_RPN_VALUES)
728 self.pitchbend = [0] * 16
729 self.program = [-1] * 16
730 self.pressure = [0] * 16
732 def __str__ (self):
736 output.append(' program=%d' % self.program[channel])
737 output.append(' pressure=%d' % self.pressure[channel])
740 for controller in self.controllers[channel].keys():
741 output.append(' %03d: %03d' % (controller, self.controllers[channel][controller]))
744 for rpn in self.rpns[channel].keys():
745 output.append(' %05d: %05d>' % (controller, self.rpns[channel][rpn]))
749 def Event (self, event):
753 self.ControlChange(event)
755 self.PressureChange(event)
757 self.ProgramChange(event)
759 self.PitchBendChange(event)
761 def PitchBendChange (self, event):
763 self.pitchbend[event.channel] = event.value
765 def ProgramChange (self, event):
767 self.program[event.channel] = event.program
769 def ControlChange (self, event):
774 self.controllers[channel][controller] = event.value
776 rpn = (self.controllers[channel][CTRL_RPN_MSB] << 7) + self.controllers[channel][CTRL_RPN_LSB]
778 value = (self.controllers[channel][CTRL_RPN_DATA_MSB] << 7) + self.controllers[channel][CTRL_RPN_DATA_LSB]
779 self.rpns[channel][rpn] = value
783 self.ResetControllers[event.channel]
785 def PressureChange (self, event):
787 self.pressure[event.channel] = event.value
789 def ResetControllers (self, channel):
791 self.controllers[channel] = DEFAULT_CONTROLLER_VALUES
792 self.rpns[channel] = DEFAULT_RPN_VALUES
793 self.pressure[channel] = 0
795 def GenerateEventList (self, ticks, ref_values=None):
807 for rpn in self.rpns[channel].keys():
808 value = self.rpns[channel][rpn]
816 for controller in self.controllers[channel].keys():
817 if self.controllers[channel][controller] != ref_values.controllers[channel][controller]:
818 events.append(ControlChangeEvent(ticks, -1, channel, controller, self.controllers[channel][controller]))
821 if self.pressure[channel] != ref_values.pressure[channel]:
822 events.append(ChannelPressureEvent(ticks, -1, channel, self.pressure[channel]))
825 if self.program[channel] != ref_values.program[channel]:
826 if self.program[channel] in range(128):
827 events.append(ProgramChangeEvent(ticks, -1, channel, self.program[channel]))
830 if self.pitchbend[channel] != ref_values.pitchbend[channel]:
831 if self.pitchbend[channel] in range(-8192,8191):
832 events.append(PitchBendEvent(ticks, -1, channel, self.pitchbend[channel]))
840 def __init__ (self):
841 list.__init__(self)
843 def FixNoteLengths (self):
847 for index in range(len(self)):
848 event = self[index]
853 for i in range(index + 1, len(self)):
854 event_to_check = self[i]
864 def ChaseControllers (self, end_seq, start_seq = 0, values = None):
872 for i in range(start_seq, min(end_seq, len(self))):
873 values.Event(self[i])
878 def SelectEvents (self, start, end):
881 for event in self:
889 def MergeEvents (self, events):
891 self.extend(events)
892 self.SortEvents()
894 def InsertEvents (self, events, seq):
895 self[seq:seq] = events
896 self.RenumberSeq()
898 def DeleteEvents (self, start_index, end_index, move_meta_events=None):
903 end_index = len(self)
906 #for evt in self[start_index:end_index]:
912 for event in self[start_index:end_index]:
920 self.remove(event)
932 def SeekEvent (self, pos):
933 for i in range(len(self)):
934 if self[i].ticks >= pos:
938 def RenumberSeq (self):
940 for event in self:
944 def SortEvents (self):
945 self.sort(self.EventSorter)
946 self.RenumberSeq()
955 def DumpEvents (self, output, timebase):
957 for event in self:
960 for event in self:
971 def __init__ (self):
972 self.length = 0
973 self.events = EventList()
974 self.end_of_track = None
975 self.channel = None
976 self.name = None
978 def ReadFromStream (self, stream, offset, file_size):
979 self.stream = stream
992 self.start = stream.tell()
995 if (self.start + track_len) > file_size:
1008 self.start) >= track_len:
1012 if self.end_of_track:
1041 if self.channel == None:
1043 self.channel = event.channel
1062 self.events.remove(note_on)
1081 self.end_of_track = event.ticks
1085 self.name = array.array('B', event.msg).tostring()
1089 self.events.append(event)
1106 if self.end_of_track is None:
1107 self.last_tick = self.events[-1].ticks
1116 def Write (self, stream, filters=None):
1122 save_events = copy.copy(self.events)
1127 if index >= len(self.events):
1131 event = self.events[index]
1137 for i in range(index, len(self.events)):
1138 if self.events[i].ticks >= note_off.ticks:
1139 self.events.insert(i, note_off)
1142 self.events.append(note_off)
1145 self.events.RenumberSeq()
1148 self.running_status = None
1149 self.ticks = 0
1150 for event in self.events:
1153 event.WriteToStream(stream, self, filters)
1156 self.events = save_events
1159 MetaEvent(self.end_of_track, 0, META_EVENT_END_OF_TRACK,[]).WriteToStream(stream, self, None)
1169 def Trim (self, start, end, slide=True, chase_controllers=True, delete_meta_events=False, quantize=0):
1174 for event in self.events.SelectEvents(start - quantize, start):
1179 for event in self.events.SelectEvents(end - quantize, end):
1187 start_event = self.events.SeekEvent(start)
1192 controllers = self.events.ChaseControllers(self.events[start_event].seq)
1195 controller_events.DumpEvents(None, self.stream.timebase)
1196 self.events.InsertEvents(controller_events, start_event)
1201 self.events.DeleteEvents(None, start_event, None)
1203 self.events.DeleteEvents(None, start_event, start)
1207 self.events.DeleteEvents(None, None, start)
1210 end_event = self.events.SeekEvent(end)
1213 self.events.DeleteEvents(end_event, None)
1216 for event in self.events:
1219 midi_file_logger.debug('Trim: trimming note that extends past end %s' % event.TimeEventStr(self.stream.timebase))
1224 midi_file_logger.debug('Trim: initial end-of-track: %d' % self.end_of_track)
1225 self.end_of_track = min(self.end_of_track, end)
1230 for event in self.events:
1235 self.end_of_track = max(0, self.end_of_track - start)
1236 midi_file_logger.debug('Trim: new end-of-track: %d' % self.end_of_track)
1238 self.events.RenumberSeq()
1239 self.events.FixNoteLengths()
1241 def DumpEvents (self, output):
1242 self.events.DumpEvents(output, self.stream.timebase)
1244 output.write('[%s]: end-of-track\n' % self.stream.timebase.ConvertTicksToStr(self.end_of_track))
1246 midi_file_logger.debug('[%s]: end-of-track' % self.stream.timebase.ConvertTicksToStr(self.end_of_track))
1257 def __init__ (self, name, mode):
1258 file.__init__(self, name, mode)
1259 self.timebase = TimeBase()
1261 def ReadFromStream (self, start_offset=0, file_size=None):
1269 self.start_offset = start_offset
1270 self.seek(0,2)
1271 file_size = self.tell() - self.start_offset
1272 self.seek(start_offset,0)
1277 self.last_good_event = None
1278 self.error_loc = None
1281 bytes = self.read(struct.calcsize(SMF_HEADER_FMT))
1282 riff_tag, self.hdr_len, self.format, self.num_tracks, self.timebase.ppqn = struct.unpack(SMF_HEADER_FMT, bytes)
1284 (riff_tag, self.hdr_len, self.format, self.num_tracks, self.timebase.ppqn))
1287 if (riff_tag != SMF_RIFF_TAG) or (self.format not in range(2)):
1288 raise MIDIFileException(self, MSG_NOT_SMF_FILE)
1291 if self.hdr_len + 8 != struct.calcsize(SMF_HEADER_FMT):
1292 self.Warning('SMF file has unusual header size: %d bytes' % self.hdr_len)
1295 offset = start_offset + self.hdr_len + 8
1296 self.tracks = []
1297 self.end_of_file = 0
1298 for i in range(self.num_tracks):
1303 length = track.ReadFromStream(self, offset, file_size)
1306 self.tracks.append(track)
1312 self.end_of_file = max(self.end_of_file, track.end_of_track)
1316 self.Warning('SMF file size is incorrect - should be %d, was %d' % (file_size, offset))
1318 def Save (self, offset=0, filters=None):
1320 if (not 'w' in self.mode) and (not '+' in self.mode):
1321 raise MIDIFileException(self, 'Cannot write to file in read-only mode')
1322 self.Write(self, offset, filters)
1324 def SaveAs (self, filename, offset=0, filters=None):
1327 self.Write(output_file, offset, filters)
1330 def Write (self, output_file, offset=0, filters=None):
1334 bytes = struct.pack(SMF_HEADER_FMT, SMF_RIFF_TAG, struct.calcsize(SMF_HEADER_FMT) - 8, self.format, self.num_tracks, self.timebase.ppqn)
1338 for track in self.tracks:
1344 def ConvertToType0 (self):
1346 if self.format == 0:
1351 for track in self.tracks[1:]:
1352 self.tracks[0].MergeEvents(track.events)
1353 self.tracks = self.tracks[:1]
1354 self.num_tracks = 1
1355 self.format = 0
1357 def DeleteEmptyTracks (self):
1360 for track in self.tracks[:]:
1361 for event in self.tracks.events:
1366 self.tracks.remove(track)
1369 def ConvertToTicks (self, measures, beats, ticks):
1370 return self.timebase.ConvertToTicks(measures, beats, ticks)
1372 def Trim (self, start, end, quantize=0, chase_controllers=True):
1374 for track in self.tracks:
1379 def DumpTracks (self, output=None):
1381 for track in self.tracks:
1389 def Warning (self, msg):
1390 midi_file_logger.warning('[%d]: %s' % (self.tell(), msg))
1392 def Error (self, msg):
1393 midi_file_logger.error('[%d]: %s' % (self.tell(), msg))
1395 def DumpError (self):
1396 if self.last_good_event:
1398 pos = self.last_good_event - 16
1399 length = self.error_loc - pos + 16
1400 elif self.error_loc:
1402 pos = self.error_loc
1408 self.seek(pos, 0)
1414 byte = self.read(1)
1425 def __init__ (self):
1426 self.err = 1
1427 self.endMbt = "0:0:0"
1428 self.totalTicks = 0
1429 self.maxTracks = 0
1430 self.maxMeasures = 0
1431 self.maxBeats = 0
1432 self.maxTicks = 0
1433 self.totalTicks = 0
1434 self.timebase = None
1435 self.ppqn = 0
1436 self.beats_per_measure = 0
1437 self.trackList = []
