falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
23 Commits
2 Branches
131MB
Tree: 20f64b2786
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '20f64b2786'
${ noResults }
Cadence/src/xycontroller.py

582 lines
21KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # XY Controller for JACK, using jacklib

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

  6. #

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

  8. # it under the terms of the GNU General Public License as published by

  9. # the Free Software Foundation; either version 2 of the License, or

  10. # any later version.

  11. #

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

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

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

  15. # GNU General Public License for more details.

  16. #

  17. # For a full copy of the GNU General Public License see the COPYING file

  18. 

  19. # Imports (Global)

  20. from PyQt4.QtCore import pyqtSlot, Qt, QPointF, QRectF, QSettings, QTimer, QVariant

  21. from PyQt4.QtGui import QApplication, QColor, QIcon, QPainter, QPen, QGraphicsItem, QGraphicsScene, QMainWindow

  22. from queue import Queue, Empty as QuequeEmpty

  23. 

  24. # Imports (Custom)

  25. import ui_xycontroller

  26. from shared import *

  27. from jacklib_helpers import *

  28. 

  29. # Globals

  30. global jack_client, jack_midi_in_port, jack_midi_out_port, jack_midi_in_data, jack_midi_out_data

  31. jack_client = None

  32. jack_midi_in_port  = None

  33. jack_midi_out_port = None

  34. jack_midi_in_data  = Queue(512)

  35. jack_midi_out_data = Queue(512)

  36. 

  37. # XY Controller Scene

  38. class XYGraphicsScene(QGraphicsScene):

  39.     def __init__(self, parent):

  40.         QGraphicsScene.__init__(self, parent)

  41. 

  42.         self.cc_x = 1

  43.         self.cc_y = 2

  44.         self.m_channels = []

  45.         self.m_mouseLock = False

  46.         self.m_smooth = False

  47.         self.m_smooth_x = 0

  48.         self.m_smooth_y = 0

  49. 

  50.         self.setBackgroundBrush(Qt.black)

  51. 

  52.         cursorPen = QPen(QColor(255,255,255), 2)

  53.         cursorBrush = QColor(255,255,255,50)

  54.         self.m_cursor = self.addEllipse(QRectF(-10, -10, 20, 20), cursorPen, cursorBrush)

  55. 

  56.         linePen = QPen(QColor(200,200,200,100), 1, Qt.DashLine)

  57.         self.m_lineH = self.addLine(-9999, 0, 9999, 0, linePen)

  58.         self.m_lineV = self.addLine(0, -9999, 0, 9999, linePen)

  59. 

  60.         self.p_size = QRectF(-100, -100, 100, 100)

  61. 

  62.     def setControlX(self, x):

  63.         self.cc_x = x

  64. 

  65.     def setControlY(self, y):

  66.         self.cc_y = y

  67. 

  68.     def setChannels(self, channels):

  69.         self.m_channels = channels

  70. 

  71.     def setPosX(self, x, forward=True):

  72.         if (self.m_mouseLock == False):

  73.           pos_x = x*(self.p_size.x()+self.p_size.width())

  74.           self.m_cursor.setPos(pos_x, self.m_cursor.y())

  75.           self.m_lineV.setX(pos_x)

  76. 

  77.           if (forward):

  78.             self.sendMIDI(pos_x/(self.p_size.x()+self.p_size.width()), None)

  79.           else:

  80.             self.m_smooth_x = pos_x

  81. 

  82.     def setPosY(self, y, forward=True):

  83.         if (self.m_mouseLock == False):

  84.           pos_y = y*(self.p_size.y()+self.p_size.height())

  85.           self.m_cursor.setPos(self.m_cursor.x(), pos_y)

  86.           self.m_lineH.setY(pos_y)

  87. 

  88.           if (forward):

  89.             self.sendMIDI(None, pos_y/(self.p_size.y()+self.p_size.height()))

  90.           else:

  91.             self.m_smooth_y = pos_y

  92. 

  93.     def setSmooth(self, smooth):

  94.         self.m_smooth = smooth

  95. 

  96.     def handleCC(self, param, value):

  97.         if (param == self.cc_x):

  98.           xp = (float(value)/63)-1.025

  99.           yp = self.m_cursor.y()/(self.p_size.y()+self.p_size.height())

  100.           self.setPosX(xp, False)

  101. 

  102.         elif (param == self.cc_y):

  103.           xp = self.m_cursor.x()/(self.p_size.x()+self.p_size.width())

  104.           yp = (float(value)/63)-1.025

  105.           self.setPosY(yp, False)

  106. 

  107.         else:

  108.           return

  109. 

  110.         self.emit(SIGNAL("cursorMoved(float, float)"), xp, yp)

  111. 

  112.     def handleMousePos(self, pos):

  113.         if (not self.p_size.contains(pos)):

  114.           if (pos.x() < self.p_size.x()):

  115.             pos.setX(self.p_size.x())

  116.           elif (pos.x() > self.p_size.x()+self.p_size.width()):

  117.             pos.setX(self.p_size.x()+self.p_size.width())

  118. 

  119.           if (pos.y() < self.p_size.y()):

  120.             pos.setY(self.p_size.y())

  121.           elif (pos.y() > self.p_size.y()+self.p_size.height()):

  122.             pos.setY(self.p_size.y()+self.p_size.height())

  123. 

  124.         self.m_smooth_x = pos.x()

  125.         self.m_smooth_y = pos.y()

  126. 

  127.         if (self.m_smooth == False):

  128.           self.m_cursor.setPos(pos)

  129.           self.m_lineH.setY(pos.y())

  130.           self.m_lineV.setX(pos.x())

  131. 

  132.           xp = pos.x()/(self.p_size.x()+self.p_size.width())

  133.           yp = pos.y()/(self.p_size.y()+self.p_size.height())

  134. 

  135.           self.sendMIDI(xp, yp)

  136.           self.emit(SIGNAL("cursorMoved(float, float)"), xp, yp)

  137. 

  138.     def sendMIDI(self, xp=None, yp=None):

  139.         global jack_midi_out_data

  140.         rate = float(0xff)/4

  141. 

  142.         if (xp != None):

  143.           value = int((xp*rate)+rate)

  144.           for channel in self.m_channels:

  145.             jack_midi_out_data.put_nowait((0xB0+channel-1, self.cc_x, value))

  146. 

  147.         if (yp != None):

  148.           value = int((yp*rate)+rate)

  149.           for channel in self.m_channels:

  150.             jack_midi_out_data.put_nowait((0xB0+channel-1, self.cc_y, value))

  151. 

  152.     def updateSize(self, size):

  153.         self.p_size.setRect(-(size.width()/2), -(size.height()/2), size.width(), size.height())

  154. 

  155.     def updateSmooth(self):

  156.         if (self.m_smooth):

  157.           if (self.m_cursor.x() != self.m_smooth_x or self.m_cursor.y() != self.m_smooth_y):

  158.             new_x = (self.m_smooth_x+self.m_cursor.x()*3)/4

  159.             new_y = (self.m_smooth_y+self.m_cursor.y()*3)/4

  160.             pos = QPointF(new_x, new_y)

  161. 

  162.             self.m_cursor.setPos(pos)

  163.             self.m_lineH.setY(pos.y())

  164.             self.m_lineV.setX(pos.x())

  165. 

  166.             xp = pos.x()/(self.p_size.x()+self.p_size.width())

  167.             yp = pos.y()/(self.p_size.y()+self.p_size.height())

  168. 

  169.             self.sendMIDI(xp, yp)

  170.             self.emit(SIGNAL("cursorMoved(float, float)"), xp, yp)

  171. 

  172.     def keyPressEvent(self, event):

  173.         event.accept()

  174. 

  175.     def wheelEvent(self, event):

  176.         event.accept()

  177. 

  178.     def mousePressEvent(self, event):

  179.         self.m_mouseLock = True

  180.         self.handleMousePos(event.scenePos())

  181.         QGraphicsScene.mousePressEvent(self, event)

  182. 

  183.     def mouseMoveEvent(self, event):

  184.         self.handleMousePos(event.scenePos())

  185.         QGraphicsScene.mouseMoveEvent(self, event)

  186. 

  187.     def mouseReleaseEvent(self, event):

  188.         self.m_mouseLock = False

  189.         QGraphicsScene.mouseReleaseEvent(self, event)

  190. 

  191. # XY Controller Window

  192. class XYControllerW(QMainWindow, ui_xycontroller.Ui_XYControllerW):

  193.     def __init__(self, parent):

  194.         QMainWindow.__init__(self, parent)

  195.         self.setupUi(self)

  196. 

  197.         # -------------------------------------------------------------

  198.         # Internal stuff

  199. 

  200.         self.cc_x = 1

  201.         self.cc_y = 2

  202.         self.m_channels = []

  203. 

  204.         # -------------------------------------------------------------

  205.         # Set-up GUI stuff

  206. 

  207.         self.dial_x.setPixmap(2)

  208.         self.dial_y.setPixmap(2)

  209.         self.dial_x.setLabel("X")

  210.         self.dial_y.setLabel("Y")

  211.         self.keyboard.setOctaves(6)

  212. 

  213.         self.scene = XYGraphicsScene(self)

  214.         self.graphicsView.setScene(self.scene)

  215.         self.graphicsView.setRenderHints(QPainter.Antialiasing)

  216. 

  217.         for MIDI_CC in MIDI_CC_LIST:

  218.           self.cb_control_x.addItem(MIDI_CC)

  219.           self.cb_control_y.addItem(MIDI_CC)

  220. 

  221.         # -------------------------------------------------------------

  222.         # Load Settings

  223. 

  224.         self.settings = QSettings("Cadence", "XY-Controller")

  225.         self.loadSettings()

  226. 

  227.         # -------------------------------------------------------------

  228.         # Connect actions to functions

  229. 

  230.         self.connect(self.keyboard, SIGNAL("noteOn(int)"), SLOT("slot_noteOn(int)"))

  231.         self.connect(self.keyboard, SIGNAL("noteOff(int)"), SLOT("slot_noteOff(int)"))

  232. 

  233.         self.connect(self.cb_smooth, SIGNAL("clicked(bool)"), SLOT("slot_setSmooth(bool)"))

  234. 

  235.         self.connect(self.dial_x, SIGNAL("valueChanged(int)"), SLOT("slot_updateSceneX(int)"))

  236.         self.connect(self.dial_y, SIGNAL("valueChanged(int)"), SLOT("slot_updateSceneY(int)"))

  237. 

  238.         self.connect(self.cb_control_x, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_checkCC_X(QString)"))

  239.         self.connect(self.cb_control_y, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_checkCC_Y(QString)"))

  240. 

  241.         # FIXME

  242.         self.connect(self.scene, SIGNAL("cursorMoved(float, float)"), self.slot_sceneCursorMoved)

  243.         #self.connect(self.scene, SIGNAL("cursorMoved(float, float)"), SLOT("slot_sceneCursorMoved(float, float)"))

  244. 

  245.         self.connect(self.act_ch_01, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  246.         self.connect(self.act_ch_02, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  247.         self.connect(self.act_ch_03, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  248.         self.connect(self.act_ch_04, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  249.         self.connect(self.act_ch_05, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  250.         self.connect(self.act_ch_06, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  251.         self.connect(self.act_ch_07, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  252.         self.connect(self.act_ch_08, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  253.         self.connect(self.act_ch_09, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  254.         self.connect(self.act_ch_10, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  255.         self.connect(self.act_ch_11, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  256.         self.connect(self.act_ch_12, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  257.         self.connect(self.act_ch_13, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  258.         self.connect(self.act_ch_14, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  259.         self.connect(self.act_ch_15, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  260.         self.connect(self.act_ch_16, SIGNAL("triggered(bool)"), SLOT("slot_checkChannel(bool)"))

  261.         self.connect(self.act_ch_all, SIGNAL("triggered()"), SLOT("slot_checkChannel_all()"))

  262.         self.connect(self.act_ch_none, SIGNAL("triggered()"), SLOT("slot_checkChannel_none()"))

  263. 

  264.         self.connect(self.act_show_keyboard, SIGNAL("triggered(bool)"), SLOT("slot_showKeyboard(bool)"))

  265.         self.connect(self.act_about, SIGNAL("triggered()"), SLOT("slot_about()"))

  266. 

  267.         # -------------------------------------------------------------

  268.         # Final stuff

  269. 

  270.         self.m_midiInTimerId = self.startTimer(50)

  271.         QTimer.singleShot(0, self, SLOT("slot_updateScreen()"))

  272. 

  273.     def updateScreen(self):

  274.         self.scene.updateSize(self.graphicsView.size())

  275.         self.graphicsView.centerOn(0, 0)

  276. 

  277.         self.slot_updateSceneX(self.dial_x.value())

  278.         self.slot_updateSceneY(self.dial_y.value())

  279. 

  280.     @pyqtSlot(int)

  281.     def slot_noteOn(self, note):

  282.         global jack_midi_out_data

  283.         for channel in self.m_channels:

  284.           jack_midi_out_data.put_nowait((0x90+channel-1, note, 100))

  285. 

  286.     @pyqtSlot(int)

  287.     def slot_noteOff(self, note):

  288.         global jack_midi_out_data

  289.         for channel in self.m_channels:

  290.           jack_midi_out_data.put_nowait((0x80+channel-1, note, 0))

  291. 

  292.     @pyqtSlot(int)

  293.     def slot_updateSceneX(self, x):

  294.         self.scene.setPosX(float(x)/100)

  295. 

  296.     @pyqtSlot(int)

  297.     def slot_updateSceneY(self, y):

  298.         self.scene.setPosY(float(y)/100)

  299. 

  300.     @pyqtSlot(str)

  301.     def slot_checkCC_X(self, text):

  302.         if (text):

  303.           self.cc_x = int(text.split(" ")[0], 16)

  304.           self.scene.setControlX(self.cc_x)

  305. 

  306.     @pyqtSlot(str)

  307.     def slot_checkCC_Y(self, text):

  308.         if (text):

  309.           self.cc_y = int(text.split(" ")[0], 16)

  310.           self.scene.setControlY(self.cc_y)

  311. 

  312.     @pyqtSlot(bool)

  313.     def slot_checkChannel(self, clicked):

  314.         channel = int(self.sender().text())

  315.         if (clicked and channel not in self.m_channels):

  316.           self.m_channels.append(channel)

  317.         elif (not clicked and channel in self.m_channels):

  318.           self.m_channels.remove(channel)

  319.         self.scene.setChannels(self.m_channels)

  320. 

  321.     @pyqtSlot()

  322.     def slot_checkChannel_all(self):

  323.         self.act_ch_01.setChecked(True)

  324.         self.act_ch_02.setChecked(True)

  325.         self.act_ch_03.setChecked(True)

  326.         self.act_ch_04.setChecked(True)

  327.         self.act_ch_05.setChecked(True)

  328.         self.act_ch_06.setChecked(True)

  329.         self.act_ch_07.setChecked(True)

  330.         self.act_ch_08.setChecked(True)

  331.         self.act_ch_09.setChecked(True)

  332.         self.act_ch_10.setChecked(True)

  333.         self.act_ch_11.setChecked(True)

  334.         self.act_ch_12.setChecked(True)

  335.         self.act_ch_13.setChecked(True)

  336.         self.act_ch_14.setChecked(True)

  337.         self.act_ch_15.setChecked(True)

  338.         self.act_ch_16.setChecked(True)

  339.         self.m_channels = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

  340.         self.scene.setChannels(self.m_channels)

  341. 

  342.     @pyqtSlot()

  343.     def slot_checkChannel_none(self):

  344.         self.act_ch_01.setChecked(False)

  345.         self.act_ch_02.setChecked(False)

  346.         self.act_ch_03.setChecked(False)

  347.         self.act_ch_04.setChecked(False)

  348.         self.act_ch_05.setChecked(False)

  349.         self.act_ch_06.setChecked(False)

  350.         self.act_ch_07.setChecked(False)

  351.         self.act_ch_08.setChecked(False)

  352.         self.act_ch_09.setChecked(False)

  353.         self.act_ch_10.setChecked(False)

  354.         self.act_ch_11.setChecked(False)

  355.         self.act_ch_12.setChecked(False)

  356.         self.act_ch_13.setChecked(False)

  357.         self.act_ch_14.setChecked(False)

  358.         self.act_ch_15.setChecked(False)

  359.         self.act_ch_16.setChecked(False)

  360.         self.m_channels = []

  361.         self.scene.setChannels(self.m_channels)

  362. 

  363.     @pyqtSlot(bool)

  364.     def slot_setSmooth(self, yesno):

  365.         self.scene.setSmooth(yesno)

  366. 

  367.     @pyqtSlot(float, float)

  368.     def slot_sceneCursorMoved(self, xp, yp):

  369.         self.dial_x.setValue(xp*100)

  370.         self.dial_y.setValue(yp*100)

  371. 

  372.     @pyqtSlot(bool)

  373.     def slot_showKeyboard(self, yesno):

  374.         self.scrollArea.setVisible(yesno)

  375.         QTimer.singleShot(0, self, SLOT("slot_updateScreen()"))

  376. 

  377.     @pyqtSlot()

  378.     def slot_about(self):

  379.         QMessageBox.about(self, self.tr("About XY Controller"), self.tr("<h3>XY Controller</h3>"

  380.             "<br>Version %s"

  381.             "<br>XY Controller is a simple XY widget that sends and receives data from Jack MIDI.<br>"

  382.             "<br>Copyright (C) 2012 falkTX" % (VERSION)))

  383. 

  384.     @pyqtSlot()

  385.     def slot_updateScreen(self):

  386.         self.updateScreen()

  387. 

  388.     def saveSettings(self):

  389.         self.settings.setValue("Geometry", self.saveGeometry())

  390.         self.settings.setValue("ShowKeyboard", self.scrollArea.isVisible())

  391.         self.settings.setValue("Smooth", self.cb_smooth.isChecked())

  392.         self.settings.setValue("DialX", self.dial_x.value())

  393.         self.settings.setValue("DialY", self.dial_y.value())

  394.         self.settings.setValue("ControlX", self.cc_x)

  395.         self.settings.setValue("ControlY", self.cc_y)

  396.         self.settings.setValue("Channels", self.m_channels)

  397. 

  398.     def loadSettings(self):

  399.         self.restoreGeometry(self.settings.value("Geometry", ""))

  400. 

  401.         showKeyboard = self.settings.value("ShowKeyboard", False, type=bool)

  402.         self.act_show_keyboard.setChecked(showKeyboard)

  403.         self.scrollArea.setVisible(showKeyboard)

  404. 

  405.         smooth = self.settings.value("Smooth", False, type=bool)

  406.         self.cb_smooth.setChecked(smooth)

  407.         self.scene.setSmooth(smooth)

  408. 

  409.         self.dial_x.setValue(self.settings.value("DialX", 50, type=int))

  410.         self.dial_y.setValue(self.settings.value("DialY", 50, type=int))

  411.         self.cc_x = self.settings.value("ControlX", 1, type=int)

  412.         self.cc_y = self.settings.value("ControlY", 2, type=int)

  413.         self.m_channels = toList(self.settings.value("Channels", [1]))

  414. 

  415.         for i in range(len(self.m_channels)):

  416.           self.m_channels[i] = int(self.m_channels[i])

  417. 

  418.         self.scene.setChannels(self.m_channels)

  419. 

  420.         for i in range(len(MIDI_CC_LIST)):

  421.           cc = int(MIDI_CC_LIST[i].split(" ")[0], 16)

  422.           if (self.cc_x == cc):

  423.             self.cb_control_x.setCurrentIndex(i)

  424.           if (self.cc_y == cc):

  425.             self.cb_control_y.setCurrentIndex(i)

  426. 

  427.         if (1 in self.m_channels):

  428.           self.act_ch_01.setChecked(True)

  429.         if (2 in self.m_channels):

  430.           self.act_ch_02.setChecked(True)

  431.         if (3 in self.m_channels):

  432.           self.act_ch_03.setChecked(True)

  433.         if (4 in self.m_channels):

  434.           self.act_ch_04.setChecked(True)

  435.         if (5 in self.m_channels):

  436.           self.act_ch_05.setChecked(True)

  437.         if (6 in self.m_channels):

  438.           self.act_ch_06.setChecked(True)

  439.         if (7 in self.m_channels):

  440.           self.act_ch_07.setChecked(True)

  441.         if (8 in self.m_channels):

  442.           self.act_ch_08.setChecked(True)

  443.         if (9 in self.m_channels):

  444.           self.act_ch_09.setChecked(True)

  445.         if (10 in self.m_channels):

  446.           self.act_ch_10.setChecked(True)

  447.         if (11 in self.m_channels):

  448.           self.act_ch_11.setChecked(True)

  449.         if (12 in self.m_channels):

  450.           self.act_ch_12.setChecked(True)

  451.         if (13 in self.m_channels):

  452.           self.act_ch_13.setChecked(True)

  453.         if (14 in self.m_channels):

  454.           self.act_ch_14.setChecked(True)

  455.         if (15 in self.m_channels):

  456.           self.act_ch_15.setChecked(True)

  457.         if (16 in self.m_channels):

  458.           self.act_ch_16.setChecked(True)

  459. 

  460.     def timerEvent(self, event):

  461.         if (event.timerId() == self.m_midiInTimerId):

  462.           global jack_midi_in_data

  463.           if (jack_midi_in_data.empty() == False):

  464.             while (True):

  465.               try:

  466.                 mode, note, velo = jack_midi_in_data.get_nowait()

  467.               except QuequeEmpty:

  468.                 break

  469. 

  470.               # TODO - filter by channel here

  471.               #channel = mode - 0xB0+1

  472.               #if (channel in self.m_channels):

  473.               if (0x80 <= mode and mode <= 0x8F):

  474.                 self.keyboard.noteOff(note, False)

  475.               elif (0x90 <= mode and mode < 0x9F):

  476.                 self.keyboard.noteOn(note, False)

  477.               elif (0xB0 <= mode and mode < 0xBF):

  478.                 self.scene.handleCC(note, velo)

  479. 

  480.               jack_midi_in_data.task_done()

  481. 

  482.           self.scene.updateSmooth()

  483. 

  484.         QMainWindow.timerEvent(self, event)

  485. 

  486.     def resizeEvent(self, event):

  487.         self.updateScreen()

  488.         QMainWindow.resizeEvent(self, event)

  489. 

  490.     def closeEvent(self, event):

  491.         self.saveSettings()

  492.         QMainWindow.closeEvent(self, event)

  493. 

  494. # -------------------------------------------------------------

  495. # JACK Stuff

  496. 

  497. static_event = jacklib.jack_midi_event_t()

  498. static_mtype = jacklib.c_ubyte*3

  499. 

  500. def jack_process_callback(nframes, arg):

  501.     global jack_midi_in_port, jack_midi_out_port, jack_midi_in_data, jack_midi_out_data

  502. 

  503.     # MIDI In

  504.     midi_in_buffer = jacklib.port_get_buffer(jack_midi_in_port, nframes)

  505. 

  506.     if (midi_in_buffer):

  507.       event_count = jacklib.midi_get_event_count(midi_in_buffer)

  508. 

  509.       for i in range(event_count):

  510.         if (jacklib.midi_event_get(jacklib.pointer(static_event), midi_in_buffer, i) == 0):

  511.           if (static_event.size == 1):

  512.             jack_midi_in_data.put_nowait((static_event.buffer[0], 0, 0))

  513.           elif (static_event.size == 2):

  514.             jack_midi_in_data.put_nowait((static_event.buffer[0], static_event.buffer[1], 0))

  515.           elif (static_event.size >= 3):

  516.             jack_midi_in_data.put_nowait((static_event.buffer[0], static_event.buffer[1], static_event.buffer[2]))

  517. 

  518.           if (jack_midi_in_data.full()):

  519.             break

  520. 

  521.     # MIDI Out

  522.     midi_out_buffer = jacklib.port_get_buffer(jack_midi_out_port, nframes)

  523. 

  524.     if (midi_out_buffer):

  525.       jacklib.midi_clear_buffer(midi_out_buffer)

  526. 

  527.       if (jack_midi_out_data.empty() == False):

  528.         while (True):

  529.           try:

  530.             mode, note, velo = jack_midi_out_data.get_nowait()

  531.           except QuequeEmpty:

  532.             break

  533. 

  534.           data = static_mtype(mode, note, velo)

  535.           jacklib.midi_event_write(midi_out_buffer, 0, data, 3)

  536. 

  537.           jack_midi_out_data.task_done()

  538. 

  539.     return 0

  540. 

  541. 

  542. #--------------- main ------------------

  543. if __name__ == '__main__':

  544. 

  545.     # App initialization

  546.     app = QApplication(sys.argv)

  547.     app.setApplicationName("XY-Controller")

  548.     app.setApplicationVersion(VERSION)

  549.     app.setOrganizationName("falkTX")

  550.     #app.setWindowIcon(QIcon(":/48x48/xy-controller.png"))

  551. 

  552.     # Start jack

  553.     jack_status = jacklib.jack_status_t(0)

  554.     jack_client = jacklib.client_open("XY-Controller", jacklib.JackNullOption, jacklib.pointer(jack_status))

  555. 

  556.     if not jack_client:

  557.       QMessageBox.critical(None, app.translate("RenderW", "Error"), app.translate("RenderW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))

  558.       sys.exit(1)

  559. 

  560.     jack_midi_in_port = jacklib.port_register(jack_client, "midi_in", jacklib.JACK_DEFAULT_MIDI_TYPE, jacklib.JackPortIsInput, 0)

  561.     jack_midi_out_port = jacklib.port_register(jack_client, "midi_out", jacklib.JACK_DEFAULT_MIDI_TYPE, jacklib.JackPortIsOutput, 0)

  562.     jacklib.set_process_callback(jack_client, jack_process_callback, None)

  563.     jacklib.activate(jack_client)

  564. 

  565.     # Show GUI

  566.     gui = XYControllerW(None)

  567.     gui.show()

  568. 

  569.     # Set-up custom signal handling

  570.     set_up_signals(gui)

  571. 

  572.     # App-Loop

  573.     ret = app.exec_()

  574. 

  575.     # Close Jack

  576.     if (jack_client):

  577.       jacklib.deactivate(jack_client)

  578.       jacklib.client_close(jack_client)

  579. 

  580.     # Exit properly

  581.     sys.exit(ret)