src/minwii/logfilereader.py

   1 # -*- coding: utf-8 -*-
   2 """
   3 Module de lecture des fichiers de log minwii
   4
   5 $Id$
   6 $URL$
   7 """
   8
   9 from types import StringTypes
  10 from widgets.playingscreen import PlayingScreenBase
  11 from eventutils import EventDispatcher
  12 from events import eventCodes
  13 from synth import Synth
  14 from musicxml import musicXml2Song
  15 import pygame
  16 from backwardsfilereader import BackwardsReader
  17
  18 SUPPORTED_FILE_HEADER = 'ENV winwii log format version : 1.0'
  19
  20 def inplaceread(m) :
  21     def readinplace(self, *args, **kw) :
  22         pos = self.logfile.tell()
  23         self.logfile.seek(0)
  24         ret = m(self, *args, **kw)
  25         self.logfile.seek(pos)
  26         return ret
  27     return readinplace
  28
  29 class LogFileReader(object) :
  30     """
  31     classe utilitaire pour l'accès aux données d'un fichier de log MinWii.
  32     """
  33
  34     def __init__(self, logfile, mode='r') :
  35         """ logfile : chemin d'accès au fichier de log MinWii.
  36             le format supporté est actuellement la version 1.0 uniquement.
  37         """
  38         if isinstance(logfile, StringTypes) :
  39             self.logfile = open(logfile, mode)
  40         else :
  41             self.logfile = logfile
  42
  43         firstline = self.next()
  44         assert firstline == SUPPORTED_FILE_HEADER
  45
  46
  47     @inplaceread
  48     def getSongFile(self) :
  49         "retourne le chemin d'accès au fichier musicxml de la chanson"
  50         for l in self :
  51             if l.startswith('APP chanson :') :
  52                 break
  53         songfile = l.split(':', 1)[1].strip()
  54         return songfile
  55
  56     @inplaceread
  57     def getSoundFontFile(self) :
  58         "retourne le chemin d'accès au fichier de la soundfont (*.sf2)"
  59         for l in self :
  60             if l.startswith('ENV soundfont :') :
  61                 break
  62         soundFontFile = l.split(':', 1)[1].strip()
  63         return soundFontFile
  64
  65     @inplaceread
  66     def getBank(self) :
  67         "retourne le paramètre bank du synthétiseur (entier)"
  68         for l in self :
  69             if l.startswith('APP bank :') :
  70                 break
  71         bank = l.split(':', 1)[1].strip()
  72         return int(bank)
  73
  74     @inplaceread
  75     def getPreset(self) :
  76         "retourne le paramètre preset du synthétiseur (entier)"
  77         for l in self :
  78             if l.startswith('APP preset :') :
  79                 break
  80         preset = l.split(':', 1)[1].strip()
  81         return int(preset)
  82
  83     @inplaceread
  84     def getScreenResolution(self) :
  85         "retourne la résolution écran (tuple de deux entiers)"
  86         for l in self :
  87             if l.startswith('ENV résolution écran :') :
  88                 break
  89         screenResolution = eval(l.split(':', 1)[1].strip())
  90         return screenResolution
  91
  92     @inplaceread
  93     def getMode(self) :
  94         "retourne le niveau de difficulté"
  95         for l in self :
  96             if l.startswith('APP mode :') :
  97                 break
  98
  99         mode = l.split(':', 1)[1].strip()
 100         return mode
 101
 102     @inplaceread
 103     def getFirstEventTicks(self) :
 104         "retourne le timecode du premier événement (entier)"
 105         for l in self :
 106             if l.startswith('EVT ') :
 107                 break
 108         firstTicks = int(l.split(None, 2)[1])
 109         return firstTicks
 110
 111     @inplaceread
 112     def getLastEventTicks(self) :
 113         "retourne le timecode du dernier événement (entier)"
 114         for l in self.getBackwardLineIterator() :
 115             if l.startswith('EVT ') :
 116                 break
 117         else :
 118             return None
 119
 120         lastTicks = int(l.split(None, 2)[1])
 121         return lastTicks
 122
 123     def __del__(self) :
 124         self.close()
 125
 126     def __iter__(self) :
 127         return self
 128
 129     def next(self) :
 130         line = self.logfile.next().strip()
 131         return line
 132
 133     def getEventsIterator(self) :
 134         """ Retourne un itérateur sur les événements.
 135             Chaque itération retourne un tuple de 3 éléments :
 136             (timecode, nom_événement, données) avec le typage :
 137             (entier,   chaîne,        chaîne)
 138         """
 139         self.logfile.seek(0)
 140         while True :
 141             try :
 142                 l = self.next()
 143             except StopIteration :
 144                 break
 145
 146             if not l.startswith('EVT ') :
 147                 continue
 148             try :
 149                 ticks, eventName, message = l.split(None, 3)[1:]
 150                 ticks = int(ticks)
 151                 yield ticks, eventName, message
 152             except ValueError :
 153                 ticks, eventName = l.split(None, 3)[1:]
 154                 ticks = int(ticks)
 155                 yield ticks, eventName, ''
 156
 157     def getBackwardLineIterator(self) :
 158         br = BackwardsReader(self.logfile, BLKSIZE=128)
 159         line = br.readline()
 160         while line :
 161             yield line.strip()
 162             line = br.readline()
 163
 164     @inplaceread
 165     def getMetadata(self) :
 166         metadata = {}
 167         self.next() # skip identification line.
 168         line = self.next()
 169         while line.startswith('METADATA ') :
 170             line = line.split(None, 1)[1]
 171             name, value = [v.strip() for v in line.split(':', 1)]
 172             metadata[name] = value
 173             line = self.next()
 174         return metadata
 175
 176     def setMetadata(self, metadata) :
 177         f = self.logfile
 178         f.seek(0)
 179         before = f.readline()
 180         after = f.read()
 181
 182         lines = []
 183         for name, value in metadata :
 184             lines.append('METADATA %s : %s' % (name, value.encode('utf-8')))
 185         metadata = '\n'.join(lines)
 186         f.seek(0)
 187         f.write(before)
 188         f.write(metadata)
 189         f.write(after)
 190
 191     def close(self) :
 192         self.logfile.close()
 193
 194
 195
 196 class LogFilePlayer(PlayingScreenBase) :
 197     """
 198     ré-exécution d'une chanson sur la base de son fichier de log.
 199     """
 200
 201     def __init__(self, logfile) :
 202         lfr = self.lfr = LogFileReader(logfile)
 203         songFile = lfr.getSongFile()
 204         soundFontFile = lfr.getSoundFontFile()
 205         sfPath = lfr.getSoundFontFile()
 206         bank = lfr.getBank()
 207         preset = lfr.getPreset()
 208         synth = Synth(sfPath=sfPath)
 209         synth.program_select(0, bank, preset)
 210         self.song = musicXml2Song(songFile)
 211         screenResolution = lfr.getScreenResolution()
 212
 213         pygame.display.set_mode(screenResolution)
 214
 215         super(LogFilePlayer, self).__init__(synth, self.song.distinctNotes)
 216
 217     def run(self):
 218         self._running = True
 219         clock = pygame.time.Clock()
 220         pygame.display.flip()
 221         pygame.mouse.set_visible(False)
 222
 223         previousTicks = self.lfr.getFirstEventTicks()
 224         eIter = self.lfr.getEventsIterator()
 225
 226         for ticks, eventName, message in eIter :
 227             t0 = pygame.time.get_ticks()
 228             if eventName == 'COLSTATECHANGE' :
 229                 parts = message.split(None, 4)
 230                 if len(parts) == 4 :
 231                     parts.append('')
 232                 index, state, midi, name, syllabus = parts
 233                 index = int(index)
 234                 midi = int(midi)
 235                 state = state == 'True'
 236                 col = self.columns[midi]
 237                 col.update(state, syllabus=syllabus.decode('utf-8'))
 238
 239             elif eventName == 'NOTEON':
 240                 chan, key, vel = [int(v) for v in message.split(None, 2)]
 241                 self.synth.noteon(chan, key, vel)
 242
 243             elif eventName == 'NOTEOFF':
 244                 chan, key = [int(v) for v in message.split(None, 1)]
 245                 self.synth.noteoff(chan, key)
 246
 247             elif eventName.startswith('COL') :
 248                 pos = [int(n) for n in message.split(None, 4)[-1].strip('()').split(',')]
 249                 self.cursor.setPosition(pos)
 250
 251
 252             pygame.event.clear()
 253
 254             dirty = self.draw(pygame.display.get_surface())
 255             pygame.display.update(dirty)
 256             execTime = pygame.time.get_ticks() - t0
 257
 258             delay = ticks - previousTicks - execTime
 259             if delay > 0 :
 260                 pygame.time.wait(delay)
 261
 262             previousTicks = ticks
 263
 264         self.stop()
 265