falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4562 Commits
17 Branches
341MB
Tree: 08e0b1caea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '08e0b1caea'
${ noResults }
Carla/source/native-plugins/resources/midipattern-ui

323 lines
11KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3. 

  4. # A piano roll viewer/editor

  5. # Copyright (C) 2012-2015 Filipe Coelho <falktx@falktx.com>

  6. # Copyright (C) 2014-2015 Perry Nguyen

  7. #

  8. # This program is free software; you can redistribute it and/or

  9. # modify it under the terms of the GNU General Public License as

  10. # published by the Free Software Foundation; either version 2 of

  11. # the License, or any later version.

  12. #

  13. # This program is distributed in the hope that it will be useful,

  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of

  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  16. # GNU General Public License for more details.

  17. #

  18. # For a full copy of the GNU General Public License see the doc/GPL.txt file.

  19. 

  20. # ------------------------------------------------------------------------------------------------------------

  21. # Imports (Config)

  22. 

  23. from carla_config import *

  24. 

  25. # ------------------------------------------------------------------------------------------------------------

  26. # Imports (Global)

  27. 

  28. if config_UseQt5:

  29.     from PyQt5.QtCore import pyqtSlot, Qt, QEvent

  30.     from PyQt5.QtGui import QKeyEvent

  31.     from PyQt5.QtWidgets import QMainWindow

  32. else:

  33.     from PyQt4.QtCore import pyqtSlot, Qt, QEvent

  34.     from PyQt4.QtGui import QKeyEvent, QMainWindow

  35. 

  36. # ------------------------------------------------------------------------------------------------------------

  37. # Imports (Custom)

  38. 

  39. from carla_shared import *

  40. from carla_utils import *

  41. from widgets.pianoroll import *

  42. 

  43. import ui_midipattern

  44. 

  45. # ------------------------------------------------------------------------------------------------------------

  46. # Imports (ExternalUI)

  47. 

  48. from carla_app import CarlaApplication

  49. from externalui import ExternalUI

  50. 

  51. # ------------------------------------------------------------------------------------------------------------

  52. 

  53. class MidiPatternW(ExternalUI, QMainWindow):

  54.     PPQ = 48.0

  55. 

  56.     def __init__(self):

  57.         ExternalUI.__init__(self)

  58.         QMainWindow.__init__(self)

  59.         self.ui = ui_midipattern.Ui_MidiPatternW()

  60.         self.ui.setupUi(self)

  61.         self.ui.piano = self.ui.graphicsView.piano

  62. 

  63.         # to be filled with note-on events, while waiting for their matching note-off

  64.         self.fPendingNoteOns = [] # (channel, note, velocity, time)

  65. 

  66.         self.fTransportInfo = {

  67.             "playing": False,

  68.             "frame": 0,

  69.             "bar": 0,

  70.             "beat": 0,

  71.             "tick": 0,

  72.             "bpm": 120.0,

  73.             "sigNum": 4.0,

  74.             "sigDenom": 4.0

  75.         }

  76. 

  77.         self.ui.act_edit_insert.triggered.connect(self.slot_editInsertMode)

  78.         self.ui.act_edit_velocity.triggered.connect(self.slot_editVelocityMode)

  79.         self.ui.act_edit_select_all.triggered.connect(self.slot_editSelectAll)

  80. 

  81.         self.ui.piano.midievent.connect(self.sendMsg)

  82.         self.ui.piano.measureupdate.connect(self.updateMeasureBox)

  83.         self.ui.piano.modeupdate.connect(self.ui.modeIndicator.changeMode)

  84.         self.ui.piano.modeupdate.connect(self.slot_modeChanged)

  85. 

  86.         self.ui.timeSigBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  87.         self.ui.measureBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  88.         self.ui.defaultLengthBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  89.         self.ui.quantizeBox.currentIndexChanged[int].connect(self.slot_paramChanged)

  90. 

  91.         self.ui.timeSigBox.currentIndexChanged[str].connect(self.ui.piano.setTimeSig)

  92.         self.ui.measureBox.currentIndexChanged[str].connect(self.ui.piano.setMeasures)

  93.         self.ui.defaultLengthBox.currentIndexChanged[str].connect(self.ui.piano.setDefaultLength)

  94.         self.ui.quantizeBox.currentIndexChanged[str].connect(self.ui.piano.setGridDiv)

  95.         self.ui.hSlider.valueChanged.connect(self.ui.graphicsView.setZoomX)

  96.         self.ui.vSlider.valueChanged.connect(self.ui.graphicsView.setZoomY)

  97. 

  98.         self.ui.graphicsView.setFocus()

  99. 

  100.         self.fIdleTimer = self.startTimer(30)

  101.         self.setWindowTitle(self.fUiName)

  102.         self.ready()

  103. 

  104.     def slot_editInsertMode(self):

  105.         ev = QKeyEvent(QEvent.User, Qt.Key_F, Qt.NoModifier)

  106.         self.ui.piano.keyPressEvent(ev)

  107. 

  108.     def slot_editVelocityMode(self):

  109.         ev = QKeyEvent(QEvent.User, Qt.Key_D, Qt.NoModifier)

  110.         self.ui.piano.keyPressEvent(ev)

  111. 

  112.     def slot_editSelectAll(self):

  113.         ev = QKeyEvent(QEvent.User, Qt.Key_A, Qt.NoModifier)

  114.         self.ui.piano.keyPressEvent(ev)

  115. 

  116.     def slot_modeChanged(self, mode):

  117.         if mode == "insert_mode":

  118.             self.ui.act_edit_insert.setChecked(True)

  119.             self.ui.act_edit_velocity.setChecked(False)

  120.         elif mode == "velocity_mode":

  121.             self.ui.act_edit_insert.setChecked(False)

  122.             self.ui.act_edit_velocity.setChecked(True)

  123.         else:

  124.             self.ui.act_edit_insert.setChecked(False)

  125.             self.ui.act_edit_velocity.setChecked(False)

  126. 

  127.     def slot_paramChanged(self, index):

  128.         sender = self.sender()

  129. 

  130.         if sender == self.ui.timeSigBox:

  131.             param = 0

  132.         elif sender == self.ui.measureBox:

  133.             param = 1

  134.             index += 1

  135.         elif sender == self.ui.defaultLengthBox:

  136.             param = 2

  137.         elif sender == self.ui.quantizeBox:

  138.             param = 3

  139.         else:

  140.             return

  141. 

  142.         self.sendControl(param, index)

  143. 

  144.     # -------------------------------------------------------------------

  145.     # DSP Callbacks

  146. 

  147.     def dspParameterChanged(self, index, value):

  148.         value = int(value)

  149. 

  150.         if index == 0: # TimeSig

  151.             self.ui.timeSigBox.setCurrentIndex(value)

  152.         elif index == 1: # Measures

  153.             self.ui.measureBox.setCurrentIndex(value-1)

  154.         elif index == 2: # DefLength

  155.             self.ui.defaultLengthBox.setCurrentIndex(value)

  156.         elif index == 3: # Quantize

  157.             self.ui.quantizeBox.setCurrentIndex(value)

  158. 

  159.     def dspStateChanged(self, key, value):

  160.         pass

  161. 

  162.     # -------------------------------------------------------------------

  163.     # ExternalUI Callbacks

  164. 

  165.     def uiShow(self):

  166.         self.show()

  167. 

  168.     def uiFocus(self):

  169.         self.setWindowState((self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive)

  170.         self.show()

  171. 

  172.         self.raise_()

  173.         self.activateWindow()

  174. 

  175.     def uiHide(self):

  176.         self.hide()

  177. 

  178.     def uiQuit(self):

  179.         self.closeExternalUI()

  180.         self.close()

  181.         app.quit()

  182. 

  183.     def uiTitleChanged(self, uiTitle):

  184.         self.setWindowTitle(uiTitle)

  185. 

  186.     # -------------------------------------------------------------------

  187.     # Qt events

  188. 

  189.     def timerEvent(self, event):

  190.         if event.timerId() == self.fIdleTimer:

  191.             self.idleExternalUI()

  192.         QMainWindow.timerEvent(self, event)

  193. 

  194.     def closeEvent(self, event):

  195.         self.closeExternalUI()

  196.         QMainWindow.closeEvent(self, event)

  197. 

  198.         # there might be other qt windows open which will block the UI from quitting

  199.         app.quit()

  200. 

  201.     # -------------------------------------------------------------------

  202.     # Custom callback

  203. 

  204.     def updateMeasureBox(self, index):

  205.         self.measureBox.setCurrentIndex(index-1)

  206. 

  207.     def sendMsg(self, data):

  208.         msg = data[0]

  209.         if msg == "midievent-remove":

  210.             note, start, length, vel = data[1:5]

  211.             note_start = start * 60. / self.fTransportInfo["bpm"] * 4. / self.fTransportInfo["sigDenom"] * self.PPQ

  212.             note_stop = note_start + length * 60. / self.fTransportInfo["bpm"] * 4. * self.fTransportInfo["sigNum"] / self.fTransportInfo["sigDenom"] * self.PPQ

  213.             self.send([msg, note_start, 3, MIDI_STATUS_NOTE_ON, note, vel])

  214.             self.send([msg, note_stop, 3, MIDI_STATUS_NOTE_OFF, note, vel])

  215. 

  216.         elif msg == "midievent-add":

  217.             note, start, length, vel = data[1:5]

  218.             note_start = start * 60. / self.fTransportInfo["bpm"] * self.PPQ

  219.             note_stop = note_start + length * 60. / self.fTransportInfo["bpm"] * 4. * self.fTransportInfo["sigNum"] / self.fTransportInfo["sigDenom"] * self.PPQ

  220.             self.send([msg, note_start, 3, MIDI_STATUS_NOTE_ON, note, vel])

  221.             self.send([msg, note_stop, 3, MIDI_STATUS_NOTE_OFF, note, vel])

  222. 

  223.     def msgCallback(self, msg):

  224.         msg = charPtrToString(msg)

  225. 

  226.         if msg == "midi-clear-all":

  227.             # clear all notes

  228.             self.ui.piano.clearNotes()

  229. 

  230.         elif msg == "midievent-add":

  231.             # adds single midi event

  232.             time = int(self.readlineblock())

  233.             size = int(self.readlineblock())

  234.             data = []

  235. 

  236.             for x in range(size):

  237.                 data.append(int(self.readlineblock()))

  238. 

  239.             self.handleMidiEvent(time, size, data)

  240. 

  241.         elif msg == "transport":

  242.             playing = bool(self.readlineblock() == "true")

  243.             frame, bar, beat, tick = [int(i) for i in self.readlineblock().split(":")]

  244.             bpm, sigNum, sigDenom = [float(i) for i in self.readlineblock().split(":")]

  245. 

  246.             if beat != self.fTransportInfo["beat"]:

  247.                 print(beat)

  248. 

  249.             old_frame = self.fTransportInfo['frame']

  250. 

  251.             self.fTransportInfo = {

  252.                 "playing": playing,

  253.                 "frame": frame,

  254.                 "bar": bar,

  255.                 "beat": beat,

  256.                 "tick": tick,

  257.                 "bpm": bpm,

  258.                 "sigNum": sigNum,

  259.                 "sigDenom": sigDenom

  260.             }

  261. 

  262.             if old_frame != frame:

  263.                 self.ui.piano.movePlayHead(self.fTransportInfo)

  264. 

  265.         else:

  266.             ExternalUI.msgCallback(self, msg)

  267. 

  268.     # -------------------------------------------------------------------

  269.     # Internal stuff

  270. 

  271.     def handleMidiEvent(self, time, size, data):

  272.         #print("Got MIDI Event on UI", time, size, data)

  273. 

  274.         # NOTE: for now time comes in frames, which might not be desirable

  275.         #       we'll convert it to a smaller value for now (seconds)

  276.         #       later on we can have time as PPQ or similar

  277. 

  278.         time /= self.PPQ

  279. 

  280.         status  = MIDI_GET_STATUS_FROM_DATA(data)

  281.         channel = MIDI_GET_CHANNEL_FROM_DATA(data)

  282.         if status == MIDI_STATUS_NOTE_ON:

  283.             note = data[1]

  284.             velo = data[2]

  285. 

  286.             # append (channel, note, velo, time) for later

  287.             self.fPendingNoteOns.append((channel, note, velo, time))

  288. 

  289.         elif status == MIDI_STATUS_NOTE_OFF:

  290.             note = data[1]

  291.             velo = data[2]

  292. 

  293.             # find previous note-on that matches this note and channel

  294.             for noteOnMsg in self.fPendingNoteOns:

  295.                 channel_, note_, velo_, time_ = noteOnMsg

  296. 

  297.                 if channel_ != channel:

  298.                     continue

  299.                 if note_ != note:

  300.                     continue

  301. 

  302.                 # found it

  303.                 #print("{} {} {} {}\n".format(note, time_, time-time_, velo_))

  304.                 start = time_ / 60. * self.fTransportInfo["bpm"] / 4. * self.fTransportInfo["sigDenom"]

  305.                 length = (time - time_) / 60. * self.fTransportInfo["bpm"] / 4. / self.fTransportInfo["sigNum"] * self.fTransportInfo["sigDenom"]

  306.                 self.ui.piano.drawNote(note, start, length, velo_)

  307. 

  308.                 # remove from list

  309.                 self.fPendingNoteOns.remove(noteOnMsg)

  310.                 break

  311. 

  312. #--------------- main ------------------

  313. if __name__ == '__main__':

  314.     import resources_rc

  315. 

  316.     pathBinaries, pathResources = getPaths()

  317.     gCarla.utils = CarlaUtils(os.path.join(pathBinaries, "libcarla_utils." + DLL_EXTENSION))

  318.     gCarla.utils.set_process_name("MidiPattern")

  319. 

  320.     app = CarlaApplication("MidiPattern")

  321.     gui = MidiPatternW()

  322.     app.exit_exec()