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) :
  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, 'r')
  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.logfile.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
 165
 166 class LogFilePlayer(PlayingScreenBase) :
 167     """
 168     ré-exécution d'une chanson sur la base de son fichier de log.
 169     """
 170
 171     def __init__(self, logfile) :
 172         lfr = self.lfr = LogFileReader(logfile)
 173         songFile = lfr.getSongFile()
 174         soundFontFile = lfr.getSoundFontFile()
 175         sfPath = lfr.getSoundFontFile()
 176         bank = lfr.getBank()
 177         preset = lfr.getPreset()
 178         synth = Synth(sfPath=sfPath)
 179         synth.program_select(0, bank, preset)
 180         self.song = musicXml2Song(songFile)
 181         screenResolution = lfr.getScreenResolution()
 182
 183         pygame.display.set_mode(screenResolution)
 184
 185         super(LogFilePlayer, self).__init__(synth, self.song.distinctNotes)
 186
 187     def run(self):
 188         self._running = True
 189         clock = pygame.time.Clock()
 190         pygame.display.flip()
 191         pygame.mouse.set_visible(False)
 192
 193         previousTicks = self.lfr.getFirstEventTicks()
 194         eIter = self.lfr.getEventsIterator()
 195
 196         for ticks, eventName, message in eIter :
 197             t0 = pygame.time.get_ticks()
 198             if eventName == 'COLSTATECHANGE' :
 199                 parts = message.split(None, 4)
 200                 if len(parts) == 4 :
 201                     parts.append('')
 202                 index, state, midi, name, syllabus = parts
 203                 index = int(index)
 204                 midi = int(midi)
 205                 state = state == 'True'
 206                 col = self.columns[midi]
 207                 col.update(state, syllabus=syllabus.decode('utf-8'))
 208
 209             elif eventName == 'NOTEON':
 210                 chan, key, vel = [int(v) for v in message.split(None, 2)]
 211                 self.synth.noteon(chan, key, vel)
 212
 213             elif eventName == 'NOTEOFF':
 214                 chan, key = [int(v) for v in message.split(None, 1)]
 215                 self.synth.noteoff(chan, key)
 216
 217             elif eventName.startswith('COL') :
 218                 pos = [int(n) for n in message.split(None, 4)[-1].strip('()').split(',')]
 219                 self.cursor.setPosition(pos)
 220
 221
 222             pygame.event.clear()
 223
 224             dirty = self.draw(pygame.display.get_surface())
 225             pygame.display.update(dirty)
 226             execTime = pygame.time.get_ticks() - t0
 227
 228             delay = ticks - previousTicks - execTime
 229             if delay > 0 :
 230                 pygame.time.wait(delay)
 231
 232             previousTicks = ticks
 233
 234         self.stop()
 235
 236