Example #1
0
 def _event_handler(self):
     piano_events = midi.midis2events(self.midiObject.read(BUFFER),1)    # .read(buffer size)
     for event in pygame.event.get():
         if event.type == pygame.QUIT:
             pygame.quit(); sys.exit();
         elif event.type == pygame.VIDEORESIZE:
             self._resize_surface(event.size)
         #Need to see if i can figure out how to use keyup and keydown to make it more readable
         '''elif event.type == pygame.locals.KEYUP:
             print('Key is up.')
         elif event.type == pygame.locals.KEYDOWN:
             print('Key is up.')'''
     self._handle_piano_events(piano_events)
     self._draw()
Example #2
0
    def process_events(self):
        if self._midin.poll():
            rawevents = self._midin.read(10)
            mevents = midi.midis2events(rawevents, self.midiin_id)
            for mevent in mevents:
                pg.fastevent.post(mevent)

        for event in pg.fastevent.get():
            if event.type == midi.MIDIIN:
                print(event)
                if event.data1 == self.note:
                    self.quick_play()
                    self.next_note()
            if event.type == pg.QUIT:
                raise WantQuit()
Example #3
0
    def start_loop(self):
        """Running two separate loops: an application loop and a midi loop
        **  is this okay?
        """
        running = True

        while running:
            events = pygame.event.get()
            for e in events:
                # quit from menu only -- add keystrokes to this
                if e.type in [KEYDOWN, QUIT]:
                    running = False

            if self.midi_in.poll():
                event = self.midi_in.read(10)
                msg = midi.midis2events(event, self.midi_in.device_id)
                
                self.receive_midi_msg(msg)
Example #4
0
def get_default_midi_val(prompt, decks):
    print prompt
    key_entered, midi_entered = False, False
    while not key_entered or not midi_entered:
        events = pyfastevent.get()
        for e in events:
            if e.type == pygame.KEYDOWN:
                if (e.key == pygame.K_RETURN) and (midi_entered == True):
                    key_entered = True
            if e.type == pymidi.MIDIIN:
                val = e.data2
                midi_entered = True
        if decks.poll():
            midi_events = decks.read(1)
            events = pymidi.midis2events(midi_events, decks.device_id)
            for e in events:
                pyfastevent.post(e)
    return val
Example #5
0
    def onRecord(self, e):
        """"""
        if self.recordButton.GetLabel() == "&Stop":
            self.recordButton.SetLabel("&Record")
            self.recordButton.Disable()
            self.going = False
            self.makeSong()
        else:
            if self.recordButton.GetLabel() == "&Record":
                self.recordButton.SetLabel("&Stop")
            midiIn = Input(midi.get_default_input_id())

            self.processKey()

            self.write("Getting input from:")
            self.write(midi.get_device_info(midi.get_default_input_id()))

            event_get = pygame.fastevent.get
            event_post = pygame.fastevent.post
            self.going = True
            startTime = time.time()
            try:
                while self.going and (time.time() - startTime) <= 20:
                    events = event_get()
                    for e in events:
                        if e.type in [QUIT]:
                            self.going = False
                    if midiIn.poll():
                        midiEvents = midiIn.read(10)
                        #                        self.write( midiEvents)
                        for m in midiEvents:
                            if m[0][1] > 0 and m[0][2] > 0:
                                self.write("Read note:" + str(self.notes[(m[0][1] + 3) % 12]))
                                self.tune.append(m[0][1])
                        midiEvs = midi.midis2events(midiEvents, midiIn.device_id)
                        for mE in midiEvs:
                            #                            self.write( "mE = ", mE)
                            event_post(mE)
            finally:
                del midiIn
                midi.quit()
Example #6
0
              x = blackxs[i]
              window.fill(rainbow(h / k1), (x, 263, 7, 53))
              window.fill(rainbow(h * note[j]['dur'] / k2), (x, 383, 7, 53))
              window.fill(rainbow(note[j]['dvol'] / k3), (x, 503, 7, 53))
          window.blit(blackshadow, (9, 261))
          window.blit(blackshadow, (9, 381))
          window.blit(blackshadow, (9, 501))
          if e.status < 144 or (e.status > 143 and e.data2 == 0):
            note[id]['vol'] = 0
          for id in range (21, 109):
            if note[id]['vol']:
              if id in whiteids:
                x = 15 * whiteids.index(id) + 11
                window.blit(wglow, (x, 320))
                window.blit(wglow, (x, 440))
                window.blit(wglow, (x, 560))
              else:
                x = blackxs[blackids.index(id)]
                window.blit(bglow, (x, 287))
                window.blit(bglow, (x, 407))
                window.blit(bglow, (x, 527))
          pg.display.flip()
    if idev.poll():
      midi_events = idev.read(10)
      # convert them into pg events.
      midi_evs = midi.midis2events(midi_events, idev.device_id)
      for m_e in midi_evs:
        pg.event.post(m_e)
del idev
midi.quit()
Example #7
0
    def run(self):

        self.playing_t = 0

        running = True
        last_t = pg.time.get_ticks()

        self.on = 0
        self.off = 0
        self.video_mute = False

        paint_t = 0
        pausing = False
        while running:
            self.t = pg.time.get_ticks()
            delta_t = self.t - last_t
            self.roll_tick += delta_t
            if not pausing:
                self.playing_t += delta_t
            paint_t += delta_t
            last_t = self.t

            if self.midi_in.poll():
                midi_events = self.midi_in.read(10)
                # convert them into pygame events.
                midi_evs = pgm.midis2events(midi_events,
                                            self.midi_in.device_id)

                for m_e in midi_evs:
                    self.event_post(m_e)

            if self.recorder.is_playing:
                while True:
                    ev = self.recorder.next_event(self.playing_t)
                    if not ev:
                        if not self.recorder.is_playing:
                            self.reset_midi_out()
                        break
                    self.midi_out.write([[[ev.status, ev.data1, ev.data2], 0]])
                    self.event_post(ev)

            # Did the user click the window close button?
            for event in self.event_get():
                # pprint(event)
                if event.type == pg.QUIT:
                    running = False
                elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
                    running = False
                elif event.type == pg.KEYDOWN and event.key == pg.K_F1:
                    self.video_mute = not self.video_mute
                elif event.type == pg.KEYDOWN and event.key == pg.K_r and not self.recorder.is_playing:
                    if self.recorder.is_recording:
                        self.recorder.stop_recording()
                    else:
                        self.recorder.start_recording()
                elif event.type == pg.KEYDOWN and event.key == pg.K_LEFT and not self.recorder.is_recording:
                    self.playing_t -= 1000

                    self.reset_midi_out()
                    self.recorder.start_playing(self.playing_t)
                elif event.type == pg.KEYDOWN and event.key == pg.K_RIGHT and not self.recorder.is_recording:
                    self.playing_t += 1000

                    self.reset_midi_out()
                    self.recorder.start_playing(self.playing_t)
                elif event.type == pg.KEYDOWN and event.key == pg.K_RETURN and self.recorder.is_playing:
                    pausing = not pausing
                elif event.type == pg.KEYDOWN and event.key == pg.K_SPACE and not self.recorder.is_recording:
                    self.reset_midi_out()
                    if self.recorder.is_playing:
                        self.recorder.stop_playing()
                    else:
                        self.playing_t = 0
                        self.recorder.start_playing(self.playing_t)
                elif event.type == pg.MOUSEBUTTONDOWN and event.button == 3:
                    running = False
                elif event.type in [pgm.MIDIIN]:
                    if DEBUG: print(event)

                    do_record = False
                    if event.status == 144:  # Note on
                        do_record = True
                        self.on += 1
                        self.notes[event.data1][0] = 1
                        self.notes[event.data1][1] = event.data2
                        self.notes[event.data1][2] = self.t

                        # Don't update the min / max notes dynamically
                        # if event.data1 < self.min_note:
                        #     self.min_note = event.data1
                        # elif event.data1 > self.max_note:
                        #     self.max_note = event.data1
                    elif event.status == 128:  # Note off
                        do_record = True
                        self.off += 1
                        self.notes[event.data1][0] = 0
                        self.notes[event.data1][2] = self.t
                    elif event.status == 176 and event.data1 == 64:  # pedal
                        do_record = True
                        self.pedal = event.data2

                    if do_record and self.recorder.is_recording:
                        self.recorder.record(self.t, event)


# Key-on
# <Event(32771-MidiIn {'status': 144, 'data1': 48, 'data2': 80, 'data3': 0, 'timestamp': 1111, 'vice_id': 3}) >
# Key-off
# <Event(32771-MidiIn {'status': 128, 'data1': 48, 'data2': 0, 'data3': 0, 'timestamp': 1364, 'vice_id': 3}) >

            if paint_t < 16:
                continue
            while paint_t >= 16:
                paint_t -= 16
            self._maybe_scroll_roll()

            self._draw()
            self.on = 0
            self.off = 0

        self.reset_midi_out()
Example #8
0
                            window.fill(rainbow(h * note[j]['dur'] / k2),
                                        (x, 383, 7, 53))
                            window.fill(rainbow(note[j]['dvol'] / k3),
                                        (x, 503, 7, 53))
                    window.blit(blackshadow, (9, 261))
                    window.blit(blackshadow, (9, 381))
                    window.blit(blackshadow, (9, 501))
                    if e.status < 144 or (e.status > 143 and e.data2 == 0):
                        note[id]['vol'] = 0
                    for id in range(21, 109):
                        if note[id]['vol']:
                            if id in whiteids:
                                x = 15 * whiteids.index(id) + 11
                                window.blit(wglow, (x, 320))
                                window.blit(wglow, (x, 440))
                                window.blit(wglow, (x, 560))
                            else:
                                x = blackxs[blackids.index(id)]
                                window.blit(bglow, (x, 287))
                                window.blit(bglow, (x, 407))
                                window.blit(bglow, (x, 527))
                    pg.display.flip()
        if idev.poll():
            midi_events = idev.read(10)
            # convert them into pg events.
            midi_evs = midi.midis2events(midi_events, idev.device_id)
            for m_e in midi_evs:
                pg.event.post(m_e)
del idev
midi.quit()
Example #9
0
    def main(self):
        tkroot = None
        '''
        tkroot = tk.Tk() # using with tk
        tkroot.withdraw() # we don't want a full GUI, so keep the root window from appearing
        embed = tk.Frame(tkroot, width=100, height=100)
        embed.bind("<Key>", self.asdf)
        embed.pack()

        if _platform == "linux" or _platform == "linux2":
            os.environ['SDL_WINDOWID'] = str(embed.winfo_id())
        elif _platform == "darwin":
            os.environ['SDL_WINDOWID'] = str(embed.winfo_id())
        elif _platform == "win32":
            os.environ['SDL_VIDEODRIVER'] = 'windib'
        else:
            print("cannot support '%s'."% _platform)
        '''

        gameapi.init()
        gameapi.fastevent.init()
        fontObj = gameapi.font.Font('freesansbold.ttf', 64)

        try:
            midi.init()
            piano_id = 3
            print(midi.get_device_info(piano_id))
            midiInput = midi.Input(piano_id)
            midiConnect = True
            print("MIDI connection complete")
        except:
            midiConnect = False
            print("MIDI connection failed")

        mainWindow = windowScreen()
        gameapi.display.set_caption('the_PLAY')
        sceneManager = SceneManager.SceneManager(StartScene, mainWindow, tkroot)

        startFps = 33
        frameN = 30
        frameAccu = [startFps] * frameN
        frameCount = 0
        fpsText = fontObj.render("%.2f fps"%min(frameAccu), False, (128, 128, 0))
        fpsClock = gameapi.time.Clock()
        while True:
            startTime = time.time()
            mod = frameCount%frameN
            
            currentScene = sceneManager.getScene()

            if(midiConnect):
                while midiInput.poll():
                    midiEvents = midiInput.read(10)
                    for e in midi.midis2events(midiEvents, piano_id):
                        gameapi.fastevent.post(e)

            currentScene.updateTime(startTime)
            for event in gameapi.fastevent.get():
                if event.type == apiVar.KEYDOWN:
                    if event.key == apiVar.K_ESCAPE:
                        gameapi.event.post(gameapi.event.Event(apiVar.QUIT))
                    elif event.key == apiVar.K_RETURN:
                        toggleScreen()
                currentScene.event(event)

            currentScene.draw()
            #mainWindow.blit(fpsText, fpsText.get_rect())
            
            
            gameapi.display.flip()
            endTime = time.time()

            

            try:
                rate = 1/(endTime-startTime)
                if rate<10:
                    rate = 10
            except:
                rate = 500
            frameAccu[mod] = rate
            frameCount+=1

            if mod == 0:
                minfps = min(frameAccu)*0.9
                #fpsText = fontObj.render("%.2f fps"%minfps, False, (128, 128, 0))
                fpsClock.tick(minfps)
Example #10
0
        for y in range(100,200,4):
            pixArr[x][y] = redColor
    del pixArr

    msgSurfaceObj = fontObj.render(keypressMsg, False, blueColor)
    msgRectobj = msgSurfaceObj.get_rect()
    msgRectobj.topleft = (0,0)
    windowSurfaceObj.blit(msgSurfaceObj, msgRectobj)

    mouseposSurfaceObj = fontObj.render(mouseposMsg, True, randomColor)
    windowSurfaceObj.blit(mouseposSurfaceObj, (mousex, mousey))


    while midiInput.poll():
        midiEvents = midiInput.read(10)
        for e in piano.midis2events(midiEvents, piano_id):
            gameapi.fastevent.post(e)
    
    for event in gameapi.fastevent.get():
        if event.type == apiVar.QUIT:
            gameapi.quit()
            sys.exit()
        elif event.type == piano.MIDIIN:
            print(event)
            '''
            print (event.data1)
            print (event.data2)
            print (event.data3)
            print (event.timestamp)
            print (event.vice_id)
            '''